@poetic-ai/poetic 1.42.0

package/dist/chunk-2N42MS2Z.js

@@ -0,0 +1,2193 @@
+import {
+  renderJsonError,
+  renderJsonResult
+} from "./chunk-Q3RO7N35.js";
+import {
+  readJudgeTypeEnv,
+  resolveCompeteConfig
+} from "./chunk-WTOKKE2V.js";
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import {
+  ConfigManager
+} from "./chunk-H66DXFS5.js";
+import {
+  isSensitiveConfigPath,
+  redactSensitiveConfig
+} from "./chunk-3M57DADF.js";
+import {
+  generateValidationReport,
+  validatePoeticConfig
+} from "./chunk-CUSRN6RJ.js";
+import {
+  registry
+} from "./chunk-Z2KYOFHS.js";
+import {
+  resolveExecutionRoles,
+  resolveExecutorRoleTarget
+} from "./chunk-YB3JD4E6.js";
+import {
+  formatResolvedValue,
+  getConfigSummary,
+  resolveConfig
+} from "./chunk-XPU2XADL.js";
+import {
+  getConfigDiagnostics
+} from "./chunk-SZ7DL357.js";
+import {
+  normalizeEngineId
+} from "./chunk-SURZ2WFE.js";
+import {
+  isPoeticConfigReadError
+} from "./chunk-G36W2T2S.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  safeJsonParse
+} from "./chunk-S54MKU6V.js";
+import {
+  ValidationError
+} from "./chunk-LUVKFFWR.js";
+import {
+  BooleanFlagSchema,
+  ExistingFilePathSchema,
+  FilePathSchema,
+  formatValidationErrors,
+  validateCommandOptions
+} from "./chunk-QOCOVLUH.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  getConfigPaths
+} from "./chunk-L6OM4A22.js";
+import {
+  sanitizeString,
+  sanitizeValue
+} from "./chunk-LPITVM7M.js";
+import {
+  POETIC_MATRIX_BORDERLINE_MARGIN,
+  POETIC_MATRIX_CLOSE_CALL_MARGIN,
+  POETIC_MATRIX_CONFIDENCE_THRESHOLD,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/cli/commands/config.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import chalk2 from "chalk";
+import { Command as Command2 } from "commander";
+import { z } from "zod";
+
+// src/cli/commands/config-migrate.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
+import { glob } from "fs/promises";
+import { basename, dirname, extname, join, resolve as resolve2 } from "path";
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/config/migration-tools.ts
+import { XMLParser } from "fast-xml-parser";
+import yaml from "js-yaml";
+
+// src/config/schema-validator.ts
+import { existsSync, readFileSync } from "fs";
+import path, { resolve } from "path";
+import { fileURLToPath } from "url";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function resolveDefaultSchemaDir() {
+  const candidates = [
+    // Source execution: src/config/schema-validator.ts -> repo/schemas
+    resolve(__dirname, "../../schemas"),
+    // Bundled package execution: dist/*.js -> package/schemas
+    resolve(__dirname, "../schemas")
+  ];
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+var SchemaValidator = class {
+  ajv;
+  schemaCache = /* @__PURE__ */ new Map();
+  schemaDir;
+  constructor(schemaDir) {
+    this.schemaDir = schemaDir || resolveDefaultSchemaDir();
+    this.ajv = new Ajv({
+      allErrors: true,
+      // Report all errors, not just the first
+      verbose: true,
+      // Include schema information in errors
+      strict: false,
+      // Allow unknown keywords
+      validateFormats: true,
+      // Validate format keywords
+      loadSchema: this.loadExternalSchema.bind(this)
+    });
+    addFormats(this.ajv);
+  }
+  /**
+   * Load external schema file ($ref support)
+   */
+  async loadExternalSchema(uri) {
+    let schemaPath;
+    if (uri.startsWith("https://poetic.dev/schemas/")) {
+      const fileName = uri.replace("https://poetic.dev/schemas/", "");
+      schemaPath = resolve(this.schemaDir, fileName);
+    } else if (uri.endsWith(".schema.json")) {
+      schemaPath = resolve(this.schemaDir, uri);
+    } else {
+      throw new Error(`Cannot resolve schema URI: ${uri}`);
+    }
+    try {
+      const schemaContent = readFileSync(schemaPath, "utf-8");
+      return safeJsonParse(schemaContent, {
+        maxDepth: 100,
+        context: `external schema URI: ${uri}`
+      });
+    } catch (error) {
+      throw new Error(`Failed to load schema from ${schemaPath}: ${error}`);
+    }
+  }
+  /**
+   * Load and compile a JSON schema
+   */
+  async loadSchema(schemaName) {
+    if (this.schemaCache.has(schemaName)) {
+      return this.schemaCache.get(schemaName);
+    }
+    const schemaPath = resolve(this.schemaDir, schemaName);
+    const schemaContent = readFileSync(schemaPath, "utf-8");
+    const schema = safeJsonParse(schemaContent, {
+      maxDepth: 100,
+      context: `schema file: ${schemaName}`
+    });
+    const validate = await this.ajv.compileAsync(schema);
+    this.schemaCache.set(schemaName, validate);
+    return validate;
+  }
+  /**
+   * Validate configuration against schema
+   */
+  async validateConfig(config, schemaName = "poetic.config.schema.json") {
+    const startTime = performance.now();
+    try {
+      const validate = await this.loadSchema(schemaName);
+      const valid = validate(config);
+      const validationTimeMs = performance.now() - startTime;
+      if (valid) {
+        return {
+          valid: true,
+          performance: { validationTimeMs }
+        };
+      }
+      const errors = this.formatErrors(validate.errors || []);
+      return {
+        valid: false,
+        errors,
+        performance: { validationTimeMs }
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          {
+            name: "ValidationError",
+            path: "",
+            message: `Schema validation failed: ${error}`,
+            suggestion: "Check that the schema file exists and is valid JSON"
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Format AJV errors into user-friendly messages
+   */
+  formatErrors(ajvErrors) {
+    return ajvErrors.map((error) => {
+      const path2 = error.instancePath || "/";
+      let message = error.message || "Validation failed";
+      let suggestion;
+      switch (error.keyword) {
+        case "type":
+          message = `Expected ${error.params.type}, got ${typeof error.data}`;
+          suggestion = `Change the value to a ${error.params.type}`;
+          break;
+        case "required":
+          message = `Missing required field: ${error.params.missingProperty}`;
+          suggestion = `Add the "${error.params.missingProperty}" field to your configuration`;
+          break;
+        case "enum":
+          message = `Invalid value. Allowed values: ${error.params.allowedValues.join(", ")}`;
+          suggestion = `Choose one of: ${error.params.allowedValues.join(", ")}`;
+          break;
+        case "minimum":
+          message = `Value must be >= ${error.params.limit}`;
+          suggestion = `Increase the value to at least ${error.params.limit}`;
+          break;
+        case "maximum":
+          message = `Value must be <= ${error.params.limit}`;
+          suggestion = `Decrease the value to at most ${error.params.limit}`;
+          break;
+        case "minLength":
+          message = `String must be at least ${error.params.limit} characters`;
+          suggestion = "Provide a longer value";
+          break;
+        case "pattern":
+          message = `String must match pattern: ${error.params.pattern}`;
+          suggestion = "Check the format requirements in the schema documentation";
+          break;
+        case "format":
+          message = `Invalid ${error.params.format} format`;
+          if (error.params.format === "date-time") {
+            suggestion = "Use ISO 8601 format: YYYY-MM-DDTHH:mm:ssZ";
+          } else if (error.params.format === "uri") {
+            suggestion = "Provide a valid URL (e.g., https://example.com)";
+          }
+          break;
+        case "additionalProperties":
+          message = `Unknown field: ${error.params.additionalProperty}`;
+          suggestion = "Remove this field or check for typos";
+          break;
+      }
+      return {
+        name: "ValidationError",
+        path: path2 === "/" ? "(root)" : path2.replace(/^\//, ""),
+        message,
+        value: error.data,
+        expected: error.schema,
+        suggestion
+      };
+    });
+  }
+  /**
+   * Validate and throw on error (for convenience)
+   */
+  async validateOrThrow(config, schemaName) {
+    const result = await this.validateConfig(config, schemaName);
+    if (!result.valid) {
+      const errorMessages = result.errors?.map((err) => {
+        let msg = `  \u2022 ${err.path}: ${err.message}`;
+        if (err.suggestion) {
+          msg += `
+    \u2192 ${err.suggestion}`;
+        }
+        return msg;
+      }).join("\n");
+      throw new SchemaValidationError(`Configuration validation failed:
+${errorMessages}`);
+    }
+  }
+  /**
+   * Clear schema cache (useful for testing)
+   */
+  clearCache() {
+    this.schemaCache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.schemaCache.size,
+      schemas: Array.from(this.schemaCache.keys())
+    };
+  }
+};
+var SchemaValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SchemaValidationError";
+  }
+};
+var validatorInstance = null;
+function getValidator() {
+  if (!validatorInstance) {
+    validatorInstance = new SchemaValidator();
+  }
+  return validatorInstance;
+}
+async function validateConfig(config, schemaName) {
+  return getValidator().validateConfig(config, schemaName);
+}
+
+// src/config/migration-tools.ts
+function detectFormat(content, fileName) {
+  const trimmed = content.trim();
+  if (fileName) {
+    if (fileName.endsWith(".json")) return "json";
+    if (fileName.endsWith(".xml")) return "xml";
+    if (fileName.endsWith(".yml") || fileName.endsWith(".yaml")) return "yaml";
+  }
+  if (trimmed.startsWith("<")) {
+    return "xml";
+  }
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      parseJsonWithContext(content, "config format detection");
+      return "json";
+    } catch {
+    }
+  }
+  if (trimmed.includes(":") && (trimmed.includes("\n") || trimmed.includes("\r")) && !trimmed.startsWith("<")) {
+    return "yaml";
+  }
+  return "unknown";
+}
+function parseXML(content) {
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    textNodeName: "#text",
+    // Keep attributes as strings so identifiers and versions such as "1.0" are preserved.
+    parseAttributeValue: false,
+    parseTagValue: true,
+    trimValues: true,
+    // Handle CDATA
+    cdataPropName: "#cdata"
+  });
+  const parsed = parser.parse(content);
+  return cleanXMLStructure(parsed);
+}
+function cleanXMLStructure(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => cleanXMLStructure(item));
+  }
+  const cleaned = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith("?xml")) {
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
+      if ("#text" in value && Object.keys(value).length === 1) {
+        cleaned[key] = value["#text"];
+      } else {
+        cleaned[key] = cleanXMLStructure(value);
+      }
+    } else {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+async function xmlToJson(content, options = {}) {
+  try {
+    const data = parseXML(content);
+    const json = JSON.stringify(data, null, options.prettyPrint !== false ? 2 : 0);
+    let validation;
+    if (options.validate && options.schemaName) {
+      validation = await validateConfig(data, options.schemaName);
+      if (!validation.valid) {
+        return {
+          success: false,
+          format: "xml",
+          data,
+          json,
+          validation,
+          errors: validation.errors && validation.errors.length > 0 ? validation.errors.map(
+            (err) => `Schema validation failed at ${err.path}: ${err.message}`
+          ) : ["Schema validation failed"]
+        };
+      }
+    }
+    return {
+      success: true,
+      format: "xml",
+      data,
+      json,
+      validation
+    };
+  } catch (error) {
+    return {
+      success: false,
+      format: "xml",
+      errors: [`XML parsing failed: ${error}`]
+    };
+  }
+}
+async function yamlToJson(content, options = {}) {
+  try {
+    const data = yaml.load(content, { schema: yaml.JSON_SCHEMA });
+    const json = JSON.stringify(data, null, options.prettyPrint !== false ? 2 : 0);
+    let validation;
+    if (options.validate && options.schemaName) {
+      validation = await validateConfig(data, options.schemaName);
+      if (!validation.valid) {
+        return {
+          success: false,
+          format: "yaml",
+          data,
+          json,
+          validation,
+          errors: validation.errors && validation.errors.length > 0 ? validation.errors.map(
+            (err) => `Schema validation failed at ${err.path}: ${err.message}`
+          ) : ["Schema validation failed"]
+        };
+      }
+    }
+    return {
+      success: true,
+      format: "yaml",
+      data,
+      json,
+      validation
+    };
+  } catch (error) {
+    return {
+      success: false,
+      format: "yaml",
+      errors: [`YAML parsing failed: ${error}`]
+    };
+  }
+}
+async function migrateToJson(content, fileName, options = {}) {
+  const format = detectFormat(content, fileName);
+  switch (format) {
+    case "json":
+      try {
+        const data = parseJsonWithContext(content, "user config migration");
+        const json = options.prettyPrint !== false ? JSON.stringify(data, null, 2) : content;
+        let validation;
+        if (options.validate && options.schemaName) {
+          validation = await validateConfig(data, options.schemaName);
+          if (!validation.valid) {
+            return {
+              success: false,
+              format: "json",
+              data,
+              json,
+              validation,
+              errors: validation.errors && validation.errors.length > 0 ? validation.errors.map(
+                (err) => `Schema validation failed at ${err.path}: ${err.message}`
+              ) : ["Schema validation failed"],
+              warnings: ["File is already in JSON format"]
+            };
+          }
+        }
+        return {
+          success: true,
+          format: "json",
+          data,
+          json,
+          validation,
+          warnings: ["File is already in JSON format"]
+        };
+      } catch (error) {
+        return {
+          success: false,
+          format: "json",
+          errors: [`Invalid JSON: ${error}`]
+        };
+      }
+    case "xml":
+      return xmlToJson(content, options);
+    case "yaml":
+      return yamlToJson(content, options);
+    default:
+      return {
+        success: false,
+        format: "unknown",
+        errors: ["Could not detect configuration format"]
+      };
+  }
+}
+async function batchMigrate(files, options = {}) {
+  const results = [];
+  let successful = 0;
+  let failed = 0;
+  for (const file of files) {
+    const result = await migrateToJson(file.content, file.name, options);
+    results.push({ fileName: file.name, result });
+    if (result.success) {
+      successful++;
+    } else {
+      failed++;
+    }
+  }
+  return {
+    total: files.length,
+    successful,
+    failed,
+    results
+  };
+}
+function generateMigrationReport(results) {
+  const lines = [];
+  lines.push("# Configuration Migration Report");
+  lines.push("");
+  lines.push(`Total files: ${results.total}`);
+  lines.push(`Successful: ${results.successful}`);
+  lines.push(`Failed: ${results.failed}`);
+  lines.push("");
+  if (results.successful > 0) {
+    lines.push("## Successful Migrations");
+    lines.push("");
+    for (const { fileName, result } of results.results) {
+      if (result.success) {
+        lines.push(`- OK: ${fileName} (${result.format} -> JSON)`);
+        if (result.warnings && result.warnings.length > 0) {
+          for (const warning of result.warnings) {
+            lines.push(`  Warning: ${warning}`);
+          }
+        }
+        if (result.validation && !result.validation.valid) {
+          lines.push("  Error: Validation failed");
+        }
+      }
+    }
+    lines.push("");
+  }
+  if (results.failed > 0) {
+    lines.push("## Failed Migrations");
+    lines.push("");
+    for (const { fileName, result } of results.results) {
+      if (!result.success) {
+        lines.push(`- Error: ${fileName}`);
+        if (result.errors) {
+          for (const error of result.errors) {
+            lines.push(`  ${error}`);
+          }
+        }
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/config-migrate.ts
+function migratedOutputPath(inputPath) {
+  const extension = extname(inputPath);
+  if (/^\.(xml|yml|yaml)$/i.test(extension)) {
+    return `${inputPath.slice(0, -extension.length)}.json`;
+  }
+  const directory = dirname(inputPath);
+  const baseName = basename(inputPath, extension);
+  const suffix = extension.toLowerCase() === ".json" ? ".migrated.json" : ".json";
+  return join(directory, `${baseName}${suffix}`);
+}
+function uniqueBackupPath(filePath) {
+  let candidate = `${filePath}.backup`;
+  let index = 1;
+  while (existsSync2(candidate)) {
+    if (index > 1e3) {
+      throw new Error(`Unable to allocate unique backup path for ${filePath}`);
+    }
+    candidate = `${filePath}.backup.${index}`;
+    index += 1;
+  }
+  return candidate;
+}
+function createConfigMigrateCommand() {
+  const migrateCommand = new Command("migrate").description(
+    "Migrate configuration files from legacy formats (XML, YAML) to JSON"
+  );
+  migrateCommand.command("file").description("Migrate a single configuration file to JSON").argument("<input>", "Input file path (XML, YAML, or JSON)").option("-o, --output <path>", "Output file path (default: same name with .json extension)").option(
+    "--no-validate",
+    "Skip schema validation after migration (explicit unchecked-output override)"
+  ).option("--schema <name>", "Schema name to validate against", "poetic.config.schema.json").option("--dry-run", "Show migration result without writing file").option("--no-backup", "Skip creating backup of original file").action(async (input, options) => {
+    try {
+      const inputPath = resolve2(input);
+      if (!existsSync2(inputPath)) {
+        console.error(chalk.red(`Error: File not found: ${inputPath}`));
+        process.exit(1);
+      }
+      const content = readFileSync2(inputPath, "utf-8");
+      const format = detectFormat(content, inputPath);
+      console.log(chalk.blue(`Migrating ${format.toUpperCase()} configuration...`));
+      console.log(chalk.gray(`   Input: ${inputPath}`));
+      const migrationOptions = {
+        validate: options.validate !== false,
+        schemaName: options.schema,
+        prettyPrint: true
+      };
+      const result = await migrateToJson(content, inputPath, migrationOptions);
+      if (!result.success) {
+        console.error(chalk.red("\nError: Migration failed:"));
+        for (const error of result.errors || []) {
+          console.error(chalk.red(`   ${error}`));
+        }
+        if (result.validation && !result.validation.valid) {
+          console.error(chalk.red("\nError: Validation issues:"));
+          for (const error of result.validation.errors || []) {
+            console.error(chalk.red(`   \u2022 ${error.path}: ${error.message}`));
+            if (error.suggestion) {
+              console.error(chalk.gray(`     \u2192 ${error.suggestion}`));
+            }
+          }
+        }
+        process.exit(1);
+      }
+      if (result.warnings && result.warnings.length > 0) {
+        console.log(chalk.yellow("\nWarning: Warnings:"));
+        for (const warning of result.warnings) {
+          console.log(chalk.yellow(`   ${warning}`));
+        }
+      }
+      const outputPath = options.output ? resolve2(options.output) : migratedOutputPath(inputPath);
+      if (options.dryRun) {
+        console.log(chalk.green("\nOK: Migration successful (dry run)"));
+        console.log(chalk.gray(`   Would write to: ${outputPath}`));
+        console.log(chalk.cyan("\nMigrated JSON:"));
+        console.log(result.json);
+      } else {
+        if (options.backup !== false && (format !== "json" || outputPath === inputPath)) {
+          const backupPath = uniqueBackupPath(inputPath);
+          writeFileSync(backupPath, content, "utf-8");
+          console.log(chalk.gray(`   Backup: ${backupPath}`));
+        }
+        const outputContent = outputPath.endsWith(".js") || outputPath.endsWith(".mjs") ? `export default ${result.json};
+` : result.json;
+        writeFileSync(outputPath, outputContent, "utf-8");
+        console.log(chalk.green("\nOK: Migration successful"));
+        console.log(chalk.gray(`   Output: ${outputPath}`));
+      }
+      if (result.validation) {
+        const validationTimeMs = result.validation.performance?.validationTimeMs;
+        console.log(
+          chalk.gray(
+            `   Validation: ${typeof validationTimeMs === "number" ? validationTimeMs.toFixed(2) : "n/a"}ms`
+          )
+        );
+      }
+    } catch (error) {
+      console.error(chalk.red(`
+Error: Migration failed: ${error}`));
+      process.exit(1);
+    }
+  });
+  migrateCommand.command("batch").description("Migrate multiple configuration files").argument("<pattern>", 'Glob pattern for files to migrate (e.g., "config/**/*.xml")').option(
+    "--no-validate",
+    "Skip schema validation after migration (explicit unchecked-output override)"
+  ).option("--schema <name>", "Schema name to validate against", "poetic.config.schema.json").option("--dry-run", "Show what would be migrated without writing files").option("--no-backup", "Skip creating backups of original files").action(async (pattern, options) => {
+    try {
+      console.log(chalk.blue(`Searching for files matching: ${pattern}`));
+      const files = [];
+      for await (const entry of glob(pattern)) {
+        if (typeof entry === "string") {
+          try {
+            const stats = statSync(entry);
+            if (stats.isFile()) {
+              files.push(entry);
+            }
+          } catch {
+          }
+        }
+      }
+      if (files.length === 0) {
+        console.log(chalk.yellow("Warning: No files found"));
+        return;
+      }
+      console.log(chalk.blue(`Found ${files.length} file(s) to migrate
+`));
+      const fileContents = files.map((filePath) => ({
+        name: filePath,
+        content: readFileSync2(filePath, "utf-8")
+      }));
+      const migrationOptions = {
+        validate: options.validate !== false,
+        schemaName: options.schema,
+        prettyPrint: true
+      };
+      const batchResult = await batchMigrate(fileContents, migrationOptions);
+      const report = generateMigrationReport(batchResult);
+      console.log(report);
+      const hasFailure = batchResult.failed > 0 || batchResult.results.some(({ result }) => !result.success);
+      if (hasFailure) {
+        console.error(
+          chalk.red(
+            `
+Error: Batch migration failed (${batchResult.failed}/${batchResult.total} file(s)); no files written`
+          )
+        );
+        process.exit(1);
+      }
+      if (!options.dryRun) {
+        for (const { fileName, result } of batchResult.results) {
+          if (result.success && result.json) {
+            const outputPath = migratedOutputPath(fileName);
+            const format = result.format;
+            if (options.backup !== false && (format !== "json" || outputPath === fileName)) {
+              const backupPath = uniqueBackupPath(fileName);
+              const fileContent = fileContents.find(
+                (f) => f.name === fileName
+              );
+              if (fileContent) {
+                writeFileSync(backupPath, fileContent.content, "utf-8");
+              }
+            }
+            writeFileSync(outputPath, result.json, "utf-8");
+          }
+        }
+        console.log(chalk.green("\nOK: Batch migration complete"));
+        console.log(chalk.gray(`   Migrated: ${batchResult.successful}/${batchResult.total}`));
+      } else {
+        console.log(chalk.blue("\nDry run complete (no files written)"));
+      }
+    } catch (error) {
+      console.error(chalk.red(`
+Error: Batch migration failed: ${error}`));
+      process.exit(1);
+    }
+  });
+  migrateCommand.command("validate").description("Validate configuration file against JSON Schema").argument("<input>", "Configuration file to validate").option("--schema <name>", "Schema name to validate against", "poetic.config.schema.json").option("-v, --verbose", "Show detailed validation information").action(async (input, options) => {
+    try {
+      const inputPath = resolve2(input);
+      if (!existsSync2(inputPath)) {
+        console.error(chalk.red(`Error: File not found: ${inputPath}`));
+        process.exit(1);
+      }
+      console.log(chalk.blue("Validating configuration..."));
+      console.log(chalk.gray(`   File: ${inputPath}`));
+      console.log(chalk.gray(`   Schema: ${options.schema}
+`));
+      const content = readFileSync2(inputPath, "utf-8");
+      const config = parseJsonWithContext(
+        content,
+        `Config file (${inputPath})`
+      );
+      const result = await validateConfig(config, options.schema);
+      if (result.valid) {
+        console.log(chalk.green("OK: Configuration is valid"));
+        if (options.verbose && result.performance) {
+          console.log(
+            chalk.gray(`   Validation time: ${result.performance.validationTimeMs.toFixed(2)}ms`)
+          );
+        }
+      } else {
+        console.log(chalk.red("Error: Configuration validation failed:"));
+        for (const error of result.errors || []) {
+          console.log(chalk.red(`   \u2022 ${error.path}: ${error.message}`));
+          if (error.suggestion) {
+            console.log(chalk.gray(`     \u2192 ${error.suggestion}`));
+          }
+        }
+        process.exit(1);
+      }
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        console.error(chalk.red(`Error: Invalid JSON: ${error.message}`));
+      } else {
+        console.error(chalk.red(`Error: Validation failed: ${error}`));
+      }
+      process.exit(1);
+    }
+  });
+  return migrateCommand;
+}
+
+// src/cli/commands/config.ts
+var REDACTED_CONFIG_VALUE = "<redacted>";
+function qualityGateStatus(enabled) {
+  return enabled ? chalk2.green("OK") : chalk2.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(path2, value) {
+  if (isSensitiveConfigPath(path2)) {
+    return REDACTED_CONFIG_VALUE;
+  }
+  return sanitizeConfigStrings(redactSensitiveConfig(value, path2.split(".").filter(Boolean)));
+}
+function formatConfigGetValueForDisplay(path2, value) {
+  const displayValue = redactConfigValueForDisplay(path2, value);
+  return typeof displayValue === "string" ? displayValue : JSON.stringify(displayValue, null, 2);
+}
+function formatConfigSetValueForDisplay(path2, value) {
+  if (isSensitiveConfigPath(path2)) {
+    return "<redacted>";
+  }
+  const displayValue = redactConfigValueForDisplay(path2, value);
+  return typeof displayValue === "string" ? displayValue : JSON.stringify(displayValue);
+}
+function buildConfigGetJsonPayload(path2, scope, value) {
+  const found = value !== void 0;
+  return {
+    path: path2,
+    scope,
+    found,
+    value: found ? redactConfigValueForDisplay(path2, value) : null
+  };
+}
+function buildConfigScopeMissLines(path2, scope, alternateScopeValue) {
+  const lines = [`${path2} is not set (scope: ${scope})`];
+  if (alternateScopeValue !== void 0) {
+    const alternateScope = scope === "project" ? "user" : "project";
+    const retryHint = alternateScope === "user" ? "poetic config get --scope user" : "poetic config get";
+    lines.push(
+      `  Tip: value is set in ${alternateScope} scope; retry with \`${retryHint} ${path2}\` or use \`poetic config resolved\` for the effective value.`
+    );
+  }
+  return lines;
+}
+async function printConfigScopeMiss(path2, scope, getConfigValue) {
+  const alternateScope = scope === "project" ? "user" : "project";
+  const alternateScopeValue = await getConfigValue(path2, alternateScope);
+  for (const line of buildConfigScopeMissLines(path2, scope, alternateScopeValue)) {
+    console.log(chalk2.yellow(line));
+  }
+}
+function formatResolvedConfigSummaryLine(summary) {
+  return `  ${chalk2.cyan(summary.provider)} \xB7 ${chalk2.cyan(summary.model)} \xB7 ${chalk2.cyan(summary.strategy)} \xB7 routing:${chalk2.cyan(summary.routingPolicy)} \xB7 blockers:${chalk2.cyan(summary.blockerMode)} \xB7 transport:${chalk2.cyan(summary.transport)} \xB7 judge:${chalk2.cyan(summary.judge.type)}`;
+}
+function errorMessage(error) {
+  return sanitizeValue(error);
+}
+function configReadRepairHint(error) {
+  return `Fix or remove ${error.filePath}; Poetic will not ignore an existing invalid config file.`;
+}
+function renderConfigReadFailure(error, json = false) {
+  if (!isPoeticConfigReadError(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(chalk2.red(`Error: ${error.message}`));
+  writeConfigError(chalk2.gray(repairHint));
+  return true;
+}
+function writeConfigLine(line = "") {
+  process.stdout.write(`${line}
+`);
+}
+function writeConfigError(line) {
+  process.stderr.write(`${line}
+`);
+}
+function printResolvedRoles(roles) {
+  const src = (r) => chalk2.gray(`[${r.sourcePath ?? r.source}]`);
+  const { orchestrator, executor, reviewer } = roles;
+  writeConfigLine(chalk2.bold.blue("\nExecution Roles\n"));
+  if (orchestrator.provider) {
+    writeConfigLine(
+      `  roles.orchestrator.provider: ${chalk2.cyan(orchestrator.provider.value)} ${src(orchestrator.provider)}`
+    );
+  }
+  if (orchestrator.model) {
+    writeConfigLine(
+      `  roles.orchestrator.model:    ${chalk2.cyan(orchestrator.model.value)} ${src(orchestrator.model)}`
+    );
+  }
+  if (orchestrator.fallbackModel) {
+    writeConfigLine(
+      `  roles.orchestrator.fallback: ${chalk2.cyan(orchestrator.fallbackModel.value)} ${src(orchestrator.fallbackModel)}`
+    );
+  }
+  writeConfigLine(
+    `  roles.executor.provider:  ${chalk2.cyan(executor.provider.value)} ${src(executor.provider)}`
+  );
+  writeConfigLine(
+    `  roles.executor.model:     ${chalk2.cyan(executor.model.value)} ${src(executor.model)}`
+  );
+  writeConfigLine(
+    `  roles.executor.subagents: ${chalk2.cyan(String(executor.subagents.value))} ${src(executor.subagents)}`
+  );
+  writeConfigLine(
+    `  roles.executor.transport: ${chalk2.cyan(executor.transport.value)} ${src(executor.transport)}`
+  );
+  writeConfigLine(
+    `  roles.reviewer.provider:  ${chalk2.cyan(reviewer.provider.value)} ${src(reviewer.provider)}`
+  );
+  writeConfigLine(
+    `  roles.reviewer.model:     ${chalk2.cyan(reviewer.model.value)} ${src(reviewer.model)}`
+  );
+  writeConfigLine(
+    `  roles.reviewer.gate:      ${chalk2.cyan(reviewer.gate.value)} ${src(reviewer.gate)}`
+  );
+  if (roles.sameVendorReview) {
+    writeConfigLine(
+      `  ${chalk2.yellow("Note:")} reviewer matches an executor provider; executor separation is unavailable`
+    );
+  }
+}
+async function buildResolvedExecutorModelQuery(provider, cwd) {
+  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
+    }
+  };
+}
+async function buildExecutionPreview(resolved) {
+  const envOverrideKeys = [
+    "POETIC_DEFAULT_PROVIDER",
+    "POETIC_DEFAULT_STRATEGY",
+    "POETIC_JUDGE_TYPE",
+    "POETIC_JUDGE",
+    "POETIC_JUDGE_RUN",
+    "POETIC_JUDGE_PRIMARY",
+    "POETIC_AI_JUDGE_RUN",
+    "POETIC_AI_JUDGE_PRIMARY",
+    "POETIC_COMPLETION_MODE",
+    "POETIC_TIMEOUT_MS",
+    "POETIC_CLAUDE_EXECUTION_TRANSPORT",
+    "POETIC_CODEX_EXECUTION_TRANSPORT",
+    "POETIC_PROVIDER_EXECUTION_TRANSPORT",
+    "POETIC_EXECUTION_TRANSPORT",
+    "POETIC_SYNTHESIS_STRATEGY",
+    "POETIC_SYNTHESIS_AI_FIRST"
+  ];
+  let compete;
+  try {
+    compete = await resolveCompeteConfig({}, { projectRoot: process.cwd() });
+  } catch (error) {
+    compete = { error: errorMessage(error) };
+  }
+  return {
+    run: {
+      provider: formatResolvedValue(resolved.defaultProvider),
+      model: formatResolvedValue(resolved.defaultModel),
+      strategy: formatResolvedValue(resolved.defaultStrategy),
+      transport: formatResolvedValue(resolved.providerExecutionTransport.current),
+      judge: {
+        type: formatResolvedValue(resolved.judge.type),
+        provider: formatResolvedValue(resolved.judge.provider),
+        model: formatResolvedValue(resolved.judge.model)
+      }
+    },
+    compete,
+    envOverrides: envOverrideKeys.filter((key) => process.env[key]?.trim())
+  };
+}
+function printExplainRow(result) {
+  const parts = [
+    chalk2.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(chalk2.yellow(`deprecated${result.replacement ? `->${result.replacement}` : ""}`));
+  }
+  if (result.error !== void 0) {
+    parts.push(chalk2.red(`error: ${result.error}`));
+  }
+  console.log(parts.join("  "));
+}
+function createConfigCommand() {
+  const configCommand = new Command2("config").alias("settings").description("Manage Poetic 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("poetic-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(chalk2.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk2.gray('\nTip: Use "poetic 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,
+            effectiveModel: config.effectiveModel,
+            isFirstTimeUser: config.isFirstTimeUser,
+            loadTime: config.loadTime
+          })
+        );
+        return;
+      }
+      console.log(chalk2.bold.blue("\nPoetic Configuration\n"));
+      console.log(chalk2.bold("Effective Settings:"));
+      console.log(`  Default Provider: ${chalk2.cyan(resolved.defaultProvider.value)}`);
+      console.log(`  Default Model: ${chalk2.cyan(resolved.defaultModel.value)}`);
+      console.log(`  Default Strategy: ${chalk2.cyan(resolved.defaultStrategy.value)}`);
+      console.log(`  First-time User: ${chalk2.cyan(config.isFirstTimeUser ? "Yes" : "No")}`);
+      console.log(`  Load Time: ${chalk2.gray(`${config.loadTime}ms`)}`);
+      console.log();
+      const enabledProviders = ProviderRegistry.getEnabledProviders();
+      if (enabledProviders.length > 0) {
+        console.log(chalk2.bold("Provider Configuration:"));
+        for (const provider of enabledProviders) {
+          const model = resolved.providerModels[provider.id]?.value ?? provider.models.default;
+          console.log(`  ${provider.id}: ${chalk2.cyan(String(model))}`);
+        }
+        console.log();
+      }
+      if (options.verbose) {
+        console.log(chalk2.bold("Configuration Sources (by priority):"));
+        for (const source of config.sources.sort((a, b) => b.priority - a.priority)) {
+          const status = source.data ? chalk2.green("OK") : chalk2.red("Error");
+          console.log(`  ${status} ${source.type} (priority: ${source.priority})`);
+          if (source.path) {
+            console.log(`    Path: ${chalk2.gray(source.path)}`);
+          }
+        }
+        console.log();
+      }
+      if (config.config.quality) {
+        console.log(chalk2.bold("Quality Gates:"));
+        const quality = config.config.quality;
+        if (quality.coverage) {
+          console.log(
+            `  ${qualityGateStatus(quality.coverage.enabled)} Coverage: ${chalk2.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(chalk2.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,
+            effectiveModel: config.effectiveModel
+          })
+        );
+        return;
+      }
+      console.log(chalk2.bold.blue("\nConfiguration Values\n"));
+      const configData = config.config;
+      console.log(`Default Provider: ${chalk2.cyan(resolved.defaultProvider.value)}`);
+      console.log(`Effective Model: ${chalk2.cyan(resolved.defaultModel.value)}`);
+      console.log(`Default Strategy: ${chalk2.cyan(resolved.defaultStrategy.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}: ${chalk2.cyan(String(model))}`);
+        }
+      }
+      if (configData.quality) {
+        console.log("\nQuality Gates:");
+        const quality = configData.quality;
+        if (quality.coverage) {
+          console.log(
+            `  ${qualityGateStatus(quality.coverage.enabled)} Coverage: ${chalk2.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 ? chalk2.green("OK") : chalk2.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(chalk2.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(chalk2.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk2.gray('\nTip: Use "poetic config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.loadConfig();
+      const validation = validatePoeticConfig(config.config, {
+        includeWarnings: true,
+        includeSuggestions: true,
+        cwd: process.cwd()
+      });
+      let providerRegistryError;
+      try {
+        ProviderRegistry.reload();
+        ProviderRegistry.load();
+      } catch (error) {
+        providerRegistryError = errorMessage(error);
+      }
+      const jsonPayload = {
+        isValid: validation.isValid && !providerRegistryError,
+        validation,
+        providerRegistryError: providerRegistryError ?? null
+      };
+      if (options.fix && !validation.isValid) {
+        const { autoFixConfig } = await import("./config-validator-KKOHOW7O.js");
+        const fixResult = autoFixConfig(config.config);
+        const saveResult = fixResult.changes.length > 0 ? await configManager.writeProjectConfig(fixResult.fixedConfig) : { success: true, error: void 0 };
+        jsonPayload.fix = {
+          changes: fixResult.changes,
+          remainingErrors: fixResult.remainingErrors,
+          saved: saveResult.success,
+          saveError: saveResult.success ? null : saveResult.error
+        };
+        if (!options.json) {
+          console.log(chalk2.bold.yellow("\nAttempting to auto-fix issues..."));
+          if (fixResult.changes.length > 0) {
+            console.log(chalk2.green("Fixed issues:"));
+            fixResult.changes.forEach((change) => {
+              console.log(`  OK ${change}`);
+            });
+            if (saveResult.success) {
+              console.log(chalk2.green("\nOK: Configuration saved successfully."));
+            } else {
+              console.log(
+                chalk2.red(`
+Error: Failed to save configuration: ${saveResult.error}`)
+              );
+            }
+          }
+          if (fixResult.remainingErrors.length > 0) {
+            console.log(chalk2.yellow("\nRemaining issues that require manual fix:"));
+            fixResult.remainingErrors.forEach((error) => {
+              console.log(
+                `  Warning: ${sanitizeString(error.path.join("."))}: ${sanitizeString(error.message)}`
+              );
+            });
+          }
+        }
+      }
+      if (options.json) {
+        renderJsonResult(jsonPayload);
+        if (!validation.isValid || providerRegistryError) {
+          throw new ExitCodeError(1);
+        }
+        return;
+      }
+      console.log(chalk2.bold.blue("\nConfiguration Validation\n"));
+      const report = generateValidationReport(validation);
+      console.log(report);
+      if (providerRegistryError) {
+        console.log(chalk2.red("\nProvider registry: invalid"));
+        console.log(chalk2.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(chalk2.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(chalk2.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk2.gray('\nTip: Use "poetic config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    try {
+      console.log(chalk2.bold.blue("\nConfiguration Diagnostics\n"));
+      const configManager = new ConfigManager();
+      const diagnostics = await configManager.getDiagnostics();
+      console.log(chalk2.bold("Configuration Paths:"));
+      for (const [name, info] of Object.entries(diagnostics.paths)) {
+        const status = info.exists ? chalk2.green("OK") : chalk2.red("Error");
+        let writable = "";
+        if (info.writable !== void 0) {
+          writable = info.writable ? chalk2.green("(writable)") : chalk2.red("(read-only)");
+        }
+        console.log(
+          `  ${status} ${name}: ${chalk2.gray(info.exists ? "exists" : "missing")} ${writable}`
+        );
+      }
+      console.log();
+      console.log(chalk2.bold("Configuration Cache:"));
+      console.log(`  Enabled: ${chalk2.cyan(diagnostics.cache.enabled ? "Yes" : "No")}`);
+      console.log(`  Size: ${chalk2.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(`    ${chalk2.gray(entry.key)} (${chalk2.cyan(`${entry.age}ms ago`)})`);
+        });
+      }
+      console.log();
+      console.log(chalk2.bold("Configuration Validation:"));
+      if (diagnostics.validation.isValid) {
+        console.log(chalk2.green("  OK Configuration is valid"));
+      } else {
+        console.log(chalk2.red("  Error Configuration has issues"));
+        console.log(`    Errors: ${chalk2.red(diagnostics.validation.errors.length)}`);
+        console.log(`    Warnings: ${chalk2.yellow(diagnostics.validation.warnings.length)}`);
+      }
+      console.log();
+      console.log(chalk2.bold("Performance Metrics:"));
+      console.log(
+        `  Average Load Time: ${chalk2.cyan(`${diagnostics.performance.avgLoadTime}ms`)}`
+      );
+      console.log(`  Cache Hit Rate: ${chalk2.cyan(`${diagnostics.performance.cacheHitRate}%`)}`);
+      console.log();
+      const systemDiagnostics = await getConfigDiagnostics();
+      console.log(chalk2.bold("Source Loading:"));
+      console.log(`  Load Time: ${chalk2.cyan(`${systemDiagnostics.loadTime}ms`)}`);
+      console.log(`  Sources Found: ${chalk2.cyan(systemDiagnostics.summary.loadedSources)}`);
+      console.log(`  Valid Sources: ${chalk2.cyan(systemDiagnostics.summary.validSources)}`);
+      console.log();
+      if (options.fix) {
+        console.log(chalk2.bold.yellow("Attempting to auto-fix configuration issues..."));
+        const configManager2 = new ConfigManager();
+        const config = await configManager2.loadConfig();
+        const { autoFixConfig } = await import("./config-validator-KKOHOW7O.js");
+        const fixResult = autoFixConfig(config.config);
+        if (fixResult.changes.length > 0) {
+          console.log(chalk2.green("Fixed issues:"));
+          fixResult.changes.forEach((change) => {
+            console.log(`  OK ${change}`);
+          });
+          const saveResult = await configManager2.writeProjectConfig(fixResult.fixedConfig);
+          if (saveResult.success) {
+            console.log(chalk2.green("\nOK: Configuration saved successfully."));
+          } else {
+            console.log(chalk2.red(`
+Error: Failed to save configuration: ${saveResult.error}`));
+          }
+        } else {
+          console.log(chalk2.gray("No auto-fixable issues detected."));
+        }
+        if (fixResult.remainingErrors.length > 0) {
+          console.log(chalk2.yellow("\nRemaining issues that require manual fix:"));
+          fixResult.remainingErrors.forEach((error) => {
+            console.log(
+              `  Warning: ${sanitizeString(error.path.join("."))}: ${sanitizeString(error.message)}`
+            );
+          });
+        }
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error)) throw new ExitCodeError(1);
+      console.error(chalk2.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(chalk2.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk2.gray('\nTip: Use "poetic config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    const configManager = new ConfigManager();
+    try {
+      console.log(chalk2.bold.yellow(`
+Resetting configuration (level: ${options.level})
+`));
+      if (options.backup) {
+        const backup = redactConfigValueForDisplay("", await configManager.exportConfig(true));
+        const backupPath = `poetic-config-backup-${Date.now()}.json`;
+        writeFileSync2(backupPath, JSON.stringify(backup, null, 2));
+        console.log(chalk2.green(`OK Backup created: ${backupPath}`));
+      }
+      const result = await configManager.resetToDefaults(
+        options.level
+      );
+      if (result.success) {
+        console.log(chalk2.green("OK: Configuration reset successfully."));
+        console.log(chalk2.gray('\nRun "poetic init" to reconfigure with optimal defaults.'));
+      } else {
+        console.log(chalk2.red(`Error: Failed to reset configuration: ${result.error}`));
+        throw new ExitCodeError(1);
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk2.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", "poetic-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(chalk2.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk2.gray('\nTip: Use "poetic 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)
+      );
+      writeFileSync2(options.output, JSON.stringify(exportData, null, 2));
+      console.log(chalk2.bold.green(`
+OK: Configuration exported to: ${options.output}`));
+      console.log(chalk2.gray(`  Exported at: ${exportData.metadata.exportedAt}`));
+      console.log(chalk2.gray(`  Version: ${exportData.metadata.version}`));
+      if (options.includePreferences) {
+        console.log(chalk2.gray("  User preferences: included"));
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error)) throw new ExitCodeError(1);
+      console.error(chalk2.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(chalk2.red("\nError: Invalid command options:"));
+        console.error(formatValidationErrors(error));
+        console.error(
+          chalk2.gray('\nTip: Use "poetic config <subcommand> --help" for valid options')
+        );
+        throw new ExitCodeError(1);
+      }
+      throw error;
+    }
+    const configManager = new ConfigManager();
+    try {
+      if (!existsSync3(file)) {
+        console.error(chalk2.red(`Configuration file not found: ${file}`));
+        throw new ExitCodeError(1);
+      }
+      const importData = parseJsonWithContext(
+        readFileSync3(file, "utf8"),
+        `Config import (${file})`
+      );
+      const result = await configManager.importConfig(
+        importData,
+        options.importPreferences
+      );
+      if (result.success) {
+        console.log(chalk2.bold.green(`
+OK: Configuration imported from: ${file}`));
+        console.log(chalk2.gray("Configuration has been successfully applied."));
+      } else {
+        console.log(chalk2.red(`Error: Failed to import configuration: ${result.error}`));
+        throw new ExitCodeError(1);
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk2.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(chalk2.bold.blue("\nConfiguration Precedence\n"));
+      console.log(chalk2.gray("Priority (highest to lowest):"));
+      console.log(chalk2.gray("  1. CLI flags (--model, --provider, --strategy, etc.)"));
+      console.log(
+        chalk2.gray(
+          "  2. Environment variables (POETIC_DEFAULT_PROVIDER, POETIC_<PROVIDER>_DEFAULT_MODEL, etc.)"
+        )
+      );
+      console.log(chalk2.gray("  3. Active profile (~/.config/poetic/profiles/<name>.json)"));
+      console.log(chalk2.gray("  4. Project config (.poetic/config/poetic.config.jsonc)"));
+      console.log(chalk2.gray("  5. User config (~/.config/poetic/poetic.config.jsonc)"));
+      console.log(chalk2.gray("  6. Registry defaults (.poetic/config/providers.yaml)"));
+      console.log(chalk2.gray("  7. Hardcoded fallback"));
+      console.log();
+      console.log(chalk2.bold("Current Source Values:"));
+      for (const source of config.sources.sort((a, b) => b.priority - a.priority)) {
+        if (source.data && source.type !== "default") {
+          console.log(chalk2.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, providerConfig] of Object.entries(configData.providers ?? {})) {
+            if (providerConfig && "model" in providerConfig && providerConfig.model) {
+              console.log(`  ${provider} Model: ${String(providerConfig.model)}`);
+            }
+          }
+          console.log();
+        }
+      }
+      console.log(chalk2.bold("Final Resolved Configuration:"));
+      console.log(`  Default Provider: ${chalk2.cyan(resolved.defaultProvider.value)}`);
+      console.log(`  Effective Model: ${chalk2.cyan(resolved.defaultModel.value)}`);
+      console.log(`  Default Strategy: ${chalk2.cyan(resolved.defaultStrategy.value)}`);
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error)) throw new ExitCodeError(1);
+      console.error(chalk2.red("Error showing precedence:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  const aliasesCommand = new Command2("aliases").description(
+    'Manage user model aliases (stored in user config)\n\nExamples:\n  poetic config aliases list\n  poetic config aliases list --provider opencode\n  poetic 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 = {};
+      for (const [providerId, providerConfig] of Object.entries(providers ?? {})) {
+        if (options.provider && providerId.toLowerCase() !== String(options.provider).toLowerCase())
+          continue;
+        if (!providerConfig || typeof providerConfig !== "object") continue;
+        const aliases = providerConfig.aliases;
+        const models = aliases && typeof aliases === "object" ? aliases.models : null;
+        if (!models || typeof models !== "object") continue;
+        const record = {};
+        for (const [k, v] of Object.entries(models)) {
+          if (typeof k !== "string" || typeof v !== "string") continue;
+          record[k] = v;
+        }
+        if (Object.keys(record).length > 0) out[providerId] = record;
+      }
+      if (options.json) {
+        console.log(JSON.stringify(out, null, 2));
+        return;
+      }
+      const providersWithAliases = Object.keys(out);
+      if (providersWithAliases.length === 0) {
+        console.log(chalk2.yellow("No user model aliases found."));
+        console.log(
+          chalk2.gray(
+            'Tip: Use "poetic provider alias set <provider> <alias> <model>" or "poetic config set --scope user providers.<provider>.aliases.models.<alias> <model>".'
+          )
+        );
+        return;
+      }
+      for (const providerId of providersWithAliases.sort()) {
+        console.log(chalk2.bold(`${providerId}:`));
+        const models = out[providerId] ?? {};
+        for (const [aliasKey, modelId] of Object.entries(models).sort(
+          ([a], [b]) => a.localeCompare(b)
+        )) {
+          console.log(`  ${chalk2.cyan(aliasKey)} -> ${chalk2.gray(modelId)}`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk2.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) => {
+    try {
+      if (options.role && (options.summary || options.compete || options.optimization)) {
+        writeConfigError(
+          chalk2.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-O6WKR47U.js");
+        const resolved2 = await resolveOptimizationConfig(process.cwd());
+        const summary = summarizeOptimizationConfig(resolved2);
+        if (options.json) {
+          console.log(JSON.stringify(redactConfigValueForDisplay("", summary), null, 2));
+          return;
+        }
+        console.log(chalk2.bold.blue("\nOptimization recipes (resolved):\n"));
+        console.log(`  Source:       ${chalk2.cyan(summary.source)}`);
+        console.log(
+          `  Available:    ${chalk2.cyan(summary.availableProviders.join(", ") || "(none)")}`
+        );
+        if (summary.unavailableProviders.length > 0) {
+          console.log(`  Unavailable:  ${chalk2.gray(summary.unavailableProviders.join(", "))}`);
+        }
+        const recipes = summary.recipes.optimization;
+        if (recipes) {
+          const speedProviders = recipes.speed?.providerPreference?.join(", ") ?? "(default)";
+          const costProviders = recipes.cost?.providerPreference?.join(", ") ?? "(default)";
+          const qualityVariants = recipes.quality?.variants?.map(
+            (variant) => `${variant.provider}:${variant.model ?? variant.modelRole ?? "default"}:${variant.strategy}:${variant.mode ?? "local"}`
+          ).join(", ") ?? "(default)";
+          console.log();
+          console.log(`  speed:        ${chalk2.cyan(speedProviders)}`);
+          console.log(`  quality:      ${chalk2.cyan(qualityVariants)}`);
+          console.log(`  cost:         ${chalk2.cyan(costProviders)}`);
+          console.log(
+            `  autoloop:     ${chalk2.cyan(recipes.autoloop?.semanticVerifierProviderPreference?.join(", ") ?? "(default)")}`
+          );
+        }
+        console.log();
+        console.log(
+          chalk2.gray(
+            "Note: optimization.* applies to poetic fast/best/cheap and poetic run --optimize. Bare poetic compete keeps its compete resolver defaults; sprint/flywheel execution keeps DomainAnalyzer/RoutingPlanner routing."
+          )
+        );
+        console.log();
+        return;
+      }
+      if (options.compete) {
+        const competeResolved = await resolveCompeteConfig({}, { projectRoot: process.cwd() });
+        if (options.json) {
+          console.log(JSON.stringify(redactConfigValueForDisplay("", competeResolved), null, 2));
+          return;
+        }
+        console.log(chalk2.bold.blue("\nCompete defaults (resolved):\n"));
+        const pad = (s, n) => s.padEnd(n);
+        const w = 20;
+        const fmtSrc = (src) => chalk2.gray(`[${src}]`);
+        console.log(
+          `  ${pad("variants:", w)} ${chalk2.cyan(competeResolved.variants.join(", ") || "(auto-discovered)")}  ${fmtSrc(competeResolved.sources.variants)}`
+        );
+        console.log(
+          `  ${pad("judge:", w)} ${chalk2.cyan(competeResolved.judge)}  ${fmtSrc(competeResolved.sources.judge)}`
+        );
+        if (competeResolved.judgeRun) {
+          console.log(
+            `  ${pad("judgeRun:", w)} ${chalk2.cyan(competeResolved.judgeRun)}  ${fmtSrc(competeResolved.sources.judgeRun ?? competeResolved.sources.judge)}`
+          );
+        }
+        if (competeResolved.judgePrimary) {
+          console.log(
+            `  ${pad("judgePrimary:", w)} ${chalk2.cyan(competeResolved.judgePrimary)}  ${fmtSrc(competeResolved.sources.judgePrimary ?? competeResolved.sources.judge)}`
+          );
+        }
+        console.log(
+          `  ${pad("completionMode:", w)} ${chalk2.cyan(competeResolved.completionMode)}  ${fmtSrc(competeResolved.sources.completionMode)}`
+        );
+        console.log(
+          `  ${pad("timeout:", w)} ${chalk2.cyan(`${competeResolved.timeout}m`)}  ${fmtSrc(competeResolved.sources.timeout)}`
+        );
+        console.log(
+          `  ${pad("requireMinVariants:", w)} ${chalk2.cyan(String(competeResolved.requireMinVariants))}  ${fmtSrc(competeResolved.sources.requireMinVariants)}`
+        );
+        console.log(
+          `  ${pad("matrixEscalation:", w)} ${chalk2.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.POETIC_COMPLETION_MODE?.trim()) {
+          envOverrides.push(
+            `  POETIC_COMPLETION_MODE=${process.env.POETIC_COMPLETION_MODE}  \u2192 completionMode: ${competeResolved.completionMode}`
+          );
+        }
+        const activeJudgeEnv = readJudgeTypeEnv();
+        if (activeJudgeEnv?.trim()) {
+          const legacyActive = process.env.POETIC_JUDGE_TYPE === void 0 && process.env.POETIC_JUDGE !== void 0;
+          const label = legacyActive ? "POETIC_JUDGE (deprecated alias for POETIC_JUDGE_TYPE)" : "POETIC_JUDGE_TYPE";
+          envOverrides.push(`  ${label}=${activeJudgeEnv}  \u2192 judge: ${competeResolved.judge}`);
+        }
+        if (process.env.POETIC_TIMEOUT_MS?.trim()) {
+          const ms = parseInt(process.env.POETIC_TIMEOUT_MS, 10);
+          if (!Number.isNaN(ms)) {
+            envOverrides.push(
+              `  POETIC_TIMEOUT_MS=${process.env.POETIC_TIMEOUT_MS}  \u2192 timeout: ${Math.ceil(ms / 6e4)}m`
+            );
+          }
+        }
+        if (process.env.POETIC_JUDGE_RUN?.trim() || process.env.POETIC_AI_JUDGE_RUN?.trim()) {
+          const key = process.env.POETIC_JUDGE_RUN?.trim() ? "POETIC_JUDGE_RUN" : "POETIC_AI_JUDGE_RUN";
+          envOverrides.push(
+            `  ${key}=${process.env[key]}  \u2192 judgeRun: ${competeResolved.judgeRun ?? "ai"}`
+          );
+        }
+        if (process.env.POETIC_JUDGE_PRIMARY?.trim() || process.env.POETIC_AI_JUDGE_PRIMARY?.trim()) {
+          const key = process.env.POETIC_JUDGE_PRIMARY?.trim() ? "POETIC_JUDGE_PRIMARY" : "POETIC_AI_JUDGE_PRIMARY";
+          envOverrides.push(
+            `  ${key}=${process.env[key]}  \u2192 judgePrimary: ${competeResolved.judgePrimary ?? "ai"}`
+          );
+        }
+        const hasMatrixEscalationEnvOverride = readEnv(POETIC_MATRIX_CLOSE_CALL_MARGIN).source === "env" || readEnv(POETIC_MATRIX_BORDERLINE_MARGIN).source === "env" || readEnv(POETIC_MATRIX_CONFIDENCE_THRESHOLD).source === "env";
+        if (hasMatrixEscalationEnvOverride) {
+          envOverrides.push(
+            `  POETIC_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 POETIC_* overrides:");
+          for (const line of envOverrides) {
+            console.log(chalk2.yellow(line));
+          }
+        }
+        console.log();
+        return;
+      }
+      const resolved = resolveConfig(void 0, process.cwd(), { strictSynthesisModel: false });
+      if (options.summary && (options.provider || options.role)) {
+        console.error(chalk2.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 summary = {
+          provider: resolved.defaultProvider.value,
+          model: resolved.defaultModel.value,
+          strategy: resolved.defaultStrategy.value,
+          routingPolicy: resolved.decompositionRoutingPolicy.value,
+          blockerMode: resolved.planExecute.blockerMode.value,
+          transport: resolved.providerExecutionTransport.current.value,
+          judge: {
+            type: resolved.judge.type.value,
+            model: resolved.judge.model.value
+          },
+          availableProviders: enabledProviders
+        };
+        if (options.json) {
+          console.log(JSON.stringify(redactSensitiveConfig(summary), null, 2));
+        } else {
+          console.log(chalk2.bold.blue("\nResolved Config Summary\n"));
+          console.log(formatResolvedConfigSummaryLine(summary));
+          console.log();
+          console.log(`  Provider:  ${chalk2.cyan(summary.provider)}`);
+          console.log(`  Model:     ${chalk2.cyan(summary.model)}`);
+          console.log(`  Strategy:  ${chalk2.cyan(summary.strategy)}`);
+          console.log(`  Routing:   ${chalk2.cyan(summary.routingPolicy)}`);
+          console.log(`  Blockers:  ${chalk2.cyan(summary.blockerMode)}`);
+          console.log(`  Transport: ${chalk2.cyan(summary.transport)}`);
+          console.log(
+            `  Judge:     ${chalk2.cyan(`${summary.judge.type} (${summary.judge.model})`)}`
+          );
+          console.log(`  Available: ${chalk2.cyan(summary.availableProviders.join(", "))}`);
+          console.log();
+        }
+        return;
+      }
+      if (options.role) {
+        if (options.role !== "executor") {
+          writeConfigError(chalk2.red(`Error: Unsupported role: ${options.role}`));
+          throw new ExitCodeError(1);
+        }
+        if (!options.provider) {
+          writeConfigError(chalk2.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(chalk2.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)}`);
+        }
+        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(chalk2.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() });
+      if (options.json) {
+        const executionPreview2 = await buildExecutionPreview(resolved);
+        console.log(
+          JSON.stringify(
+            redactConfigValueForDisplay("", { ...resolved, roles, executionPreview: executionPreview2 }),
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log(chalk2.bold.blue("\nResolved Configuration\n"));
+      console.log(getConfigSummary());
+      const executionPreview = await buildExecutionPreview(resolved);
+      console.log(chalk2.bold.blue("Execution Preview\n"));
+      console.log(`  run.provider:   ${chalk2.cyan(executionPreview.run.provider)}`);
+      console.log(`  run.model:      ${chalk2.cyan(executionPreview.run.model)}`);
+      console.log(`  run.strategy:   ${chalk2.cyan(executionPreview.run.strategy)}`);
+      console.log(`  run.transport:  ${chalk2.cyan(executionPreview.run.transport)}`);
+      console.log(
+        `  run.judge:      ${chalk2.cyan(`${executionPreview.run.judge.type}; ${executionPreview.run.judge.provider}; ${executionPreview.run.judge.model}`)}`
+      );
+      if ("error" in executionPreview.compete) {
+        console.log(`  compete:        ${chalk2.yellow(executionPreview.compete.error)}`);
+      } else {
+        const compete = executionPreview.compete;
+        console.log(
+          `  compete.variants: ${chalk2.cyan(compete.variants.join(", "))} ${chalk2.gray(`[${compete.sources.variants}]`)}`
+        );
+        console.log(
+          `  compete.judge:    ${chalk2.cyan(compete.judge)} ${chalk2.gray(`[${compete.sources.judge}]`)}`
+        );
+        if (compete.judgeRun) {
+          console.log(
+            `  compete.judgeRun: ${chalk2.cyan(compete.judgeRun)} ${chalk2.gray(`[${compete.sources.judgeRun ?? compete.sources.judge}]`)}`
+          );
+        }
+      }
+      console.log(
+        `  env.overrides:  ${chalk2.cyan(executionPreview.envOverrides.length > 0 ? executionPreview.envOverrides.join(", ") : "none")}`
+      );
+      printResolvedRoles(roles);
+      console.log();
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error, Boolean(options.json))) throw new ExitCodeError(1);
+      console.error(chalk2.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 (path2, value, options) => {
+    try {
+      const scope = options.scope;
+      if (scope !== "user" && scope !== "project") {
+        console.error(chalk2.red(`Invalid scope: ${scope}. Use 'user' or 'project'.`));
+        throw new ExitCodeError(1);
+      }
+      const configManager = new ConfigManager();
+      const result = await configManager.setConfigValue(path2, value, scope);
+      if (result.success) {
+        console.log(
+          chalk2.green(`OK: Set ${path2} = ${formatConfigSetValueForDisplay(path2, value)}`)
+        );
+        console.log(chalk2.gray(`  Scope: ${scope}`));
+        if (result.previousValue !== void 0) {
+          console.log(
+            chalk2.gray(
+              `  Previous: ${formatConfigSetValueForDisplay(path2, result.previousValue)}`
+            )
+          );
+        }
+      } else {
+        console.error(chalk2.red(`Error: Failed to set configuration: ${result.error}`));
+        throw new ExitCodeError(1);
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk2.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 (path2, options) => {
+    try {
+      const scope = options.scope;
+      if (scope !== "user" && scope !== "project") {
+        console.error(chalk2.red(`Invalid scope: ${scope}. Use 'user' or 'project'.`));
+        throw new ExitCodeError(1);
+      }
+      const configManager = new ConfigManager();
+      const value = await configManager.getConfigValue(path2, scope);
+      if (options.json) {
+        console.log(JSON.stringify(buildConfigGetJsonPayload(path2, scope, value), null, 2));
+      } else if (value === void 0) {
+        await printConfigScopeMiss(
+          path2,
+          scope,
+          (configPath, configScope) => configManager.getConfigValue(configPath, configScope)
+        );
+      } else {
+        console.log(chalk2.cyan(`${path2}`), "=", formatConfigGetValueForDisplay(path2, value));
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      if (renderConfigReadFailure(error, Boolean(options.json))) throw new ExitCodeError(1);
+      console.error(chalk2.red("Error getting configuration:"), errorMessage(error));
+      throw new ExitCodeError(1);
+    }
+  });
+  const userCommand = new Command2("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 (path2, value) => {
+    try {
+      const configManager = new ConfigManager();
+      const result = await configManager.setConfigValue(path2, value, "user");
+      if (result.success) {
+        console.log(
+          chalk2.green(`OK: Set ${path2} = ${formatConfigSetValueForDisplay(path2, value)}`)
+        );
+        console.log(chalk2.gray("  Scope: user"));
+        if (result.previousValue !== void 0) {
+          console.log(
+            chalk2.gray(
+              `  Previous: ${formatConfigSetValueForDisplay(path2, result.previousValue)}`
+            )
+          );
+        }
+        return;
+      }
+      console.error(chalk2.red(`Error: Failed to set configuration: ${result.error}`));
+      throw new ExitCodeError(1);
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk2.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 (path2, options) => {
+    try {
+      const configManager = new ConfigManager();
+      const value = await configManager.getConfigValue(path2, "user");
+      if (options.json) {
+        console.log(JSON.stringify(buildConfigGetJsonPayload(path2, "user", value), null, 2));
+      } else if (value === void 0) {
+        await printConfigScopeMiss(
+          path2,
+          "user",
+          (configPath, configScope) => configManager.getConfigValue(configPath, configScope)
+        );
+      } else {
+        console.log(chalk2.cyan(`${path2}`), "=", formatConfigGetValueForDisplay(path2, value));
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk2.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: existsSync4, readdirSync, unlinkSync, statSync: statSync2 } = await import("fs");
+      const { join: join2 } = await import("path");
+      console.log(chalk2.bold.blue("\nConfiguration Cleanup\n"));
+      if (options.backups) {
+        const configDir = getConfigPaths(process.cwd()).projectConfigDir;
+        if (!existsSync4(configDir)) {
+          console.log(chalk2.yellow("No .poetic/config directory found."));
+          return;
+        }
+        const files = readdirSync(configDir);
+        const backupFiles = files.filter((f) => f.startsWith("poetic.config.backup.")).map((f) => ({
+          name: f,
+          path: join2(configDir, f),
+          mtime: statSync2(join2(configDir, f)).mtime.getTime()
+        })).sort((a, b) => b.mtime - a.mtime);
+        if (backupFiles.length === 0) {
+          console.log(chalk2.green("No backup files found."));
+          return;
+        }
+        const toDelete = backupFiles.slice(3);
+        const toKeep = backupFiles.slice(0, 3);
+        console.log(chalk2.gray(`Found ${backupFiles.length} backup files.`));
+        console.log(chalk2.green(`Keeping ${toKeep.length} most recent:`));
+        for (const f of toKeep) {
+          console.log(chalk2.gray(`  OK ${f.name}`));
+        }
+        if (toDelete.length === 0) {
+          console.log(chalk2.green("\nNo files to delete."));
+          return;
+        }
+        console.log(chalk2.yellow(`
+Deleting ${toDelete.length} old backups:`));
+        for (const f of toDelete) {
+          console.log(chalk2.gray(`  Error ${f.name}`));
+          if (!options.dryRun) {
+            unlinkSync(f.path);
+          }
+        }
+        if (options.dryRun) {
+          console.log(chalk2.yellow("\n(Dry run - no files were actually deleted)"));
+        } else {
+          console.log(chalk2.green(`
+OK: Deleted ${toDelete.length} backup files.`));
+        }
+      } else {
+        console.log(chalk2.gray("Use --backups to remove old backup files."));
+        console.log(chalk2.gray("Example: poetic config cleanup --backups"));
+      }
+    } catch (error) {
+      if (error instanceof ExitCodeError) throw error;
+      console.error(chalk2.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-TNILDEVJ.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(chalk2.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-EL3GHXS7.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);
+    }
+  });
+  configCommand.addCommand(createConfigMigrateCommand());
+  return configCommand;
+}
+
+export {
+  redactConfigValueForDisplay,
+  formatConfigGetValueForDisplay,
+  formatConfigSetValueForDisplay,
+  buildConfigGetJsonPayload,
+  buildConfigScopeMissLines,
+  createConfigCommand
+};
+//# sourceMappingURL=chunk-2N42MS2Z.js.map