@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-HT5OCGKN.js

@@ -0,0 +1,899 @@
+import {
+  findProviderCollisions
+} from "./chunk-FUUVZZUB.js";
+import {
+  validateRolesConfig
+} from "./chunk-32IYXIE5.js";
+import {
+  assertJudgeRoleCapabilities,
+  checkDefaultProviderEnablement,
+  judgeLayerBlocks,
+  loadProviderRegistryForCwd,
+  normalizeProviderId,
+  resolveDefaultProvider,
+  resolveJudgeBinding,
+  validateModelForProvider
+} from "./chunk-C3DH3NCY.js";
+import {
+  mutateUserState
+} from "./chunk-ZH4G3FU5.js";
+import {
+  BuildConfigSchema,
+  KNOWN_BUILD_CONFIG_ROOTS,
+  UserPreferencesSchema
+} from "./chunk-FKCG7K6H.js";
+import {
+  isProviderCliResolvable
+} from "./chunk-KKQKWAMF.js";
+import {
+  ProviderRegistry,
+  isInvalidExplicitConfigError
+} from "./chunk-QJ6OEH4K.js";
+
+// src/core/config/config-judge-validation.ts
+var ROLE_BY_JUDGE_TYPE = {
+  ai: "ai-primary",
+  "multi-lens": "multi-lens-technical"
+};
+var NO_PROVIDER_NAMED = new Error("no judge provider named in this layer");
+var INFERRED_SUFFIX = " (provider inferred from model)";
+function layerJudgeProvider(layer, judgeType) {
+  try {
+    const { provider } = resolveJudgeBinding({
+      layers: [{ source: "project", blocks: judgeLayerBlocks(layer, "", judgeType) }],
+      defaultProvider: () => {
+        throw NO_PROVIDER_NAMED;
+      },
+      defaultEffort: () => void 0
+    });
+    const keyPath = (provider.sourcePath ?? "").replace(INFERRED_SUFFIX, "");
+    return {
+      provider: normalizeProviderId(provider.value.trim()),
+      path: keyPath.split(".").filter(Boolean)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function collectJudgeCapabilityIssues(layer, knownProviderIds) {
+  const view = layer;
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const judgeType of Object.keys(ROLE_BY_JUDGE_TYPE)) {
+    const bound = view && layerJudgeProvider(view, judgeType);
+    if (!bound || !knownProviderIds.includes(bound.provider)) continue;
+    const dotted = bound.path.join(".");
+    if (seen.has(dotted)) continue;
+    try {
+      assertJudgeRoleCapabilities(ROLE_BY_JUDGE_TYPE[judgeType], bound.provider);
+    } catch (error) {
+      seen.add(dotted);
+      issues.push({ path: bound.path, message: `${dotted}: ${error.message}` });
+    }
+  }
+  return issues;
+}
+function collectLayerJudgeErrors(layer, knownProviderIds) {
+  return collectJudgeCapabilityIssues(layer, knownProviderIds).map((issue) => ({
+    code: "judge_provider_cannot_fill_role",
+    message: issue.message,
+    path: issue.path,
+    fixable: false
+  }));
+}
+function judgeErrorAtPath(layer, path, cwd = process.cwd()) {
+  let known;
+  try {
+    known = Object.keys(loadProviderRegistryForCwd(cwd).providers);
+  } catch {
+    return void 0;
+  }
+  return collectJudgeCapabilityIssues(layer, known).find(
+    (issue) => path.every((segment, index) => issue.path[index] === segment)
+  )?.message;
+}
+
+// src/core/config/config-provider-validation.ts
+var PROVIDER_VALUED_PATHS = [
+  { path: ["defaults", "provider"], code: "unknown_defaults_provider" },
+  { path: ["defaults", "judge", "provider"], code: "unknown_judge_provider" },
+  { path: ["defaults", "synthesis", "provider"], code: "unknown_synthesis_provider" },
+  { path: ["defaults", "splitter", "provider"], code: "unknown_splitter_provider" },
+  { path: ["judge", "provider"], code: "unknown_judge_provider" },
+  { path: ["judge", "ai", "provider"], code: "unknown_judge_provider" },
+  { path: ["judge", "multiLens", "provider"], code: "unknown_judge_provider" }
+];
+function valueAtPath(layer, path) {
+  let value = layer;
+  for (const segment of path) {
+    value = value !== null && typeof value === "object" ? value[segment] : void 0;
+  }
+  return value;
+}
+function collectLayerProviderErrors(layer, knownProviderIds, options = {}) {
+  if (knownProviderIds.length === 0) {
+    return [];
+  }
+  const errors = [];
+  for (const { path, code } of PROVIDER_VALUED_PATHS) {
+    const dotted = path.join(".");
+    if (options.includeDefaultsProvider === false && dotted === "defaults.provider") {
+      continue;
+    }
+    const value = valueAtPath(layer, path);
+    if (typeof value !== "string" || value.trim().length === 0) {
+      continue;
+    }
+    const providerId = value.trim();
+    if (knownProviderIds.includes(normalizeProviderId(providerId))) {
+      continue;
+    }
+    errors.push({
+      code,
+      message: `${dotted} '${providerId}' is not a known provider`,
+      path,
+      fixable: false,
+      fixSuggestion: `Use one of: ${knownProviderIds.join(", ")}`
+    });
+  }
+  return errors;
+}
+function providerErrorAtPath(layer, path, cwd = process.cwd()) {
+  let providers;
+  try {
+    providers = loadProviderRegistryForCwd(cwd).providers;
+  } catch {
+    return void 0;
+  }
+  const issue = collectLayerProviderErrors(layer, Object.keys(providers)).find(
+    (candidate) => path.every((segment, index) => candidate.path[index] === segment)
+  );
+  if (!issue) {
+    return void 0;
+  }
+  const enabled = Object.values(providers).filter((provider) => provider.enabled).sort((a, b) => a.order - b.order).map((provider) => provider.id);
+  return `${issue.message}. Available enabled providers: ${enabled.join(", ") || "(none)"}.`;
+}
+
+// src/core/config/first-time-setup-state.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readRawSetup(preferences) {
+  if (!preferences || !isRecord(preferences)) return {};
+  return isRecord(preferences.firstTimeSetup) ? preferences.firstTimeSetup : {};
+}
+function legacyDefaultsInitialized(preferences) {
+  if (!preferences || !isRecord(preferences)) return false;
+  const topLevel = readRawSetup(preferences);
+  if (topLevel.version !== 2 && topLevel.completed === true) return true;
+  const preferencesRoot = isRecord(preferences.preferences) ? preferences.preferences : void 0;
+  const cursor = preferencesRoot && isRecord(preferencesRoot.cursor) ? preferencesRoot.cursor : null;
+  const cursorSetup = cursor && isRecord(cursor.firstTimeSetup) ? cursor.firstTimeSetup : null;
+  return cursorSetup?.completed === true;
+}
+function readFirstTimeSetupState(preferences) {
+  const raw = readRawSetup(preferences);
+  if (raw.version === 2) {
+    const readyProviderIds = Array.isArray(raw.readyProviderIds) ? [
+      ...new Set(
+        raw.readyProviderIds.filter(
+          (id) => typeof id === "string" && id.length > 0
+        )
+      )
+    ] : [];
+    const defaultsInitialized = raw.defaultsInitialized === true;
+    const completed = defaultsInitialized && raw.completed === true && readyProviderIds.length > 0;
+    return {
+      version: 2,
+      defaultsInitialized,
+      ...typeof raw.defaultsInitializedAt === "string" ? { defaultsInitializedAt: raw.defaultsInitializedAt } : {},
+      completed,
+      ...completed && typeof raw.completedAt === "string" ? { completedAt: raw.completedAt } : {},
+      readyProviderIds
+    };
+  }
+  return {
+    version: 2,
+    defaultsInitialized: legacyDefaultsInitialized(preferences),
+    ...typeof raw.timestamp === "string" ? { defaultsInitializedAt: raw.timestamp } : {},
+    completed: false,
+    readyProviderIds: []
+  };
+}
+function isFirstTimeDefaultsInitialized(preferences) {
+  return readFirstTimeSetupState(preferences).defaultsInitialized;
+}
+function isFirstTimeSetupCompleted(preferences) {
+  return readFirstTimeSetupState(preferences).completed;
+}
+function markFirstTimeDefaultsInitialized(options = {}) {
+  return mutateUserState(
+    (state) => {
+      const existing = readFirstTimeSetupState(state);
+      const timestamp = options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+      const next = {
+        ...existing,
+        version: 2,
+        defaultsInitialized: true,
+        defaultsInitializedAt: existing.defaultsInitializedAt ?? timestamp
+      };
+      state.firstTimeSetup = next;
+      return next;
+    },
+    options.filePath ? { filePath: options.filePath } : {}
+  );
+}
+function markFirstTimeSetupCompleted(providerIds, options = {}) {
+  const normalized = [...new Set(providerIds.map((id) => id.trim()).filter(Boolean))];
+  if (normalized.length === 0) {
+    throw new Error("First-run completion requires at least one ready provider");
+  }
+  return mutateUserState(
+    (state) => {
+      const existing = readFirstTimeSetupState(state);
+      if (!existing.defaultsInitialized) {
+        throw new Error(
+          "First-run completion cannot be recorded before required user defaults are initialized"
+        );
+      }
+      const timestamp = options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+      const next = {
+        version: 2,
+        defaultsInitialized: existing.defaultsInitialized,
+        ...existing.defaultsInitializedAt ? { defaultsInitializedAt: existing.defaultsInitializedAt } : {},
+        completed: true,
+        completedAt: existing.completedAt ?? timestamp,
+        readyProviderIds: normalized
+      };
+      state.firstTimeSetup = next;
+      return next;
+    },
+    options.filePath ? { filePath: options.filePath } : {}
+  );
+}
+
+// src/core/config/reviewer-readiness-validation.ts
+var SET_REVIEWER_PROVIDER = "build config set roles.reviewer.provider";
+var SET_REVIEWER_POLICY_ADVISORY = "build config set roles.reviewer.policy advisory";
+function defaultDeps() {
+  return {
+    isProviderInstalled: isProviderCliResolvable,
+    listReviewerCandidateProviders: (cwd) => {
+      try {
+        const registry = loadProviderRegistryForCwd(cwd);
+        return ProviderRegistry.getEnabledProviders(registry).map((provider) => provider.id);
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function trimmedString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function rolePinnedProvider(roles, role) {
+  return trimmedString(asRecord(roles?.[role])?.provider);
+}
+function reviewGateBlocks(roles) {
+  const reviewer = asRecord(roles?.reviewer);
+  const policy = trimmedString(reviewer?.policy);
+  if (policy) return policy.startsWith("block:") || policy.startsWith("repair:");
+  return trimmedString(reviewer?.gate) === "high-severity-blocks";
+}
+function collectReviewerReadinessWarnings(config, cwd = process.cwd(), deps = defaultDeps()) {
+  const roles = asRecord(asRecord(config)?.roles);
+  if (!roles || !reviewGateBlocks(roles)) return [];
+  const pinnedReviewer = rolePinnedProvider(roles, "reviewer");
+  if (pinnedReviewer) {
+    if (deps.isProviderInstalled(pinnedReviewer)) return [];
+    return [
+      {
+        code: "reviewer_provider_not_installed",
+        message: `Reviewer provider "${pinnedReviewer}" is pinned by roles.reviewer.provider but its CLI is not installed, so the blocking review gate will fail reviewer preflight.`,
+        path: ["roles", "reviewer", "provider"],
+        recommendation: `Install the ${pinnedReviewer} CLI, pin an installed reviewer with \`${SET_REVIEWER_PROVIDER} <installed-provider>\`, or downgrade the gate with \`${SET_REVIEWER_POLICY_ADVISORY}\`.`
+      }
+    ];
+  }
+  const executor = rolePinnedProvider(roles, "executor");
+  const executorKey = executor?.toLowerCase();
+  const candidates = deps.listReviewerCandidateProviders(cwd).filter((providerId) => deps.isProviderInstalled(providerId));
+  const independent = executorKey ? candidates.filter((providerId) => providerId.toLowerCase() !== executorKey) : candidates.slice(1);
+  if (independent.length > 0) return [];
+  return [
+    {
+      code: "reviewer_no_independent_provider",
+      message: "No installed provider CLI is independent of the executor" + (executor ? ` provider "${executor}"` : "") + ", so automatic reviewer selection degrades to same-as-executor review and reviewer independence is lost.",
+      path: ["roles", "reviewer"],
+      recommendation: `Install a second provider CLI, or accept same-as-executor review with \`${SET_REVIEWER_POLICY_ADVISORY}\`.`
+    }
+  ];
+}
+
+// src/core/config/config-validator.ts
+function validateBuildConfig(config, options = {}) {
+  const {
+    strict: _strict = false,
+    includeWarnings = true,
+    includeSuggestions: _includeSuggestions = true,
+    cwd = process.cwd(),
+    layers = []
+  } = options;
+  const errors = [];
+  const warnings = [];
+  const suggestions = [];
+  errors.push(...detectUnknownRootKeys(config));
+  const schemaResult = BuildConfigSchema.safeParse(config);
+  if (!schemaResult.success) {
+    for (const zodError of schemaResult.error.issues) {
+      errors.push(parseZodError(zodError));
+    }
+  }
+  if (schemaResult.success) {
+    const validConfig = schemaResult.data;
+    validateCustomRules(validConfig, errors, warnings, suggestions, cwd);
+  }
+  if (schemaResult.success && includeWarnings) {
+    validateBusinessLogic(schemaResult.data, warnings, suggestions);
+    warnings.push(...collectReviewerReadinessWarnings(schemaResult.data, cwd));
+  }
+  for (const layer of layers) {
+    errors.push(...collectLayerModelErrors(layer.config, cwd, layer.label));
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings,
+    suggestions,
+    autoFixed: false
+  };
+}
+function detectUnknownRootKeys(config) {
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    return [];
+  }
+  const knownRoots = new Set(KNOWN_BUILD_CONFIG_ROOTS);
+  const unknownKeys = Object.keys(config).filter((key) => !knownRoots.has(key));
+  if (unknownKeys.length === 0) {
+    return [];
+  }
+  return [
+    {
+      code: "unrecognized_keys",
+      message: `Unrecognized configuration root key(s): ${unknownKeys.join(", ")}`,
+      path: [],
+      fixable: true,
+      fixSuggestion: `Remove unrecognized properties: ${unknownKeys.join(", ")}`
+    }
+  ];
+}
+function validateUserPreferences(preferences) {
+  const errors = [];
+  const warnings = [];
+  const suggestions = [];
+  const schemaResult = UserPreferencesSchema.safeParse(preferences);
+  if (!schemaResult.success) {
+    const zodErrors = schemaResult.error.issues;
+    for (const zodError of zodErrors) {
+      errors.push(parseZodError(zodError));
+    }
+  }
+  if (schemaResult.success) {
+    const validPrefs = schemaResult.data;
+    validateUserPreferencesLogic(validPrefs, errors, warnings, suggestions);
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings,
+    suggestions,
+    autoFixed: false
+  };
+}
+function parseZodError(zodError) {
+  const path = zodError.path.map(String);
+  const message = zodError.message;
+  let fixable = false;
+  let fixSuggestion;
+  let expected;
+  let received;
+  switch (zodError.code) {
+    case "invalid_type":
+      fixable = true;
+      if ("expected" in zodError) {
+        expected = String(zodError.expected);
+      }
+      if ("received" in zodError) {
+        received = String(zodError.received);
+      }
+      if (expected === "string" && received === "undefined") {
+        fixSuggestion = `Add a string value for '${path.join(".")}' or remove the property`;
+      } else if (expected === "boolean") {
+        fixSuggestion = `Use true or false for '${path.join(".")}'`;
+      }
+      break;
+    case "invalid_format": {
+      fixable = true;
+      const zodErrorWithOptions = zodError;
+      const options = zodErrorWithOptions.options?.join(", ") || "unknown options";
+      fixSuggestion = `Use one of: ${options}`;
+      break;
+    }
+    case "invalid_value": {
+      fixable = true;
+      const zodErrorWithExpected = zodError;
+      fixSuggestion = `Use the exact value: ${zodErrorWithExpected.expected}`;
+      break;
+    }
+    case "unrecognized_keys": {
+      fixable = true;
+      const zodErrorWithKeys = zodError;
+      fixSuggestion = `Remove unrecognized properties: ${zodErrorWithKeys.keys?.join(", ")}`;
+      break;
+    }
+  }
+  return {
+    code: zodError.code,
+    message,
+    path,
+    expected,
+    received,
+    fixable,
+    fixSuggestion
+  };
+}
+function hasEnabledProperty(value) {
+  return typeof value === "object" && value !== null && "enabled" in value;
+}
+var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+function normalizeProviderId2(value) {
+  const provider = value?.toLowerCase().trim();
+  return provider && PROVIDER_ID_PATTERN.test(provider) ? normalizeProviderId(provider) : null;
+}
+function enabledProvidersFromConfig(config) {
+  if (!config.providers) {
+    return null;
+  }
+  return Object.entries(config.providers).filter(([_, provider]) => hasEnabledProperty(provider) && provider.enabled).map(([name]) => name);
+}
+function providerEnabledFromConfig(config, provider) {
+  const providers = config.providers;
+  const providerConfig = providers?.[provider];
+  return hasEnabledProperty(providerConfig) ? providerConfig.enabled : void 0;
+}
+function addDisabledProviderError(provider, path, errors, enabledProviders) {
+  errors.push({
+    code: "invalid_default_provider",
+    message: `Default provider '${provider}' is not enabled`,
+    path,
+    fixable: true,
+    fixSuggestion: `Either enable ${provider} provider or change the default provider to one of: ${enabledProviders.join(", ") || "(none)"}`
+  });
+}
+function validateProviderEnabled(providerValue, path, config, errors, cwd) {
+  const provider = normalizeProviderId2(providerValue);
+  if (!provider) {
+    if (providerValue !== void 0 && providerValue.trim() !== "") {
+      errors.push({
+        code: "invalid_provider_format",
+        message: `Provider '${providerValue}' has an invalid format`,
+        path,
+        fixable: false,
+        fixSuggestion: "Use lowercase letters, digits, underscores, or hyphens"
+      });
+    }
+    return;
+  }
+  if (providerEnabledFromConfig(config, provider) === false) {
+    addDisabledProviderError(provider, path, errors, enabledProvidersFromConfig(config) ?? []);
+    return;
+  }
+  try {
+    const check = checkDefaultProviderEnablement(provider, cwd);
+    if (!check.providerKnown) {
+      errors.push({
+        code: "unknown_defaults_provider",
+        message: `Default provider '${provider}' is not a known provider`,
+        path,
+        fixable: false,
+        fixSuggestion: `Use one of: ${check.knownProviders.join(", ")}`
+      });
+      return;
+    }
+    if (!check.providerEnabled) {
+      addDisabledProviderError(provider, path, errors, check.enabledProviders);
+    }
+  } catch (error) {
+    if (isInvalidExplicitConfigError(error)) {
+      throw error;
+    }
+    errors.push({
+      code: "provider_registry_unavailable",
+      message: `Could not validate default provider '${provider}' against providers.yaml: ${error instanceof Error ? error.message : String(error)}`,
+      path,
+      fixable: false
+    });
+  }
+}
+function knownProviderIdsForCwd(cwd) {
+  try {
+    return Object.keys(loadProviderRegistryForCwd(cwd).providers);
+  } catch {
+    return [];
+  }
+}
+function asConfigLayer(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function modelErrorFor(provider, model, path, cwd, label) {
+  const providerId = normalizeProviderId2(provider);
+  if (!providerId || typeof model !== "string" || model.trim().length === 0) {
+    return [];
+  }
+  if (!knownProviderIdsForCwd(cwd).includes(providerId)) {
+    return [];
+  }
+  const dotted = path.join(".");
+  try {
+    validateModelForProvider(providerId, model, label ? `${label}#${dotted}` : dotted, cwd);
+    return [];
+  } catch (error) {
+    return [
+      {
+        code: "unknown_model_for_provider",
+        message: error instanceof Error ? error.message : String(error),
+        path,
+        fixable: false
+      }
+    ];
+  }
+}
+function collectLayerModelErrors(layer, cwd = process.cwd(), label) {
+  const config = asConfigLayer(layer);
+  if (!config) {
+    return [];
+  }
+  const errors = [];
+  if (config.defaults?.model) {
+    let provider = config.defaults.provider;
+    try {
+      provider ??= resolveDefaultProvider(void 0, cwd).value;
+    } catch {
+    }
+    errors.push(
+      ...modelErrorFor(provider, config.defaults.model, ["defaults", "model"], cwd, label)
+    );
+  }
+  for (const [providerId, defaults] of Object.entries(config.defaults?.providers ?? {})) {
+    for (const key of ["model", "fastModel"]) {
+      const path = ["defaults", "providers", providerId, key];
+      errors.push(...modelErrorFor(providerId, defaults?.[key], path, cwd, label));
+    }
+  }
+  for (const [providerId, provider] of Object.entries(config.providers ?? {})) {
+    const model = provider?.model;
+    const path = ["providers", providerId, "model"];
+    errors.push(...modelErrorFor(providerId, model, path, cwd, label));
+  }
+  return errors;
+}
+function modelErrorAtPath(layer, path, cwd = process.cwd()) {
+  const dotted = path.join(".");
+  return collectLayerModelErrors(layer, cwd).find((issue) => issue.path.join(".") === dotted)?.message;
+}
+function registryErrorAtPath(layer, path, cwd = process.cwd()) {
+  return providerErrorAtPath(layer, path, cwd) ?? modelErrorAtPath(layer, path, cwd) ?? judgeErrorAtPath(layer, path, cwd);
+}
+function validateCustomRules(config, errors, warnings, _suggestions, cwd) {
+  if (config.providers) {
+    const enabledProviders = enabledProvidersFromConfig(config) ?? [];
+    if (enabledProviders.length === 0) {
+      errors.push({
+        code: "no_enabled_providers",
+        message: "At least one provider must be enabled",
+        path: ["providers"],
+        fixable: true,
+        fixSuggestion: "Set at least one provider.enabled to true"
+      });
+    }
+    if (!config.defaults?.provider) {
+      const legacyProvider = normalizeProviderId2(config.defaultProvider);
+      if (legacyProvider && providerEnabledFromConfig(config, legacyProvider) === false) {
+        addDisabledProviderError(legacyProvider, ["defaultProvider"], errors, enabledProviders);
+      }
+    }
+  }
+  validateProviderEnabled(config.defaults?.provider, ["defaults", "provider"], config, errors, cwd);
+  if (!config.defaults?.provider) {
+    validateProviderEnabled(config.defaultProvider, ["defaultProvider"], config, errors, cwd);
+  }
+  if (config.defaultProvider && config.defaults?.provider) {
+    const legacyProvider = normalizeProviderId2(config.defaultProvider);
+    const canonicalProvider = normalizeProviderId2(config.defaults.provider);
+    if (legacyProvider && canonicalProvider && legacyProvider !== canonicalProvider) {
+      warnings.push({
+        code: "default_provider_source_drift",
+        message: `defaultProvider '${legacyProvider}' differs from defaults.provider '${canonicalProvider}'; defaults.provider is the canonical runtime default`,
+        path: ["defaultProvider"],
+        recommendation: "Remove defaultProvider or set it to match defaults.provider"
+      });
+    }
+  }
+  const knownProviderIds = knownProviderIdsForCwd(cwd);
+  if (knownProviderIds.length > 0) {
+    const defaultsProvider = config.defaults?.provider;
+    if (defaultsProvider && !knownProviderIds.includes(normalizeProviderId(defaultsProvider.trim()))) {
+      errors.push({
+        code: "unknown_defaults_provider",
+        message: `defaults.provider '${defaultsProvider}' is not a known provider`,
+        path: ["defaults", "provider"],
+        fixable: false,
+        fixSuggestion: `Use one of: ${knownProviderIds.join(", ")}`
+      });
+    }
+    const askPresets = config.ask?.presets;
+    if (askPresets) {
+      for (const presetName of findProviderCollisions(Object.keys(askPresets), knownProviderIds)) {
+        errors.push({
+          code: "ask_preset_provider_collision",
+          message: `ask.presets name '${presetName}' collides with a registered provider id`,
+          path: ["ask", "presets", presetName],
+          fixable: false,
+          fixSuggestion: "Rename the preset; positional preset names must not shadow providers"
+        });
+      }
+    }
+    errors.push(
+      ...collectLayerProviderErrors(config, knownProviderIds, { includeDefaultsProvider: false }),
+      ...collectLayerJudgeErrors(config, knownProviderIds)
+    );
+    for (const rolesError of validateRolesConfig(
+      config.roles,
+      knownProviderIds
+    )) {
+      errors.push({
+        code: rolesError.code,
+        message: rolesError.message,
+        path: rolesError.path,
+        fixable: false,
+        fixSuggestion: rolesError.code.startsWith("unknown_") ? `Use one of: ${knownProviderIds.join(", ")}` : void 0
+      });
+    }
+  }
+  if (config.quality?.coverage?.threshold) {
+    const threshold = config.quality.coverage.threshold;
+    if (threshold < 0 || threshold > 100) {
+      errors.push({
+        code: "invalid_coverage_threshold",
+        message: "Coverage threshold must be between 0 and 100",
+        path: ["quality", "coverage", "threshold"],
+        fixable: true,
+        fixSuggestion: "Set threshold to a value between 0 and 100"
+      });
+    }
+  }
+  if (config.execution?.defaultTimeout) {
+    const timeout = config.execution.defaultTimeout;
+    if (timeout < 1 || timeout > 180) {
+      warnings.push({
+        code: "extreme_timeout",
+        message: `Timeout of ${timeout} minutes is unusual`,
+        path: ["execution", "defaultTimeout"],
+        recommendation: "Consider using a timeout between 5 and 60 minutes"
+      });
+    }
+  }
+}
+function validateBusinessLogic(config, warnings, suggestions) {
+  if (!config.telemetry?.enabled) {
+    suggestions.push({
+      type: "improvement",
+      message: "Enable telemetry to track variant performance and improve recommendations",
+      path: ["telemetry", "enabled"],
+      action: "Set telemetry.enabled to true"
+    });
+  }
+  if (config.quality?.coverage?.threshold && config.quality.coverage.threshold < 70) {
+    suggestions.push({
+      type: "best-practice",
+      message: "Consider increasing coverage threshold for better code quality",
+      path: ["quality", "coverage", "threshold"],
+      action: "Set coverage.threshold to 80 or higher"
+    });
+  }
+  const removedStrategyKeys = collectRemovedStrategyConfigKeys(config);
+  if (removedStrategyKeys.length > 0) {
+    warnings.push({
+      code: "removed_strategy_config",
+      message: `Ignored removed variant strategy config: ${removedStrategyKeys.join(", ")}`,
+      path: ["variants", "strategies"],
+      recommendation: "Remove these keys. The variant strategy axis was removed (ADR-025); use provider, model, or reasoning effort for variant diversity."
+    });
+  }
+}
+function collectRemovedStrategyConfigKeys(config) {
+  const found = [];
+  if (config.defaults?.strategy !== void 0) {
+    found.push("defaults.strategy");
+  }
+  for (const [providerId, providerDefaults] of Object.entries(config.defaults?.providers ?? {})) {
+    if (providerDefaults?.strategy !== void 0) {
+      found.push(`defaults.providers.${providerId}.strategy`);
+    }
+  }
+  for (const [providerId, providerConfig] of Object.entries(config.providers ?? {})) {
+    if (providerConfig?.strategy !== void 0) {
+      found.push(`providers.${providerId}.strategy`);
+    }
+  }
+  if (config.variants?.strategies !== void 0) {
+    found.push("variants.strategies");
+  }
+  for (const mode of ["speed", "quality", "cost"]) {
+    const variants = config.optimization?.[mode]?.variants;
+    if (variants?.some((variant) => variant?.strategy !== void 0)) {
+      found.push(`optimization.${mode}.variants[].strategy`);
+    }
+  }
+  return found;
+}
+function validateUserPreferencesLogic(preferences, _errors, warnings, suggestions) {
+  const cursorPrefs = preferences?.preferences?.cursor;
+  if (!cursorPrefs) {
+    return;
+  }
+  const cursorModel = cursorPrefs.defaultModel;
+  const validModels = [
+    "auto",
+    "cheetah",
+    "sonnet-4.5",
+    "sonnet-4.5-thinking",
+    "gpt-5",
+    "gpt-5-codex",
+    "opus-4.1",
+    "grok"
+  ];
+  if (cursorModel && !validModels.includes(cursorModel)) {
+    warnings.push({
+      code: "unknown_cursor_model",
+      message: `Unknown cursor model: ${cursorModel}`,
+      path: ["preferences", "cursor", "defaultModel"],
+      recommendation: `Use one of: ${validModels.join(", ")}`
+    });
+  }
+  if (!isFirstTimeDefaultsInitialized(preferences)) {
+    suggestions.push({
+      type: "improvement",
+      message: "Initialize user defaults for optimal experience",
+      path: ["firstTimeSetup"],
+      action: "Run build provider setup --first-run"
+    });
+  }
+  const usageHistory = cursorPrefs.usageHistory;
+  if (usageHistory?.lastUsed && usageHistory.usageCount === 0) {
+    warnings.push({
+      code: "inconsistent_usage_history",
+      message: "Last used model specified but usage count is 0",
+      path: ["preferences", "cursor", "usageHistory"],
+      recommendation: "Update usage count to match actual usage"
+    });
+  }
+}
+function generateValidationReport(result) {
+  const lines = [];
+  if (result.isValid) {
+    lines.push("Configuration is valid");
+  } else {
+    lines.push("Configuration has errors");
+  }
+  if (result.errors.length > 0) {
+    lines.push("\nErrors:");
+    for (const error of result.errors) {
+      lines.push(`  ${error.path.join(".")}: ${error.message}`);
+      if (error.fixSuggestion) {
+        lines.push(`    Fix: ${error.fixSuggestion}`);
+      }
+    }
+  }
+  if (result.warnings.length > 0) {
+    lines.push("\nWarnings:");
+    for (const warning of result.warnings) {
+      lines.push(`  ${warning.path.join(".")}: ${warning.message}`);
+      if (warning.recommendation) {
+        lines.push(`    Recommendation: ${warning.recommendation}`);
+      }
+    }
+  }
+  if (result.suggestions.length > 0) {
+    lines.push("\nSuggestions:");
+    for (const suggestion of result.suggestions) {
+      lines.push(`  - ${suggestion.message}`);
+      if (suggestion.action) {
+        lines.push(`    Action: ${suggestion.action}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function readCanonicalDefaultProvider(config) {
+  const defaults = config.defaults;
+  if (typeof defaults !== "object" || defaults === null) {
+    return void 0;
+  }
+  const provider = defaults.provider;
+  return typeof provider === "string" && provider.trim().length > 0 ? provider.trim() : void 0;
+}
+function autoFixConfig(config) {
+  const changes = [];
+  const edits = [];
+  const fixedConfig = typeof config === "object" && config !== null ? structuredClone(config) : {};
+  if (!fixedConfig.defaultProvider && readCanonicalDefaultProvider(fixedConfig) === void 0 && typeof fixedConfig.providers === "object" && fixedConfig.providers !== null) {
+    const providers = fixedConfig.providers;
+    const enabledProviders = Object.entries(providers).filter(([_, provider]) => hasEnabledProperty(provider) && provider.enabled).map(([name]) => name);
+    if (enabledProviders.length > 0) {
+      fixedConfig.defaultProvider = enabledProviders[0];
+      const description = `Set defaultProvider to '${fixedConfig.defaultProvider}'`;
+      changes.push(description);
+      edits.push({
+        code: "default-provider",
+        path: ["defaultProvider"],
+        value: fixedConfig.defaultProvider,
+        description
+      });
+    }
+  }
+  if (typeof fixedConfig.providers === "object" && fixedConfig.providers !== null) {
+    const providers = fixedConfig.providers;
+    const enabledCount = Object.values(providers).filter(
+      (p) => hasEnabledProperty(p) && p.enabled
+    ).length;
+    if (enabledCount === 0) {
+      const firstRepairable = Object.entries(providers).find(
+        ([, provider]) => hasEnabledProperty(provider)
+      );
+      if (firstRepairable !== void 0) {
+        const [name, provider] = firstRepairable;
+        provider.enabled = true;
+        const description = `Enabled '${name}' provider (no providers were enabled)`;
+        changes.push(description);
+        edits.push({
+          code: "enable-provider",
+          path: ["providers", name, "enabled"],
+          value: true,
+          description
+        });
+      }
+    }
+  }
+  const validationResult = validateBuildConfig(fixedConfig);
+  const remainingErrors = validationResult.errors.filter((error) => !error.fixable);
+  return {
+    fixedConfig,
+    changes,
+    edits,
+    remainingErrors
+  };
+}
+
+export {
+  readFirstTimeSetupState,
+  isFirstTimeDefaultsInitialized,
+  isFirstTimeSetupCompleted,
+  markFirstTimeDefaultsInitialized,
+  markFirstTimeSetupCompleted,
+  validateBuildConfig,
+  validateUserPreferences,
+  collectLayerModelErrors,
+  modelErrorAtPath,
+  registryErrorAtPath,
+  collectRemovedStrategyConfigKeys,
+  generateValidationReport,
+  autoFixConfig
+};
+//# sourceMappingURL=chunk-HT5OCGKN.js.map