@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-RGJU63FV.js

@@ -0,0 +1,1717 @@
+import {
+  AGENT_DEFAULT,
+  buildExecutionPreview,
+  buildJudgeRow,
+  describeInstructionsImport,
+  fastFallbackLabel,
+  formatEffort,
+  formatShown,
+  formatSummaryJudge,
+  summarizeJudgeRow
+} from "./chunk-7NVJMH52.js";
+import {
+  resolveReviewerEligibility
+} from "./chunk-JDCZQZU7.js";
+import {
+  renderJsonError,
+  renderJsonResult
+} from "./chunk-5YDE3Q62.js";
+import {
+  resolveRepoRootForBuildDir
+} from "./chunk-UB7LQITD.js";
+import {
+  readJudgeTypeEnv,
+  resolveCompeteConfig
+} from "./chunk-EN62WLFD.js";
+import {
+  registry
+} from "./chunk-7HYBSRPZ.js";
+import {
+  ExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import {
+  ConfigManager
+} from "./chunk-W4BAIQ6L.js";
+import {
+  isSensitiveConfigPath,
+  redactSensitiveConfig
+} from "./chunk-3M57DADF.js";
+import {
+  autoFixConfig,
+  generateValidationReport,
+  validateBuildConfig
+} from "./chunk-HT5OCGKN.js";
+import {
+  resolveExecutionRoles,
+  resolveExecutorRoleTarget
+} from "./chunk-32IYXIE5.js";
+import {
+  mergeConfigSources
+} from "./chunk-U5KS22IN.js";
+import {
+  enterReadOnlyProviderOrderView,
+  formatResolvedValue,
+  resolveConfig,
+  resolveDefaultProvider
+} from "./chunk-C3DH3NCY.js";
+import {
+  BooleanFlagSchema,
+  ExistingFilePathSchema,
+  FilePathSchema,
+  formatValidationErrors,
+  validateCommandOptions
+} from "./chunk-I7SCBHJN.js";
+import {
+  getConfigDiagnostics,
+  loadActiveProfile,
+  loadAllConfigSources,
+  profileToBuildConfig
+} from "./chunk-M4BUEXXF.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  isBuildConfigReadError
+} from "./chunk-FKCG7K6H.js";
+import {
+  normalizeEngineId
+} from "./chunk-KKQKWAMF.js";
+import {
+  InvalidConfigContentError,
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  findProjectRoot,
+  getConfigPaths
+} from "./chunk-35J4NE6S.js";
+import {
+  ValidationError
+} from "./chunk-RRC5BL7B.js";
+import {
+  getUserConfigDir,
+  getUserConfigFile
+} from "./chunk-56WPYDJH.js";
+import {
+  BUILD_MATRIX_BORDERLINE_MARGIN,
+  BUILD_MATRIX_CLOSE_CALL_MARGIN,
+  BUILD_MATRIX_CONFIDENCE_THRESHOLD,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+import {
+  sanitizeString,
+  sanitizeValue
+} from "./chunk-CPSVQR2I.js";
+
+// src/cli/commands/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import chalk3 from "chalk";
+import { Command } from "commander";
+import { z } from "zod";
+
+// src/core/config/project-config-repair.ts
+var UNRESOLVED_REASON = {
+  "default-provider": "No default provider is set, and the project config declares no enabled provider to name as the default",
+  "enable-provider": "No provider is enabled, and the project config declares no provider to enable"
+};
+function resolveProjectConfigRepair(mergedEdits, projectConfig) {
+  const projectEdits = autoFixConfig(projectConfig ?? {}).edits;
+  const repair = { edits: [], applied: [], unresolved: [] };
+  for (const mergedEdit of mergedEdits) {
+    const projectEdit = projectEdits.find((edit) => edit.code === mergedEdit.code);
+    if (projectEdit === void 0) {
+      repair.unresolved.push(UNRESOLVED_REASON[mergedEdit.code]);
+      continue;
+    }
+    repair.edits.push(projectEdit);
+    repair.applied.push(projectEdit.description);
+  }
+  return repair;
+}
+async function loadUnvalidatedConfig(cwd = process.cwd()) {
+  const sources = await loadAllConfigSources(cwd);
+  return { config: mergeConfigSources(sources).mergedConfig, sources };
+}
+
+// src/cli/commands/config-precedence-sources.ts
+function listSourceProviderModels(source, resolved) {
+  const entries = /* @__PURE__ */ new Map();
+  const data = source.data;
+  for (const [provider, providerDefaults] of Object.entries(data?.defaults?.providers ?? {})) {
+    if (providerDefaults?.model) entries.set(provider, providerDefaults.model);
+  }
+  for (const [provider, providerConfig] of Object.entries(data?.providers ?? {})) {
+    if (!entries.has(provider) && providerConfig && "model" in providerConfig && providerConfig.model) {
+      entries.set(provider, String(providerConfig.model));
+    }
+  }
+  if (source.type === "env") {
+    for (const [provider, model] of Object.entries(resolved.providerModels)) {
+      if ((model.source === "env" || model.source === "env-legacy") && !entries.has(provider)) {
+        entries.set(provider, model.value);
+      }
+    }
+  }
+  return [...entries];
+}
+function sourcesForPrecedence(sources, resolved) {
+  const envSource = { type: "env", priority: 90, data: {}, exists: true };
+  const needsEnvSource = !sources.some((source) => source.type === "env") && listSourceProviderModels(envSource, resolved).length > 0;
+  return [...sources, ...needsEnvSource ? [envSource] : []].sort(
+    (a, b) => b.priority - a.priority
+  );
+}
+
+// src/cli/commands/config-resolved-render.ts
+import chalk from "chalk";
+function jobLines(label, job) {
+  return [
+    `  ${label} Provider: ${formatShown(job.provider)}`,
+    `  ${label} Model: ${formatShown(job.model)}`,
+    `  ${label} Reasoning: ${formatEffort(job.reasoningEffort)}`,
+    ...job.error ? [`  ${label} Error: ${job.error}`] : []
+  ];
+}
+function formatResolvedSummary(resolved, view) {
+  const lines = [
+    "Build Configuration:",
+    `  Default Provider: ${formatResolvedValue(resolved.defaultProvider)}`,
+    `  Default Model: ${formatResolvedValue(resolved.defaultModel)}`,
+    `  Default Reasoning Effort: ${view.run.reasoningEffort}`,
+    `  planExecute.blockerMode: ${formatResolvedValue(resolved.planExecute.blockerMode)}`,
+    ...jobLines("Synthesis", view.synthesis),
+    ...jobLines("Splitter", view.splitter),
+    "",
+    "Judges:"
+  ];
+  for (const judge of view.judges) {
+    lines.push(`  ${judge.type}${judge.isDefault ? " (default type)" : ""}:`);
+    lines.push(`    provider: ${formatShown(judge.provider)}`);
+    lines.push(`    model: ${formatShown(judge.model)}`);
+    lines.push(`    reasoning: ${formatEffort(judge.reasoningEffort)}`);
+    if (judge.error) lines.push(`    error: ${judge.error}`);
+  }
+  lines.push("", "Provider Models:");
+  for (const provider of view.providers) {
+    lines.push(`  ${provider.id}${provider.installed ? "" : " (CLI not installed)"}:`);
+    lines.push(`    model: ${formatShown(provider.model)}`);
+    lines.push(`    reasoningEffort: ${formatEffort(provider.reasoningEffort)}`);
+    if (provider.nativeDefaults) {
+      lines.push("    Native configured preferences (no execution observed):");
+      for (const field of ["model", "reasoningEffort", "serviceTier"]) {
+        const value = provider.nativeDefaults[field];
+        lines.push(`      ${field}: ${value ? formatShown(value) : "unset (native CLI default)"}`);
+      }
+      for (const limitation of provider.nativeDefaults.limitations ?? [])
+        lines.push(`      scope: ${limitation}`);
+      if (provider.nativeDefaults.unavailablePaths?.length) {
+        lines.push(
+          `      unavailable settings: ${provider.nativeDefaults.unavailablePaths.join(", ")}`
+        );
+      }
+    }
+    lines.push(
+      `    fast: ${provider.fastModel ? formatShown(provider.fastModel) : fastFallbackLabel(provider.model.value)}`
+    );
+    if (provider.judge) {
+      lines.push(`    judge: ${formatShown(provider.judge.model)}`);
+      lines.push(`    judge reasoning: ${formatEffort(provider.judge.reasoningEffort)}`);
+    }
+    if (provider.error) lines.push(`    error: ${provider.error}`);
+  }
+  lines.push(`Registry sources: ${view.registrySources.join(", ") || "none"}`);
+  lines.push("", "Ask:", `  build ask: ${view.ask.summary}`);
+  const presets = view.ask.presets.map((preset) => `${preset.name} (${preset.source})`);
+  lines.push(`  presets: ${presets.join(", ") || "none"}`);
+  if (view.ask.error) lines.push(`  error: ${view.ask.error}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function printExecutionPreview(resolved, view, write) {
+  write(chalk.bold.blue("Execution Preview\n"));
+  write(`  run.provider:   ${chalk.cyan(view.run.provider)}`);
+  write(`  run.model:      ${chalk.cyan(view.run.model)}`);
+  write(`  run.reasoning:  ${chalk.cyan(view.run.reasoningEffort)}`);
+  write(`  run.transport:  ${chalk.cyan(view.run.transport)}`);
+  const inherit = view.inheritance;
+  write(
+    `  instructions.inheritance: ${chalk.cyan(`automated ${inherit.automated}; ask ${inherit.ask}`)}`
+  );
+  if ("error" in view.compete) {
+    write(`  compete:        ${chalk.yellow(view.compete.error)}`);
+  } else {
+    const compete = view.compete;
+    write(
+      `  compete.variants: ${chalk.cyan(compete.variants.join(", "))} ${chalk.gray(`[${compete.sources.variants}]`)}`
+    );
+    write(
+      `  compete.judge:    ${chalk.cyan(compete.judge)} ${chalk.gray(`[${compete.sources.judge}]`)}`
+    );
+    if (compete.judgeRun) {
+      write(
+        `  compete.judgeRun: ${chalk.cyan(compete.judgeRun)} ${chalk.gray(`[${compete.sources.judgeRun ?? compete.sources.judge}]`)}`
+      );
+    }
+  }
+  write(
+    `  env.overrides:  ${chalk.cyan(view.envOverrides.length > 0 ? view.envOverrides.join(", ") : "none")}`
+  );
+  write(`  git.attribution: ${chalk.cyan(formatResolvedValue(resolved.gitAttribution))}`);
+}
+function src(value) {
+  return chalk.gray(`[${value.sourcePath ?? value.source}]`);
+}
+function roleLine(label, value, unset) {
+  return value ? `  ${label} ${chalk.cyan(String(value.value))} ${src(value)}` : `  ${label} ${chalk.cyan(unset)}`;
+}
+function printResolvedRoles(roles, write) {
+  const { orchestrator, executor, reviewer } = roles;
+  write(chalk.bold.blue("\nExecution Roles\n"));
+  write(roleLine("roles.orchestrator.provider:", orchestrator.provider, "not set (run provider)"));
+  write(roleLine("roles.orchestrator.model:   ", orchestrator.model, "not set (run model)"));
+  if (orchestrator.fallbackModel) {
+    write(roleLine("roles.orchestrator.fallback:", orchestrator.fallbackModel, ""));
+  }
+  write(roleLine("roles.orchestrator.reasoning:", orchestrator.reasoningEffort, AGENT_DEFAULT));
+  write(roleLine("roles.executor.provider: ", executor.provider, ""));
+  write(roleLine("roles.executor.model:    ", executor.model, ""));
+  write(roleLine("roles.executor.subagents:", executor.subagents, ""));
+  write(roleLine("roles.executor.transport:", executor.transport, ""));
+  write(roleLine("roles.executor.reasoning:", executor.reasoningEffort, AGENT_DEFAULT));
+  write(roleLine("roles.reviewer.provider: ", reviewer.provider, ""));
+  write(roleLine("roles.reviewer.model:    ", reviewer.model, ""));
+  write(roleLine("roles.reviewer.reasoning:", reviewer.reasoningEffort, AGENT_DEFAULT));
+  write(roleLine("roles.reviewer.policy:   ", reviewer.policy, ""));
+  write(roleLine("roles.reviewer.gate:     ", reviewer.gate, ""));
+  write(roleLine("roles.reviewer.threshold:", reviewer.threshold, ""));
+  if (reviewer.policyNotice) {
+    write(`  ${chalk.yellow("Warning:")} ${reviewer.policyNotice}`);
+  }
+  if (roles.sameVendorReview) {
+    write(
+      `  ${chalk.yellow("Note:")} reviewer matches an executor provider; executor separation is unavailable`
+    );
+  }
+}
+
+// src/cli/commands/config-set-shadow.ts
+import chalk2 from "chalk";
+var CANONICAL_CONFIG_PATHS = {
+  defaultProvider: "defaults.provider"
+};
+function canonicalConfigPath(path) {
+  return CANONICAL_CONFIG_PATHS[path] ?? path;
+}
+function readConfigPath(config, path) {
+  let current = config;
+  for (const segment of path.split(".").filter(Boolean)) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+async function inspectConfigSetShadow(path, sources) {
+  const resolvedPath = canonicalConfigPath(path);
+  const effectiveValue = readConfigPath(await sources.loadEffectiveConfig(), resolvedPath);
+  const profile = sources.loadProfileLayer();
+  if (!profile || readConfigPath(profile.config, resolvedPath) === void 0) {
+    return { effectiveValue };
+  }
+  return { effectiveValue, shadowingProfile: profile.name };
+}
+function buildConfigSetShadowLines(path, shadow, formatValue) {
+  if (shadow.effectiveValue === void 0) return void 0;
+  const lines = {
+    effective: `  Effective: ${formatValue(path, shadow.effectiveValue)}`
+  };
+  if (shadow.shadowingProfile !== void 0) {
+    lines.warning = `Warning: active profile "${shadow.shadowingProfile}" also sets ${path}; profile scope takes precedence over project, so the effective value above is not the project value.`;
+  }
+  return lines;
+}
+function defaultConfigSetShadowSources(cwd = process.cwd()) {
+  return {
+    loadEffectiveConfig: async () => {
+      try {
+        const merged = await new ConfigManager({ cwd }).loadConfig({}, true);
+        return merged.config;
+      } catch {
+        return void 0;
+      }
+    },
+    loadProfileLayer: () => {
+      const profile = loadActiveProfile();
+      if (!profile) return void 0;
+      try {
+        return { name: profile.name, config: profileToBuildConfig(profile) };
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+async function printConfigSetShadowNotice(path, formatValue, sources = defaultConfigSetShadowSources()) {
+  const shadow = await inspectConfigSetShadow(path, sources);
+  const lines = buildConfigSetShadowLines(path, shadow, formatValue);
+  if (!lines) return;
+  console.log(chalk2.gray(lines.effective));
+  if (lines.warning !== void 0) {
+    console.log(chalk2.yellow(lines.warning));
+  }
+}
+
+// src/cli/commands/model-alias-listing.ts
+function projectModelAliases(providerConfig) {
+  const record = {};
+  if (!providerConfig || typeof providerConfig !== "object") return record;
+  const aliases = providerConfig.aliases;
+  const models = aliases && typeof aliases === "object" ? aliases.models : null;
+  if (!models || typeof models !== "object") return record;
+  for (const [key, value] of Object.entries(models)) {
+    if (typeof value === "string") record[key] = value;
+  }
+  return record;
+}
+function projectModelAliasListing(providers, providerFilter) {
+  const out = {};
+  for (const [providerId, providerConfig] of Object.entries(providers ?? {})) {
+    if (providerFilter && providerId.toLowerCase() !== String(providerFilter).toLowerCase()) {
+      continue;
+    }
+    const aliases = projectModelAliases(providerConfig);
+    if (Object.keys(aliases).length > 0) out[providerId] = aliases;
+  }
+  return out;
+}
+function sortedModelAliasListing(listing) {
+  return Object.keys(listing).sort().map((providerId) => ({
+    providerId,
+    models: Object.entries(listing[providerId] ?? {}).sort(([a], [b]) => a.localeCompare(b))
+  }));
+}
+
+// src/cli/commands/config.ts
+var REDACTED_CONFIG_VALUE = "<redacted>";
+function qualityGateStatus(enabled) {
+  return enabled ? chalk3.green("OK") : chalk3.gray("Disabled");
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitizeConfigStrings(value) {
+  if (typeof value === "string") {
+    return sanitizeString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeConfigStrings(item));
+  }
+  if (isPlainRecord(value)) {
+    const sanitized = {};
+    for (const [key, item] of Object.entries(value)) {
+      sanitized[key] = sanitizeConfigStrings(item);
+    }
+    return sanitized;
+  }
+  return value;
+}
+function redactConfigValueForDisplay(path, value) {
+  if (isSensitiveConfigPath(path)) {
+    return REDACTED_CONFIG_VALUE;
+  }
+  return sanitizeConfigStrings(redactSensitiveConfig(value, path.split(".").filter(Boolean)));
+}
+function formatConfigGetValueForDisplay(path, value) {
+  const displayValue = redactConfigValueForDisplay(path, value);
+  return typeof displayValue === "string" ? displayValue : JSON.stringify(displayValue, null, 2);
+}
+function formatConfigSetValueForDisplay(path, value) {
+  if (isSensitiveConfigPath(path)) {
+    return "<redacted>";
+  }
+  const displayValue = redactConfigValueForDisplay(path, value);
+  return typeof displayValue === "string" ? displayValue : JSON.stringify(displayValue);
+}
+function buildConfigGetJsonPayload(path, scope, value) {
+  const found = value !== void 0;
+  return {
+    path,
+    scope,
+    found,
+    value: found ? redactConfigValueForDisplay(path, value) : null
+  };
+}
+function buildConfigScopeMissLines(path, scope, alternateScopeValue) {
+  const lines = [`${path} is not set (scope: ${scope})`];
+  if (alternateScopeValue !== void 0) {
+    const alternateScope = scope === "project" ? "user" : "project";
+    const retryHint = alternateScope === "user" ? "build config get --scope user" : "build config get";
+    lines.push(
+      `  Tip: value is set in ${alternateScope} scope; retry with \`${retryHint} ${path}\` or use \`build config resolved\` for the effective value.`
+    );
+  }
+  return lines;
+}
+async function printConfigScopeMiss(path, scope, getConfigValue) {
+  const alternateScope = scope === "project" ? "user" : "project";
+  const alternateScopeValue = await getConfigValue(path, alternateScope);
+  for (const line of buildConfigScopeMissLines(path, scope, alternateScopeValue)) {
+    console.log(chalk3.yellow(line));
+  }
+}
+function formatResolvedConfigSummaryLine(summary) {
+  return `  ${chalk3.cyan(summary.provider)} \xB7 ${chalk3.cyan(summary.model)} \xB7 blockers:${chalk3.cyan(summary.blockerMode)} \xB7 transport:${chalk3.cyan(summary.transport)} \xB7 judge:${chalk3.cyan(summary.judge.type)}`;
+}
+function errorMessage(error) {
+  return sanitizeValue(error);
+}
+function configReadRepairHint(error) {
+  return `Fix or remove ${error.filePath}; Build will not ignore an existing invalid config file.`;
+}
+function renderConfigReadFailure(error, json = false) {
+  if (!isBuildConfigReadError(error)) return false;
+  const repairHint = configReadRepairHint(error);
+  if (json) {
+    renderJsonError(
+      new ValidationError(error.message, {
+        code: error.code,
+        filePath: error.filePath,
+        reason: error.reason,
+        diagnostics: error.diagnostics,
+        repairHint
+      })
+    );
+    return true;
+  }
+  writeConfigError(chalk3.red(`Error: ${error.message}`));
+  writeConfigError(chalk3.gray(repairHint));
+  return true;
+}
+function writeConfigLine(line = "") {
+  process.stdout.write(`${line}
+`);
+}
+function writeConfigError(line) {
+  process.stderr.write(`${line}
+`);
+}
+async function buildResolvedExecutorModelQuery(provider, cwd) {
+  const { prepareModelSelectionCatalog } = await import("./model-catalog-readiness-R5KJBP5M.js");
+  await prepareModelSelectionCatalog({ providerId: provider, projectRoot: cwd, coldStart: true });
+  const { triggerOpportunisticModelRefresh } = await import("./opportunistic-TL4S26VX.js");
+  triggerOpportunisticModelRefresh({
+    projectRoot: cwd,
+    entryPath: process.argv[1] ?? "",
+    command: "config",
+    args: process.argv.slice(2)
+  });
+  const executor = resolveExecutorRoleTarget({
+    cwd,
+    providerOverride: provider
+  });
+  const providerModule = registry.get(provider);
+  const bridge = providerModule?.resolveModelSelection;
+  const selection = bridge ? await bridge({ modelInput: executor.model.value }) : {
+    modelInput: executor.model.value,
+    effectiveModel: executor.model.value,
+    nativeDefault: null,
+    emitModelArg: null,
+    emittedModel: null,
+    cliVersion: null,
+    discoveryStatus: "unsupported",
+    availableModels: [],
+    selectedModelAvailable: null
+  };
+  return {
+    schemaVersion: 1,
+    role: "executor",
+    provider: executor.provider,
+    model: {
+      input: selection.modelInput,
+      effective: selection.effectiveModel,
+      source: executor.model.source,
+      ...executor.model.sourcePath ? { sourcePath: executor.model.sourcePath } : {},
+      ...executor.modelRole ? { modelRole: executor.modelRole } : {},
+      nativeDefault: selection.nativeDefault,
+      emitModelArg: selection.emitModelArg,
+      emittedModel: selection.emittedModel,
+      cliVersion: selection.cliVersion,
+      discoveryStatus: selection.discoveryStatus,
+      bridgeStatus: bridge ? "supported" : "unsupported",
+      availableModels: selection.availableModels,
+      selectedModelAvailable: selection.selectedModelAvailable
+    },
+    reasoningEffort: executor.reasoningEffort ?? null
+  };
+}
+function printExplainRow(result) {
+  const parts = [
+    chalk3.cyan(result.name),
+    result.type,
+    `default=${result.default !== void 0 ? String(result.default) : "(none)"}`,
+    `source=${result.source}`,
+    `category=${result.category}`
+  ];
+  if (result.status === "deprecated") {
+    parts.push(chalk3.yellow(`deprecated${result.replacement ? `->${result.replacement}` : ""}`));
+  }
+  if (result.error !== void 0) {
+    parts.push(chalk3.red(`error: ${result.error}`));
+  }
+  console.log(parts.join("  "));
+}
+function createConfigCommand() {
+  const configCommand = new Command("config").alias("settings").description("Manage Build configuration and preferences");
+  const ShowOptionsSchema = z.object({
+    verbose: BooleanFlagSchema.optional(),
+    json: BooleanFlagSchema.optional()
+  }).strict();
+  const ValidateOptionsSchema = z.object({
+    fix: BooleanFlagSchema.optional(),
+    verbose: BooleanFlagSchema.optional(),
+    json: BooleanFlagSchema.optional()
+  }).strict();
+  const DiagnoseOptionsSchema = z.object({
+    fix: BooleanFlagSchema.optional()
+  }).strict();
+  const ResetOptionsSchema = z.object({
+    level: z.enum(["user", "project", "all"]).optional().default("project"),
+    backup: BooleanFlagSchema.optional()
+  }).strict();
+  const ExportOptionsSchema = z.object({
+    output: FilePathSchema.optional().default("build-config-export.json"),
+    includePreferences: BooleanFlagSchema.optional()
+  }).strict();
+  const ImportOptionsSchema = z.object({
+    importPreferences: BooleanFlagSchema.optional()
+  }).strict();
+  configCommand.command("show").description("Display current configuration with source information").option("-v, --verbose", "Show detailed configuration with sources").option("-j, --json", "Output configuration as JSON").action(async (options) => {
+    try {
+      const validatedOptions = validateCommandOptions(ShowOptionsSchema, options);
+      options = validatedOptions;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error(chalk3.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk3.gray('\nTip: Use "build config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.loadConfig();
+      const resolved = configManager.resolveExecutionConfig();
+      if (options.json) {
+        renderJsonResult(
+          redactConfigValueForDisplay("", {
+            config: config.config,
+            resolved,
+            sources: config.sources,
+            isFirstTimeUser: config.isFirstTimeUser,
+            loadTime: config.loadTime
+          })
+        );
+        return;
+      }
+      console.log(chalk3.bold.blue("\nBuild Configuration\n"));
+      console.log(chalk3.bold("Effective Settings:"));
+      console.log(`  Default Provider: ${chalk3.cyan(resolved.defaultProvider.value)}`);
+      console.log(`  Default Model: ${chalk3.cyan(resolved.defaultModel.value)}`);
+      console.log(`  First-time User: ${chalk3.cyan(config.isFirstTimeUser ? "Yes" : "No")}`);
+      console.log(`  Load Time: ${chalk3.gray(`${config.loadTime}ms`)}`);
+      console.log();
+      const enabledProviders = ProviderRegistry.getEnabledProviders();
+      if (enabledProviders.length > 0) {
+        console.log(chalk3.bold("Provider Configuration:"));
+        for (const provider of enabledProviders) {
+          const model = resolved.providerModels[provider.id]?.value ?? provider.models.default;
+          console.log(`  ${provider.id}: ${chalk3.cyan(String(model))}`);
+        }
+        console.log();
+      }
+      if (options.verbose) {
+        console.log(chalk3.bold("Configuration Sources (by priority):"));
+        for (const source of config.sources.sort((a, b) => b.priority - a.priority)) {
+          const status = source.data ? chalk3.green("OK") : chalk3.red("Error");
+          console.log(`  ${status} ${source.type} (priority: ${source.priority})`);
+          if (source.path) {
+            console.log(`    Path: ${chalk3.gray(source.path)}`);
+          }
+        }
+        console.log();
+      }
+      if (config.config.quality) {
+        console.log(chalk3.bold("Quality Gates:"));
+        const quality = config.config.quality;
+        if (quality.coverage) {
+          console.log(
+            `  ${qualityGateStatus(quality.coverage.enabled)} Coverage: ${chalk3.cyan(
+              `${quality.coverage.threshold}%`
+            )}`
+          );
+        }
+        if (quality.lint) {
+          console.log(`  ${qualityGateStatus(quality.lint.enabled)} Linting`);
+        }
+        if (quality.security) {
+          console.log(`  ${qualityGateStatus(quality.security.enabled)} Security`);
+        }
+        console.log();
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error, Boolean(options.json))) throw new ExitCodeError(1);
+      console.error(chalk3.red("Error loading configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("list").description("List all configuration values").option("-j, --json", "Output configuration as JSON").action(async (options) => {
+    try {
+      const configManager = new ConfigManager();
+      const config = await configManager.loadConfig();
+      const resolved = configManager.resolveExecutionConfig();
+      if (options.json) {
+        renderJsonResult(
+          redactConfigValueForDisplay("", {
+            config: config.config,
+            resolved,
+            sources: config.sources
+          })
+        );
+        return;
+      }
+      console.log(chalk3.bold.blue("\nConfiguration Values\n"));
+      const configData = config.config;
+      console.log(`Default Provider: ${chalk3.cyan(resolved.defaultProvider.value)}`);
+      console.log(`Effective Model: ${chalk3.cyan(resolved.defaultModel.value)}`);
+      const enabledProviders = ProviderRegistry.getEnabledProviders();
+      if (enabledProviders.length > 0) {
+        console.log("\nProviders:");
+        for (const provider of enabledProviders) {
+          const model = resolved.providerModels[provider.id]?.value ?? provider.models.default;
+          console.log(`  ${provider.id}: ${chalk3.cyan(String(model))}`);
+        }
+      }
+      if (configData.quality) {
+        console.log("\nQuality Gates:");
+        const quality = configData.quality;
+        if (quality.coverage) {
+          console.log(
+            `  ${qualityGateStatus(quality.coverage.enabled)} Coverage: ${chalk3.cyan(
+              `${quality.coverage.threshold}%`
+            )}`
+          );
+        }
+        if (quality.lint) {
+          console.log(`  ${qualityGateStatus(quality.lint.enabled)} Linting`);
+        }
+        if (quality.security) {
+          console.log(`  ${qualityGateStatus(quality.security.enabled)} Security`);
+        }
+      }
+      console.log("\nConfiguration Sources:");
+      for (const source of config.sources.filter((s) => s.data).sort((a, b) => b.priority - a.priority)) {
+        const status = source.data ? chalk3.green("OK") : chalk3.red("Error");
+        console.log(`  ${status} ${source.type} (priority: ${source.priority})`);
+      }
+      console.log();
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error, Boolean(options.json))) throw new ExitCodeError(1);
+      console.error(chalk3.red("Error listing configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("validate").description("Validate configuration files and report issues").option("--fix", "Attempt to auto-fix fixable issues").option("-v, --verbose", "Show detailed validation information").option("-j, --json", "Output validation result as JSON").action(async (options) => {
+    const wantsJson = Boolean(options.json);
+    try {
+      const validatedOptions = validateCommandOptions(ValidateOptionsSchema, options);
+      options = validatedOptions;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        if (wantsJson) {
+          renderJsonError(
+            new ValidationError("Invalid command options", {
+              details: formatValidationErrors(error)
+            })
+          );
+          throw new ExitCodeError(1);
+        }
+        console.error(chalk3.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk3.gray('\nTip: Use "build config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.loadConfig().catch((error) => {
+        if (options.fix && error instanceof InvalidConfigContentError) {
+          return loadUnvalidatedConfig();
+        }
+        throw error;
+      });
+      const validation = validateBuildConfig(config.config, {
+        includeWarnings: true,
+        includeSuggestions: true,
+        cwd: process.cwd(),
+        // Raw layers: a configured model is only checkable against the provider
+        // its own layer declares, which the merged tree no longer shows.
+        layers: config.sources.map((source) => ({
+          label: source.path ?? source.type,
+          config: source.data
+        }))
+      });
+      let providerRegistryError;
+      try {
+        ProviderRegistry.reload();
+        ProviderRegistry.load();
+        providerRegistryError = ProviderRegistry.describeIgnoredUserModelEntries();
+      } catch (error) {
+        providerRegistryError = errorMessage(error);
+      }
+      const jsonPayload = {
+        isValid: validation.isValid && !providerRegistryError,
+        validation,
+        providerRegistryError: providerRegistryError ?? null
+      };
+      if (options.fix && !validation.isValid) {
+        const { autoFixConfig: autoFixConfig2 } = await import("./config-validator-H4ZVIE56.js");
+        const fixResult = autoFixConfig2(config.config);
+        const repair = resolveProjectConfigRepair(
+          fixResult.edits,
+          await configManager.loadProjectConfig()
+        );
+        const saveResult = repair.edits.length > 0 ? await configManager.applyProjectConfigFixes(repair.edits) : { success: true, error: void 0 };
+        jsonPayload.fix = {
+          changes: repair.applied,
+          unresolved: repair.unresolved,
+          remainingErrors: fixResult.remainingErrors,
+          saved: saveResult.success,
+          saveError: saveResult.success ? null : saveResult.error
+        };
+        if (!options.json) {
+          console.log(chalk3.bold.yellow("\nAttempting to auto-fix issues..."));
+          if (repair.applied.length > 0) {
+            console.log(chalk3.green("Fixed issues:"));
+            repair.applied.forEach((change) => {
+              console.log(`  OK ${change}`);
+            });
+            if (saveResult.success) {
+              console.log(chalk3.green("\nOK: Configuration saved successfully."));
+            } else {
+              console.log(
+                chalk3.red(`
+Error: Failed to save configuration: ${saveResult.error}`)
+              );
+            }
+          }
+          if (fixResult.remainingErrors.length > 0 || repair.unresolved.length > 0) {
+            console.log(chalk3.yellow("\nRemaining issues that require manual fix:"));
+            fixResult.remainingErrors.forEach((error) => {
+              console.log(
+                `  Warning: ${sanitizeString(error.path.join("."))}: ${sanitizeString(error.message)}`
+              );
+            });
+            repair.unresolved.forEach((issue) => {
+              console.log(`  Warning: ${sanitizeString(issue)}`);
+            });
+          }
+        }
+      }
+      if (options.json) {
+        renderJsonResult(jsonPayload);
+        if (!validation.isValid || providerRegistryError) {
+          throw new ExitCodeError(1);
+        }
+        return;
+      }
+      console.log(chalk3.bold.blue("\nConfiguration Validation\n"));
+      const report = generateValidationReport(validation);
+      console.log(report);
+      if (providerRegistryError) {
+        console.log(chalk3.red("\nProvider registry: invalid"));
+        console.log(chalk3.red(`  Error: ${providerRegistryError}`));
+      }
+      if (!validation.isValid || providerRegistryError) {
+        throw new ExitCodeError(1);
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error, Boolean(options.json))) throw new ExitCodeError(1);
+      if (options.json) {
+        renderJsonError(error);
+        throw new ExitCodeError(1);
+      }
+      console.error(chalk3.red("Error validating configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("diagnose").description("Run comprehensive diagnostics on configuration system").option("--fix", "Attempt to fix detected issues").action(async (options) => {
+    try {
+      const validatedOptions = validateCommandOptions(DiagnoseOptionsSchema, options);
+      options = validatedOptions;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error(chalk3.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk3.gray('\nTip: Use "build config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    try {
+      console.log(chalk3.bold.blue("\nConfiguration Diagnostics\n"));
+      const configManager = new ConfigManager();
+      const diagnostics = await configManager.getDiagnostics();
+      console.log(chalk3.bold("Configuration Paths:"));
+      for (const [name, info] of Object.entries(diagnostics.paths)) {
+        const status = info.exists ? chalk3.green("OK") : chalk3.red("Error");
+        let writable = "";
+        if (info.writable !== void 0) {
+          writable = info.writable ? chalk3.green("(writable)") : chalk3.red("(read-only)");
+        }
+        console.log(
+          `  ${status} ${name}: ${chalk3.gray(info.exists ? "exists" : "missing")} ${writable}`
+        );
+      }
+      console.log();
+      console.log(chalk3.bold("Configuration Cache:"));
+      console.log(`  Enabled: ${chalk3.cyan(diagnostics.cache.enabled ? "Yes" : "No")}`);
+      console.log(`  Size: ${chalk3.cyan(diagnostics.cache.size)} entries`);
+      if (diagnostics.cache.entries.length > 0) {
+        console.log("  Recent entries:");
+        diagnostics.cache.entries.slice(0, 5).forEach((entry) => {
+          console.log(`    ${chalk3.gray(entry.key)} (${chalk3.cyan(`${entry.age}ms ago`)})`);
+        });
+      }
+      console.log();
+      console.log(chalk3.bold("Configuration Validation:"));
+      if (diagnostics.validation.isValid) {
+        console.log(chalk3.green("  OK Configuration is valid"));
+      } else {
+        console.log(chalk3.red("  Error Configuration has issues"));
+        console.log(`    Errors: ${chalk3.red(diagnostics.validation.errors.length)}`);
+        console.log(`    Warnings: ${chalk3.yellow(diagnostics.validation.warnings.length)}`);
+      }
+      console.log();
+      console.log(chalk3.bold("Performance Metrics:"));
+      console.log(
+        `  Average Load Time: ${chalk3.cyan(`${diagnostics.performance.avgLoadTime}ms`)}`
+      );
+      console.log(`  Cache Hit Rate: ${chalk3.cyan(`${diagnostics.performance.cacheHitRate}%`)}`);
+      console.log();
+      const systemDiagnostics = await getConfigDiagnostics();
+      console.log(chalk3.bold("Source Loading:"));
+      console.log(`  Load Time: ${chalk3.cyan(`${systemDiagnostics.loadTime}ms`)}`);
+      console.log(`  Sources Found: ${chalk3.cyan(systemDiagnostics.summary.loadedSources)}`);
+      console.log(`  Valid Sources: ${chalk3.cyan(systemDiagnostics.summary.validSources)}`);
+      console.log();
+      if (options.fix) {
+        console.log(chalk3.bold.yellow("Attempting to auto-fix configuration issues..."));
+        const configManager2 = new ConfigManager();
+        const config = await configManager2.loadConfig();
+        const { autoFixConfig: autoFixConfig2 } = await import("./config-validator-H4ZVIE56.js");
+        const fixResult = autoFixConfig2(config.config);
+        const repair = resolveProjectConfigRepair(
+          fixResult.edits,
+          await configManager2.loadProjectConfig()
+        );
+        if (repair.applied.length > 0) {
+          console.log(chalk3.green("Fixed issues:"));
+          repair.applied.forEach((change) => {
+            console.log(`  OK ${change}`);
+          });
+          const saveResult = await configManager2.applyProjectConfigFixes(repair.edits);
+          if (saveResult.success) {
+            console.log(chalk3.green("\nOK: Configuration saved successfully."));
+          } else {
+            console.log(chalk3.red(`
+Error: Failed to save configuration: ${saveResult.error}`));
+          }
+        } else {
+          console.log(chalk3.gray("No auto-fixable issues detected."));
+        }
+        if (fixResult.remainingErrors.length > 0 || repair.unresolved.length > 0) {
+          console.log(chalk3.yellow("\nRemaining issues that require manual fix:"));
+          fixResult.remainingErrors.forEach((error) => {
+            console.log(
+              `  Warning: ${sanitizeString(error.path.join("."))}: ${sanitizeString(error.message)}`
+            );
+          });
+          repair.unresolved.forEach((issue) => {
+            console.log(`  Warning: ${sanitizeString(issue)}`);
+          });
+        }
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error)) throw new ExitCodeError(1);
+      console.error(chalk3.red("Error running diagnostics:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("reset").description("Reset configuration to defaults").option("--level <level>", "Reset level: user, project, or all", "project").option("--backup", "Create backup before resetting").action(async (options) => {
+    try {
+      const validatedOptions = validateCommandOptions(ResetOptionsSchema, options);
+      options = validatedOptions;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error(chalk3.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk3.gray('\nTip: Use "build config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    const configManager = new ConfigManager();
+    try {
+      console.log(chalk3.bold.yellow(`
+Resetting configuration (level: ${options.level})
+`));
+      if (options.backup) {
+        const backup = redactConfigValueForDisplay("", await configManager.exportConfig(true));
+        const backupPath = `build-config-backup-${Date.now()}.json`;
+        writeFileSync(backupPath, JSON.stringify(backup, null, 2));
+        console.log(chalk3.green(`OK Backup created: ${backupPath}`));
+      }
+      const result = await configManager.resetToDefaults(
+        options.level
+      );
+      if (result.success) {
+        console.log(chalk3.green("OK: Configuration reset successfully."));
+        console.log(chalk3.gray('\nRun "build init" to reconfigure with optimal defaults.'));
+      } else {
+        console.log(chalk3.red(`Error: Failed to reset configuration: ${result.error}`));
+        throw new ExitCodeError(1);
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk3.red("Error resetting configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("export").description("Export configuration to file").option("-o, --output <file>", "Output file path", "build-config-export.json").option("--include-preferences", "Include user preferences in export").action(async (options) => {
+    try {
+      const validatedOptions = validateCommandOptions(ExportOptionsSchema, options);
+      options = validatedOptions;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error(chalk3.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk3.gray('\nTip: Use "build config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    const configManager = new ConfigManager();
+    try {
+      const exportData = redactConfigValueForDisplay(
+        "",
+        await configManager.exportConfig(options.includePreferences)
+      );
+      writeFileSync(options.output, JSON.stringify(exportData, null, 2));
+      console.log(chalk3.bold.green(`
+OK: Configuration exported to: ${options.output}`));
+      console.log(chalk3.gray(`  Exported at: ${exportData.metadata.exportedAt}`));
+      console.log(chalk3.gray(`  Version: ${exportData.metadata.version}`));
+      if (options.includePreferences) {
+        console.log(chalk3.gray("  User preferences: included"));
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error)) throw new ExitCodeError(1);
+      console.error(chalk3.red("Error exporting configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("import").description("Import configuration from file").argument("<file>", "Configuration file to import").option("--import-preferences", "Import user preferences from file").action(async (file, options) => {
+    try {
+      validateCommandOptions(ExistingFilePathSchema, file);
+      const validatedOptions = validateCommandOptions(ImportOptionsSchema, options);
+      options = validatedOptions;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error(chalk3.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk3.gray('\nTip: Use "build config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    const configManager = new ConfigManager();
+    try {
+      if (!existsSync(file)) {
+        console.error(chalk3.red(`Configuration file not found: ${file}`));
+        throw new ExitCodeError(1);
+      }
+      const importData = parseJsonWithContext(
+        readFileSync(file, "utf8"),
+        `Config import (${file})`
+      );
+      const result = await configManager.importConfig(
+        importData,
+        options.importPreferences
+      );
+      if (result.success) {
+        console.log(chalk3.bold.green(`
+OK: Configuration imported from: ${file}`));
+        console.log(chalk3.gray("Configuration has been successfully applied."));
+      } else {
+        console.log(chalk3.red(`Error: Failed to import configuration: ${result.error}`));
+        throw new ExitCodeError(1);
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk3.red("Error importing configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("precedence").description("Display configuration precedence order and current values").action(async () => {
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.loadConfig();
+      const resolved = configManager.resolveExecutionConfig();
+      console.log(chalk3.bold.blue("\nConfiguration Precedence\n"));
+      console.log(chalk3.gray("Priority (highest to lowest):"));
+      console.log(chalk3.gray("  1. CLI flags (--model, --provider, etc.)"));
+      console.log(
+        chalk3.gray(
+          "  2. Environment variables (BUILD_DEFAULT_PROVIDER, BUILD_<PROVIDER>_DEFAULT_MODEL, etc.)"
+        )
+      );
+      console.log(
+        chalk3.gray(`  3. Active profile (${join(getUserConfigDir(), "profiles", "<name>.json")})`)
+      );
+      console.log(chalk3.gray("  4. Project config (.build-project/config/build.config.jsonc)"));
+      console.log(chalk3.gray(`  5. User config (${getUserConfigFile()})`));
+      console.log(chalk3.gray("  6. Registry defaults (.build-project/config/providers.yaml)"));
+      console.log(chalk3.gray("  7. Hardcoded fallback"));
+      console.log();
+      console.log(chalk3.bold("Current Source Values:"));
+      for (const source of sourcesForPrecedence(config.sources, resolved)) {
+        if (source.data && source.type !== "default") {
+          console.log(chalk3.cyan(`${source.type.toUpperCase()} (priority: ${source.priority}):`));
+          const configData = source.data;
+          if (configData.defaults?.provider || configData.defaultProvider) {
+            console.log(
+              `  Default Provider: ${configData.defaults?.provider ?? configData.defaultProvider}`
+            );
+          }
+          for (const [provider, model] of listSourceProviderModels(source, resolved)) {
+            console.log(`  ${provider} Model: ${model}`);
+          }
+          console.log();
+        }
+      }
+      console.log(chalk3.bold("Final Resolved Configuration:"));
+      console.log(`  Default Provider: ${chalk3.cyan(resolved.defaultProvider.value)}`);
+      console.log(`  Effective Model: ${chalk3.cyan(resolved.defaultModel.value)}`);
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error)) throw new ExitCodeError(1);
+      console.error(chalk3.red("Error showing precedence:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  const aliasesCommand = new Command("aliases").description(
+    'Manage user model aliases (stored in user config)\n\nExamples:\n  build config aliases list\n  build config aliases list --provider opencode\n  build provider alias set opencode fast "openrouter/provider/model-name"'
+  );
+  aliasesCommand.command("list").description("List user model aliases (provider-scoped)").option("-p, --provider <provider>", "Filter to a single provider (e.g., opencode)").option("-j, --json", "Output as JSON").action(async (options) => {
+    try {
+      const configManager = new ConfigManager();
+      const providers = await configManager.getConfigValue("providers", "user");
+      const out = projectModelAliasListing(providers, options.provider);
+      if (options.json) {
+        console.log(JSON.stringify(out, null, 2));
+        return;
+      }
+      const providersWithAliases = sortedModelAliasListing(out);
+      if (providersWithAliases.length === 0) {
+        console.log(chalk3.yellow("No user model aliases found."));
+        console.log(
+          chalk3.gray(
+            'Tip: Use "build provider alias set <provider> <alias> <model>" or "build config set --scope user providers.<provider>.aliases.models.<alias> <model>".'
+          )
+        );
+        return;
+      }
+      for (const { providerId, models } of providersWithAliases) {
+        console.log(chalk3.bold(`${providerId}:`));
+        for (const [aliasKey, modelId] of models) {
+          console.log(`  ${chalk3.cyan(aliasKey)} -> ${chalk3.gray(modelId)}`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk3.red("Error listing aliases:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.addCommand(aliasesCommand);
+  configCommand.command("resolved").description("Show resolved configuration with source attribution").option("-j, --json", "Output as JSON").option("-p, --provider <provider>", "Show resolved model for specific provider").option("--role <role>", "Show a role-scoped model decision (currently: executor)").option("--summary", "Output compact planning-critical fields only").option("--compete", "Show compete defaults with source attribution per tier").option("--optimization", "Show fast/best/cheap optimization recipes and provider availability").action(async (options) => {
+    enterReadOnlyProviderOrderView();
+    try {
+      if (options.role && (options.summary || options.compete || options.optimization)) {
+        writeConfigError(
+          chalk3.red(
+            "Error: --role cannot be combined with --summary, --compete, or --optimization"
+          )
+        );
+        throw new ExitCodeError(1);
+      }
+      if (options.optimization) {
+        const { resolveOptimizationConfig, summarizeOptimizationConfig } = await import("./optimization-config-resolver-NAEIYU6A.js");
+        const resolved2 = await resolveOptimizationConfig(process.cwd());
+        const summary = summarizeOptimizationConfig(resolved2, resolveDefaultProvider().value);
+        if (options.json) {
+          console.log(JSON.stringify(redactConfigValueForDisplay("", summary), null, 2));
+          return;
+        }
+        console.log(chalk3.bold.blue("\nOptimization recipes (resolved):\n"));
+        console.log(`  Source:       ${chalk3.cyan(summary.source)}`);
+        console.log(
+          `  Available:    ${chalk3.cyan(summary.availableProviders.join(", ") || "(none)")}`
+        );
+        if (summary.unavailableProviders.length > 0) {
+          console.log(`  Unavailable:  ${chalk3.gray(summary.unavailableProviders.join(", "))}`);
+        }
+        const formatOrder = ({ providers, source }) => {
+          if (source === "provider that did the work") return `${source} (fast model)`;
+          const list = providers.join(", ") || "(none available)";
+          return source === "configured" ? list : `${list} (${source})`;
+        };
+        const { autoloop } = summary.providerOrder;
+        const recipes = summary.recipes.optimization;
+        if (recipes) {
+          console.log();
+          console.log(`  cost:         ${chalk3.cyan(formatOrder(summary.providerOrder.cost))}`);
+          console.log(`  autoloop:     ${chalk3.cyan(formatOrder(autoloop))}`);
+        }
+        console.log();
+        console.log(
+          chalk3.gray(
+            "Note: optimization.* applies to build run --optimize. Bare build run competition keeps its compete resolver defaults; build/flywheel/competition provider/model routing uses the canonical decision contract (automatic ranking remains opt-in)."
+          )
+        );
+        console.log();
+        return;
+      }
+      if (options.compete) {
+        const projectRoot2 = resolveRepoRootForBuildDir(process.cwd());
+        const competeResolved = await resolveCompeteConfig({}, { projectRoot: projectRoot2 });
+        if (options.json) {
+          console.log(JSON.stringify(redactConfigValueForDisplay("", competeResolved), null, 2));
+          return;
+        }
+        console.log(chalk3.bold.blue("\nCompete defaults (resolved):\n"));
+        const pad = (s, n) => s.padEnd(n);
+        const w = 20;
+        const fmtSrc = (src2) => chalk3.gray(`[${src2}]`);
+        console.log(
+          `  ${pad("variants:", w)} ${chalk3.cyan(competeResolved.variants.join(", ") || "(auto-discovered)")}  ${fmtSrc(competeResolved.sources.variants)}`
+        );
+        console.log(
+          `  ${pad("judge:", w)} ${chalk3.cyan(competeResolved.judge)}  ${fmtSrc(competeResolved.sources.judge)}`
+        );
+        if (competeResolved.judgeRun) {
+          console.log(
+            `  ${pad("judgeRun:", w)} ${chalk3.cyan(competeResolved.judgeRun)}  ${fmtSrc(competeResolved.sources.judgeRun ?? competeResolved.sources.judge)}`
+          );
+        }
+        if (competeResolved.judgePrimary) {
+          console.log(
+            `  ${pad("judgePrimary:", w)} ${chalk3.cyan(competeResolved.judgePrimary)}  ${fmtSrc(competeResolved.sources.judgePrimary ?? competeResolved.sources.judge)}`
+          );
+        }
+        console.log(
+          `  ${pad("completionMode:", w)} ${chalk3.cyan(competeResolved.completionMode)}  ${fmtSrc(competeResolved.sources.completionMode)}`
+        );
+        console.log(
+          `  ${pad("timeout:", w)} ${chalk3.cyan(`${competeResolved.timeout}m`)}  ${fmtSrc(competeResolved.sources.timeout)}`
+        );
+        console.log(
+          `  ${pad("requireMinVariants:", w)} ${chalk3.cyan(String(competeResolved.requireMinVariants))}  ${fmtSrc(competeResolved.sources.requireMinVariants)}`
+        );
+        console.log(
+          `  ${pad("matrixEscalation:", w)} ${chalk3.cyan(`close<=${competeResolved.matrixEscalation?.closeCallMargin ?? 5}, borderline<=${competeResolved.matrixEscalation?.borderlineMargin ?? 7}, confidence<${competeResolved.matrixEscalation?.confidenceThreshold ?? 0.75}`)}  ${fmtSrc(competeResolved.sources.matrixEscalation ?? "built-in")}`
+        );
+        const envOverrides = [];
+        if (process.env.BUILD_COMPLETION_MODE?.trim()) {
+          envOverrides.push(
+            `  BUILD_COMPLETION_MODE=${process.env.BUILD_COMPLETION_MODE}  \u2192 completionMode: ${competeResolved.completionMode}`
+          );
+        }
+        const activeJudgeEnv = readJudgeTypeEnv();
+        if (activeJudgeEnv?.trim()) {
+          const legacyActive = process.env.BUILD_JUDGE_TYPE === void 0 && process.env.BUILD_JUDGE !== void 0;
+          const label = legacyActive ? "BUILD_JUDGE (deprecated alias for BUILD_JUDGE_TYPE)" : "BUILD_JUDGE_TYPE";
+          envOverrides.push(`  ${label}=${activeJudgeEnv}  \u2192 judge: ${competeResolved.judge}`);
+        }
+        if (process.env.BUILD_TIMEOUT_MS?.trim()) {
+          const ms = parseInt(process.env.BUILD_TIMEOUT_MS, 10);
+          if (!Number.isNaN(ms)) {
+            envOverrides.push(
+              `  BUILD_TIMEOUT_MS=${process.env.BUILD_TIMEOUT_MS}  \u2192 timeout: ${Math.ceil(ms / 6e4)}m`
+            );
+          }
+        }
+        if (process.env.BUILD_JUDGE_RUN?.trim() || process.env.BUILD_AI_JUDGE_RUN?.trim()) {
+          const key = process.env.BUILD_JUDGE_RUN?.trim() ? "BUILD_JUDGE_RUN" : "BUILD_AI_JUDGE_RUN";
+          envOverrides.push(
+            `  ${key}=${process.env[key]}  \u2192 judgeRun: ${competeResolved.judgeRun ?? "ai"}`
+          );
+        }
+        if (process.env.BUILD_JUDGE_PRIMARY?.trim() || process.env.BUILD_AI_JUDGE_PRIMARY?.trim()) {
+          const key = process.env.BUILD_JUDGE_PRIMARY?.trim() ? "BUILD_JUDGE_PRIMARY" : "BUILD_AI_JUDGE_PRIMARY";
+          envOverrides.push(
+            `  ${key}=${process.env[key]}  \u2192 judgePrimary: ${competeResolved.judgePrimary ?? "ai"}`
+          );
+        }
+        const hasMatrixEscalationEnvOverride = readEnv(BUILD_MATRIX_CLOSE_CALL_MARGIN).source === "env" || readEnv(BUILD_MATRIX_BORDERLINE_MARGIN).source === "env" || readEnv(BUILD_MATRIX_CONFIDENCE_THRESHOLD).source === "env";
+        if (hasMatrixEscalationEnvOverride) {
+          envOverrides.push(
+            `  BUILD_MATRIX_*  \u2192 matrixEscalation: close<=${competeResolved.matrixEscalation?.closeCallMargin ?? 5}, borderline<=${competeResolved.matrixEscalation?.borderlineMargin ?? 7}, confidence<${competeResolved.matrixEscalation?.confidenceThreshold ?? 0.75}`
+          );
+        }
+        if (envOverrides.length > 0) {
+          console.log("\nActive BUILD_* overrides:");
+          for (const line of envOverrides) {
+            console.log(chalk3.yellow(line));
+          }
+        }
+        console.log();
+        return;
+      }
+      const resolved = resolveConfig(void 0, process.cwd(), { strictSynthesisModel: false });
+      if (options.summary && (options.provider || options.role)) {
+        console.error(chalk3.red("Error: --summary cannot be combined with --provider or --role"));
+        throw new ExitCodeError(1);
+      }
+      if (options.summary) {
+        const enabledProviders = ProviderRegistry.getEnabledProviders().map((p) => p.id);
+        const judgeType = resolved.judge.type.value;
+        const judge = await buildJudgeRow(
+          judgeType,
+          resolveRepoRootForBuildDir(process.cwd()),
+          judgeType
+        );
+        const summary = {
+          provider: resolved.defaultProvider.value,
+          model: resolved.defaultModel.value,
+          blockerMode: resolved.planExecute.blockerMode.value,
+          transport: resolved.providerExecutionTransport.current.value,
+          judge: summarizeJudgeRow(judge, resolved),
+          availableProviders: enabledProviders
+        };
+        if (options.json) {
+          console.log(JSON.stringify(redactSensitiveConfig(summary), null, 2));
+        } else {
+          console.log(chalk3.bold.blue("\nResolved Config Summary\n"));
+          console.log(formatResolvedConfigSummaryLine(summary));
+          console.log();
+          console.log(`  Provider:  ${chalk3.cyan(summary.provider)}`);
+          console.log(`  Model:     ${chalk3.cyan(summary.model)}`);
+          console.log(`  Blockers:  ${chalk3.cyan(summary.blockerMode)}`);
+          console.log(`  Transport: ${chalk3.cyan(summary.transport)}`);
+          console.log(`  Judge:     ${chalk3.cyan(formatSummaryJudge(summary.judge))}`);
+          console.log(`  Available: ${chalk3.cyan(summary.availableProviders.join(", "))}`);
+          console.log();
+        }
+        return;
+      }
+      if (options.role) {
+        if (options.role !== "executor") {
+          writeConfigError(chalk3.red(`Error: Unsupported role: ${options.role}`));
+          throw new ExitCodeError(1);
+        }
+        if (!options.provider) {
+          writeConfigError(chalk3.red("Error: --role requires --provider"));
+          throw new ExitCodeError(1);
+        }
+        const normalizedProvider = normalizeEngineId(String(options.provider));
+        if (!resolved.providerModels[normalizedProvider]) {
+          if (options.json) {
+            renderJsonError(
+              new ValidationError(`Unknown provider: ${options.provider}`, {
+                provider: options.provider
+              })
+            );
+            throw new ExitCodeError(1);
+          }
+          writeConfigError(chalk3.red(`Unknown provider: ${options.provider}`));
+          throw new ExitCodeError(1);
+        }
+        const query = await buildResolvedExecutorModelQuery(normalizedProvider, process.cwd());
+        if (options.json) {
+          renderJsonResult(redactConfigValueForDisplay("", query));
+        } else {
+          const model = query.model;
+          writeConfigLine(`roles.executor.provider: ${normalizedProvider}`);
+          writeConfigLine(`roles.executor.model.input: ${String(model.input)}`);
+          writeConfigLine(`roles.executor.model.effective: ${String(model.effective)}`);
+          writeConfigLine(`roles.executor.model.source: ${String(model.source)}`);
+          writeConfigLine(`roles.executor.model.discovery: ${String(model.discoveryStatus)}`);
+          writeConfigLine(`roles.executor.model.emitArg: ${String(model.emitModelArg)}`);
+          const reasoning = query.reasoningEffort;
+          writeConfigLine(
+            `roles.executor.reasoningEffort: ${reasoning ? String(reasoning.value) : AGENT_DEFAULT}`
+          );
+          if (reasoning?.source) {
+            writeConfigLine(`roles.executor.reasoningSource: ${String(reasoning.source)}`);
+          }
+        }
+        return;
+      }
+      if (options.provider) {
+        const normalizedProvider = normalizeEngineId(String(options.provider));
+        const providerModel = resolved.providerModels[normalizedProvider];
+        if (!providerModel) {
+          if (options.json) {
+            renderJsonError(
+              new ValidationError(`Unknown provider: ${options.provider}`, {
+                provider: options.provider
+              })
+            );
+            throw new ExitCodeError(1);
+          }
+          console.error(chalk3.red(`Unknown provider: ${options.provider}`));
+          throw new ExitCodeError(1);
+        }
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              redactConfigValueForDisplay(normalizedProvider, providerModel),
+              null,
+              2
+            )
+          );
+        } else {
+          console.log(formatResolvedValue(providerModel));
+        }
+        return;
+      }
+      const roles = resolveExecutionRoles({
+        cwd: process.cwd(),
+        ...resolveReviewerEligibility(process.cwd())
+      });
+      const projectRoot = resolveRepoRootForBuildDir(process.cwd());
+      if (options.json) {
+        const executionPreview2 = await buildExecutionPreview(resolved, projectRoot);
+        const instructionsImport = describeInstructionsImport();
+        const shown = { ...resolved, roles, executionPreview: executionPreview2, instructionsImport };
+        console.log(JSON.stringify(redactConfigValueForDisplay("", shown), null, 2));
+        return;
+      }
+      console.log(chalk3.bold.blue("\nResolved Configuration\n"));
+      const executionPreview = await buildExecutionPreview(resolved, projectRoot);
+      const log = (line = "") => console.log(line);
+      log(formatResolvedSummary(resolved, executionPreview));
+      printExecutionPreview(resolved, executionPreview, log);
+      printResolvedRoles(roles, writeConfigLine);
+      console.log();
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error, Boolean(options.json))) throw new ExitCodeError(1);
+      console.error(chalk3.red("Error resolving configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("set").description("Set configuration value using dot-notation path").argument(
+    "<path>",
+    "Config path (e.g., defaults.provider, automation.flywheel.merge.biomeRepair)"
+  ).argument("<value>", "Value to set").option("--scope <scope>", "Configuration scope: user or project", "project").action(async (path, value, options) => {
+    try {
+      const scope = options.scope;
+      if (scope !== "user" && scope !== "project") {
+        console.error(chalk3.red(`Invalid scope: ${scope}. Use 'user' or 'project'.`));
+        throw new ExitCodeError(1);
+      }
+      const writeCwd = findProjectRoot(process.cwd()) ?? resolveRepoRootForBuildDir(process.cwd());
+      const configManager = new ConfigManager({ cwd: writeCwd });
+      const hadProjectConfig = existsSync(getConfigPaths(writeCwd).projectConfigFile);
+      const result = await configManager.setConfigValue(path, value, scope);
+      if (result.success) {
+        console.log(
+          chalk3.green(`OK: Set ${path} = ${formatConfigSetValueForDisplay(path, value)}`)
+        );
+        console.log(chalk3.gray(`  Scope: ${scope}`));
+        if (result.previousValue !== void 0) {
+          console.log(
+            chalk3.gray(
+              `  Previous: ${formatConfigSetValueForDisplay(path, result.previousValue)}`
+            )
+          );
+        }
+        if (scope === "project") {
+          await printConfigSetShadowNotice(path, formatConfigSetValueForDisplay);
+          if (!hadProjectConfig) {
+            console.log(
+              "Info: created .build-project/config/build.config.jsonc only; run build init for the full project state."
+            );
+          }
+        }
+      } else {
+        console.error(chalk3.red(`Error: Failed to set configuration: ${result.error}`));
+        throw new ExitCodeError(1);
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk3.red("Error setting configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("get").description("Get configuration value using dot-notation path").argument("<path>", "Config path (e.g., defaults.provider, execution.defaultTimeout)").option("--scope <scope>", "Configuration scope: user or project", "project").option("-j, --json", "Output as JSON").action(async (path, options) => {
+    try {
+      const scope = options.scope;
+      if (scope !== "user" && scope !== "project") {
+        console.error(chalk3.red(`Invalid scope: ${scope}. Use 'user' or 'project'.`));
+        throw new ExitCodeError(1);
+      }
+      const configManager = new ConfigManager();
+      const value = await configManager.getConfigValue(path, scope);
+      if (options.json) {
+        console.log(JSON.stringify(buildConfigGetJsonPayload(path, scope, value), null, 2));
+      } else if (value === void 0) {
+        await printConfigScopeMiss(
+          path,
+          scope,
+          (configPath, configScope) => configManager.getConfigValue(configPath, configScope)
+        );
+      } else {
+        console.log(chalk3.cyan(`${path}`), "=", formatConfigGetValueForDisplay(path, value));
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error, Boolean(options.json))) throw new ExitCodeError(1);
+      console.error(chalk3.red("Error getting configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  const userCommand = new Command("user").description("Manage user-scope configuration values");
+  userCommand.command("set").description("Set a user-scope configuration value using dot-notation path").argument("<path>", "Config path (e.g., defaults.provider)").argument("<value>", "Value to set").action(async (path, value) => {
+    try {
+      const configManager = new ConfigManager();
+      const result = await configManager.setConfigValue(path, value, "user");
+      if (result.success) {
+        console.log(
+          chalk3.green(`OK: Set ${path} = ${formatConfigSetValueForDisplay(path, value)}`)
+        );
+        console.log(chalk3.gray("  Scope: user"));
+        if (result.previousValue !== void 0) {
+          console.log(
+            chalk3.gray(
+              `  Previous: ${formatConfigSetValueForDisplay(path, result.previousValue)}`
+            )
+          );
+        }
+        return;
+      }
+      console.error(chalk3.red(`Error: Failed to set configuration: ${result.error}`));
+      throw new ExitCodeError(1);
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk3.red("Error setting configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  userCommand.command("get").description("Get a user-scope configuration value using dot-notation path").argument("<path>", "Config path (e.g., defaults.provider)").option("-j, --json", "Output as JSON").action(async (path, options) => {
+    try {
+      const configManager = new ConfigManager();
+      const value = await configManager.getConfigValue(path, "user");
+      if (options.json) {
+        console.log(JSON.stringify(buildConfigGetJsonPayload(path, "user", value), null, 2));
+      } else if (value === void 0) {
+        await printConfigScopeMiss(
+          path,
+          "user",
+          (configPath, configScope) => configManager.getConfigValue(configPath, configScope)
+        );
+      } else {
+        console.log(chalk3.cyan(`${path}`), "=", formatConfigGetValueForDisplay(path, value));
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk3.red("Error getting configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.addCommand(userCommand);
+  configCommand.command("cleanup").description("Clean up configuration artifacts").option("--backups", "Remove old backup files (keeps last 3)").option("--dry-run", "Show what would be deleted without actually deleting").action(async (options) => {
+    try {
+      const { existsSync: existsSync2, readdirSync, unlinkSync, statSync } = await import("fs");
+      const { join: join2 } = await import("path");
+      console.log(chalk3.bold.blue("\nConfiguration Cleanup\n"));
+      if (options.backups) {
+        const configDir = getConfigPaths(process.cwd()).projectConfigDir;
+        if (!existsSync2(configDir)) {
+          console.log(chalk3.yellow("No .build-project/config directory found."));
+          return;
+        }
+        const files = readdirSync(configDir);
+        const backupFiles = files.filter((f) => f.startsWith("build.config.backup.")).map((f) => ({
+          name: f,
+          path: join2(configDir, f),
+          mtime: statSync(join2(configDir, f)).mtime.getTime()
+        })).sort((a, b) => b.mtime - a.mtime);
+        if (backupFiles.length === 0) {
+          console.log(chalk3.green("No backup files found."));
+          return;
+        }
+        const toDelete = backupFiles.slice(3);
+        const toKeep = backupFiles.slice(0, 3);
+        console.log(chalk3.gray(`Found ${backupFiles.length} backup files.`));
+        console.log(chalk3.green(`Keeping ${toKeep.length} most recent:`));
+        for (const f of toKeep) {
+          console.log(chalk3.gray(`  OK ${f.name}`));
+        }
+        if (toDelete.length === 0) {
+          console.log(chalk3.green("\nNo files to delete."));
+          return;
+        }
+        console.log(chalk3.yellow(`
+Deleting ${toDelete.length} old backups:`));
+        for (const f of toDelete) {
+          console.log(chalk3.gray(`  Error ${f.name}`));
+          if (!options.dryRun) {
+            unlinkSync(f.path);
+          }
+        }
+        if (options.dryRun) {
+          console.log(chalk3.yellow("\n(Dry run - no files were actually deleted)"));
+        } else {
+          console.log(chalk3.green(`
+OK: Deleted ${toDelete.length} backup files.`));
+        }
+      } else {
+        console.log(chalk3.gray("Use --backups to remove old backup files."));
+        console.log(chalk3.gray("Example: build config cleanup --backups"));
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk3.red("Error during cleanup:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  configCommand.command("explain [key]").description("Show env-registry key details (type, default, current value, source)").option("-j, --json", "Output as JSON").option(
+    "--category <name>",
+    "Filter to one category (core/provider/judge/feature/orchestrator/telemetry/sandbox/autoloop/test/worktree/repair)"
+  ).option("--show-deprecated", "Include deprecated keys (hidden by default)").option("--source <source>", "Filter by source: env | default | unset").action(
+    async (key, options) => {
+      try {
+        const { explainEnvKey, explainAllEnvKeys } = await import("./config-explain-4LMO556H.js");
+        if (key !== void 0) {
+          const result = explainEnvKey(key);
+          if (result === void 0) {
+            if (options.json) {
+              renderJsonError(
+                new ValidationError(`Unknown env key: ${key}`, {
+                  key
+                })
+              );
+              throw new ExitCodeError(1);
+            }
+            console.error(`Error: Unknown env key: ${key}`);
+            throw new ExitCodeError(1);
+          }
+          if (options.json) {
+            console.log(JSON.stringify(redactConfigValueForDisplay("", result), null, 2));
+            return;
+          }
+          printExplainRow(result);
+          return;
+        }
+        const results = explainAllEnvKeys({
+          category: options.category,
+          showDeprecated: options.showDeprecated ?? false,
+          source: options.source
+        });
+        if (options.json) {
+          console.log(JSON.stringify(redactConfigValueForDisplay("", results), null, 2));
+          return;
+        }
+        for (const result of results) {
+          printExplainRow(result);
+        }
+      } catch (error) {
+        if (error instanceof ExitCodeError) throw error;
+        console.error(chalk3.red("Error running config explain:"), errorMessage(error));
+        throw new ExitCodeError(1);
+      }
+    }
+  );
+  configCommand.command("audit").description(
+    "Audit configuration: report direct env reads, unregistered vars, deprecated aliases, and migration risks"
+  ).option("--fix-plan", "Output a structured fix plan").option("-j, --json", "JSON output").option("--severity <level>", "Filter findings (error|warn|info)").action(async (options) => {
+    try {
+      const { runAudit, formatAuditPlain, formatAuditJson } = await import("./config-audit-GA5DCUAI.js");
+      let findings = await runAudit({ cwd: process.cwd() });
+      if (options.severity) {
+        const level = options.severity;
+        if (!["error", "warn", "info"].includes(level)) {
+          console.error(`Error: Invalid severity filter "${level}". Use error, warn, or info.`);
+          throw new ExitCodeError(1);
+        }
+        findings = findings.filter((f) => f.severity === level);
+      }
+      const errors = findings.filter((f) => f.severity === "error").length;
+      if (options.json) {
+        console.log(formatAuditJson(findings));
+        if (errors > 0) {
+          throw new ExitCodeError(1);
+        }
+        return;
+      }
+      if (options.fixPlan) {
+        console.log("Config audit fix plan\n");
+        console.log(formatAuditPlain(findings));
+        return;
+      }
+      const warns = findings.filter((f) => f.severity === "warn").length;
+      const infos = findings.filter((f) => f.severity === "info").length;
+      if (findings.length === 0) {
+        console.log("OK: No audit findings.");
+        return;
+      }
+      console.log(`Audit: ${errors} error(s), ${warns} warn(s), ${infos} info(s)`);
+      for (const f of findings) {
+        const loc = f.location?.path ? ` [${f.location.line ? `${f.location.path}:${f.location.line}` : f.location.path}]` : "";
+        console.log(`[${f.severity}] ${f.title}${loc}`);
+      }
+      if (errors > 0) {
+        throw new ExitCodeError(1);
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error("Error running config audit:", errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  return configCommand;
+}
+
+export {
+  projectModelAliases,
+  projectModelAliasListing,
+  sortedModelAliasListing,
+  redactConfigValueForDisplay,
+  formatConfigGetValueForDisplay,
+  formatConfigSetValueForDisplay,
+  buildConfigGetJsonPayload,
+  buildConfigScopeMissLines,
+  createConfigCommand
+};
+//# sourceMappingURL=chunk-RGJU63FV.js.map