@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-FKCG7K6H.js

@@ -0,0 +1,1146 @@
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  MAX_CONCURRENT_DEFAULT
+} from "./chunk-U4DRS6ZW.js";
+
+// src/core/config/schemas/config-schemas.ts
+import { hostname } from "os";
+import { z } from "zod";
+var ConfigNumberSchema = z.preprocess((value) => {
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? value : parsed;
+  }
+  return value;
+}, z.number());
+var ConfigBooleanSchema = z.preprocess((value) => {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true") return true;
+    if (normalized === "false") return false;
+  }
+  return value;
+}, z.boolean());
+function normalizeJudgeType(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : value;
+}
+var JudgeTypeSchema = z.preprocess(normalizeJudgeType, z.enum(["ai", "multi-lens"]));
+var ModelChangeContextTypeSchema = z.enum(["cli_flag", "config_edit", "first_time"]);
+var ModelFamilySchema = z.enum(["sonnet", "gpt", "glm", "kimi"]);
+var ModelRoutingRouteSchema = z.object({
+  /**
+   * Execution provider (tool/facade) Build will run (e.g. codex/claude/cursor/copilot/opencode).
+   * Note: This is NOT the upstream provider/host.
+   */
+  engine: z.string(),
+  /** Upstream provider/host label for display/debugging (OpenAI/Anthropic/Z.ai/Moonshot/...) */
+  upstream: z.string().optional(),
+  /**
+   * Model template or literal model ID to pass to the execution provider.
+   *
+   * Supported placeholders:
+   * - {{latest}}: resolved best-available model for this engine+family request (deterministic, local)
+   * - {{family}}: model family (sonnet/gpt/glm/kimi)
+   * - {{version}}: resolved family version (e.g. "4.5", "5.2")
+   * - {{version_dash}}: resolved family version with '.' replaced by '-' (e.g. "4-5", "5-2")
+   */
+  modelTemplate: z.string().optional()
+}).strict();
+var ModelRoutingFailoverSchema = z.object({
+  enabled: z.boolean().optional(),
+  maxAttempts: z.number().int().min(1).max(10).optional()
+}).optional();
+var ModelRoutingPreferencesSchema = z.object({
+  /** Retired, still read this release (retired-config-keys.ts): ordered routes per family */
+  routes: z.record(ModelFamilySchema, z.array(ModelRoutingRouteSchema)).optional(),
+  failover: ModelRoutingFailoverSchema
+  // retired, still read: use execution.failover
+}).optional();
+var CursorConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional(),
+  preferences: z.object({
+    firstSeen: z.iso.datetime().optional(),
+    lastModelChange: z.iso.datetime().optional(),
+    userChosenDefault: z.string().optional(),
+    usageCount: z.number().optional(),
+    version: z.string().optional()
+  }).optional()
+}).strict();
+var ClaudeConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).strict();
+var CodexConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).strict();
+var CopilotConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  organization: z.string().optional(),
+  seat: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).strict();
+var GeminiConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).loose();
+var OpencodeConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).loose();
+var GrokConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).loose();
+var OpenrouterConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).loose();
+var KiroConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).loose();
+var AntigravityConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).loose();
+var PiConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  model: z.string().optional(),
+  aliases: z.object({
+    models: z.record(z.string(), z.string()).optional()
+  }).optional()
+}).loose();
+var ProvidersConfigSchema = z.object({
+  claude: ClaudeConfigSchema.optional(),
+  codex: CodexConfigSchema.optional(),
+  cursor: CursorConfigSchema.optional(),
+  copilot: CopilotConfigSchema.optional(),
+  gemini: GeminiConfigSchema.optional(),
+  opencode: OpencodeConfigSchema.optional(),
+  grok: GrokConfigSchema.optional(),
+  openrouter: OpenrouterConfigSchema.optional(),
+  kiro: KiroConfigSchema.optional(),
+  antigravity: AntigravityConfigSchema.optional(),
+  pi: PiConfigSchema.optional()
+}).strict();
+var QualityConfigSchema = z.object({
+  // Legacy project config key accepted for backwards-compatible `build config set`.
+  enforce: ConfigBooleanSchema.optional(),
+  coverage: z.object({
+    enabled: ConfigBooleanSchema,
+    threshold: ConfigNumberSchema
+  }).optional(),
+  lint: z.object({
+    enabled: ConfigBooleanSchema
+  }).optional(),
+  security: z.object({
+    enabled: ConfigBooleanSchema
+  }).optional()
+}).strict();
+var LEGACY_REPO_LOCAL_TELEMETRY_DATABASE = ".build-project/telemetry/db/variants.db";
+var TelemetryConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  /**
+   * DEPRECATED override. Set only to relocate telemetry outside the repository.
+   *
+   * Telemetry is written under the Build data root; there is no default value.
+   * A value equal to the historical repo-local default
+   * (`.build-project/telemetry/db/variants.db`) is ignored, and any other value is
+   * honored with a one-time deprecation warning.
+   */
+  database: z.string().optional(),
+  ephemeralReplication: z.boolean().optional(),
+  retention: z.object({
+    backups_days: z.number().positive().optional(),
+    backups_monthly_count: z.number().nonnegative().optional(),
+    backups_max_bytes: z.number().nonnegative().optional(),
+    logs_days: z.number().positive().optional(),
+    vacuum_on_cleanup: z.boolean().optional()
+  }).strict().optional()
+}).strict();
+var VariantsConfigSchema = z.object({
+  /**
+   * Removed by ADR-025 (variant strategy axis). Accepted for one release so an
+   * existing consumer config still loads; the value is ignored by resolution
+   * and reported once by the config validator.
+   */
+  strategies: z.record(
+    z.string(),
+    z.object({
+      weight: z.number()
+    })
+  ).optional(),
+  maxConcurrent: z.number().optional()
+}).strict();
+var ComplexityNumberSchema = z.union([
+  z.number(),
+  z.object({
+    low: z.number(),
+    medium: z.number(),
+    high: z.number()
+  })
+]);
+var ReasoningEffortSchema = z.preprocess(
+  (value) => {
+    if (value === void 0 || value === null) return void 0;
+    const normalized = normalizeReasoningEffortInput(value);
+    return normalized ?? value;
+  },
+  z.enum(["low", "medium", "high", "xhigh", "max"])
+);
+var OptimizationVariantRecipeSchema = z.object({
+  provider: z.string().trim().min(1),
+  model: z.string().trim().min(1).optional(),
+  modelRole: z.string().trim().min(1).optional(),
+  fallbackModelRole: z.string().trim().min(1).optional(),
+  // Retired: still read this release.
+  reasoningEffort: ReasoningEffortSchema.optional(),
+  /** Removed by ADR-025; accepted for one release and ignored. */
+  strategy: z.string().trim().min(1).optional(),
+  mode: z.enum(["local", "cloud"]).optional()
+}).strict().superRefine((recipe, ctx) => {
+  if (recipe.mode === "cloud") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["mode"],
+      message: 'Cloud execution is not supported; use mode "local"'
+    });
+  }
+});
+var OptimizationModeRecipeSchema = z.object({
+  /** Retired: speed/cost still read it this release; quality ignores it. */
+  providerPreference: z.array(z.string().trim().min(1)).optional(),
+  modelRole: z.string().trim().min(1).optional(),
+  fallbackModelRole: z.string().trim().min(1).optional(),
+  // Retired: speed/cost still read it; quality ignores it.
+  reasoningEffort: ReasoningEffortSchema.optional(),
+  variants: z.array(OptimizationVariantRecipeSchema).optional(),
+  parallel: ComplexityNumberSchema.optional(),
+  maxConcurrent: ComplexityNumberSchema.optional(),
+  earlyExit: z.boolean().optional(),
+  streamResults: z.boolean().optional(),
+  compete: z.boolean().optional(),
+  aiJudge: z.boolean().optional(),
+  synthesize: z.boolean().optional(),
+  autoloop: z.boolean().optional(),
+  autoloopMaxIterations: ComplexityNumberSchema.optional(),
+  autoloopTimeboxMinutes: ComplexityNumberSchema.optional(),
+  autoloopMinProgress: z.number().min(0).max(1).optional(),
+  autoloopJudge: z.boolean().optional(),
+  autoloopQualityGates: z.boolean().optional(),
+  // Phase B schema catch-up: runtime/flag concepts that already exist
+  // (`--autoloop-completion-promise`, `--autoloop-completion-signal`,
+  // `--autoloop-validation`) but were not previously schema-covered.
+  autoloopCompletionPromise: z.string().optional(),
+  autoloopCompletionSignal: z.string().optional(),
+  autoloopValidationMode: z.enum(["heuristic", "none", "deterministic"]).optional()
+}).strict();
+var OptimizationAutoloopRecipeSchema = z.object({
+  // Retired semanticVerifier* keys: still read this release (retired-config-keys.ts).
+  semanticVerifierProviderPreference: z.array(z.string().trim().min(1)).optional(),
+  semanticVerifierProvider: z.string().trim().min(1).optional(),
+  semanticVerifierModel: z.string().trim().min(1).optional(),
+  semanticVerifierModelRole: z.string().trim().min(1).optional(),
+  fallbackModelRole: z.string().trim().min(1).optional()
+  // Retired: still read this release.
+}).strict();
+var OptimizationConfigSchema = z.object({
+  reasoningEffortByRole: z.record(z.string().trim().min(1), ReasoningEffortSchema).optional(),
+  speed: OptimizationModeRecipeSchema.optional(),
+  quality: OptimizationModeRecipeSchema.optional(),
+  cost: OptimizationModeRecipeSchema.optional(),
+  autoloop: OptimizationAutoloopRecipeSchema.optional()
+}).strict();
+var ExecutionContractRefSchema = z.object({
+  id: z.string().trim().min(1),
+  version: z.string().trim().min(1).optional()
+}).strict();
+var PlanExecuteBlockerModeSchema = z.enum(["non-interactive", "interactive"]);
+var CompeteConfigSchema = z.record(z.string(), z.unknown()).optional();
+var PlanExecuteConfigSchema = z.object({
+  blockerMode: PlanExecuteBlockerModeSchema.optional()
+}).strict();
+var WorktreeConfigSchema = z.object({
+  poolSize: z.number().optional(),
+  maxConcurrent: z.number().optional(),
+  cleanupInterval: z.number().optional(),
+  healthCheckInterval: z.number().optional(),
+  /**
+   * Repo-root-relative gitignored env files (for example `.env`) to copy into
+   * variant, synthesis and baseline worktrees. Off when unset. Project config
+   * is honored only for a trusted project root (secrets boundary).
+   */
+  copyEnvFiles: z.array(z.string()).optional()
+}).strict();
+var FuzzyFileMatchingSchema = z.object({
+  enabled: z.boolean().optional(),
+  basenameMatch: z.boolean().optional(),
+  normalizedPath: z.boolean().optional(),
+  caseInsensitive: z.boolean().optional()
+}).strict();
+var DefaultsConfigSchema = z.object({
+  provider: z.string().optional(),
+  /** Removed by ADR-025; accepted for one release and ignored. */
+  strategy: z.string().optional(),
+  model: z.string().optional(),
+  /** Removed; accepted for one release and ignored. */
+  routingPolicy: z.enum(["strict", "reroute"]).optional(),
+  providerOrder: z.array(z.string()).optional(),
+  synthesis: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    reasoningEffort: ReasoningEffortSchema.optional(),
+    /** Compare a validated synthesis with the judged winner before shipping it (default true). */
+    headToHead: z.boolean().optional(),
+    /** Retired: still read this release; use defaults.providerOrder. */
+    providerOrder: z.array(z.string()).optional()
+  }).optional(),
+  splitter: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    reasoningEffort: ReasoningEffortSchema.optional()
+  }).optional(),
+  intent: z.object({
+    decompositionHints: z.array(z.string()).optional(),
+    nonGoals: z.array(z.string()).optional(),
+    disableRepoContext: z.boolean().optional(),
+    decomposition: z.object({
+      /** Retired: still read this release; use defaults.providerOrder. */
+      providerOrder: z.array(z.string()).optional(),
+      /** Removed; accepted for one release and ignored. */
+      routingPolicy: z.enum(["strict", "reroute"]).optional(),
+      /** Never supported; accepted for one release and ignored. */
+      model: z.unknown().optional()
+    }).optional()
+  }).optional(),
+  judge: z.object({
+    type: JudgeTypeSchema.optional(),
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    reasoningEffort: ReasoningEffortSchema.optional(),
+    /** Removed; accepted for one release and ignored. */
+    providerOrder: z.array(z.string()).optional()
+  }).optional(),
+  providers: z.record(
+    z.string(),
+    z.object({
+      model: z.string().optional(),
+      /** Overrides the providers.yaml fast slot for anything that wants a fast model. */
+      fastModel: z.string().optional(),
+      reasoningEffort: ReasoningEffortSchema.optional(),
+      /** Removed by ADR-025; accepted for one release and ignored. */
+      strategy: z.string().optional(),
+      modelOrder: z.array(z.string()).optional()
+      // Retired: still read; set `model` instead.
+    })
+  ).optional()
+}).strict();
+var AutomationConfigSchema = z.object({
+  flywheel: z.object({
+    merge: z.object({
+      biomeRepair: z.boolean().optional()
+    }).optional()
+  }).optional()
+}).strict();
+var SyncConfigSchema = z.object({
+  routeMain: z.boolean().optional(),
+  autoPublish: z.boolean().optional(),
+  protectMain: z.enum(["off", "warn", "confirm", "block"]).optional(),
+  checkoutMain: z.boolean().optional()
+}).strict();
+var JudgeConfigSchema = z.object({
+  /** Custom prompt template for AI Judge evaluation */
+  prompt: z.string().optional(),
+  /** Provider to use for AI Judge (defaults to claude) */
+  provider: z.string().optional(),
+  /** Model to use for AI Judge (defaults to resolved from config) */
+  model: z.string().optional(),
+  /** Reasoning effort applied to judge calls when the tier does not override it. */
+  reasoningEffort: ReasoningEffortSchema.optional(),
+  /**
+   * Thinking budget token hint for judge execution (provider-specific).
+   *
+   * For Claude CLI, Build uses env-based toggles (e.g. MAX_THINKING_TOKENS / ANTHROPIC_MAX_THINKING_TOKENS).
+   */
+  thinkingBudgetTokens: z.number().int().min(0).optional(),
+  /**
+   * When true, Build will fail the judge call if thinking cannot be verified.
+   * Intended for "always thinking" enforcement in judge evaluation.
+   */
+  requireThinking: z.boolean().optional(),
+  /**
+   * Per-judge overrides. These take precedence over the top-level judge.* fields.
+   */
+  ai: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    reasoningEffort: ReasoningEffortSchema.optional(),
+    thinkingBudgetTokens: z.number().int().min(0).optional(),
+    requireThinking: z.boolean().optional()
+  }).optional(),
+  multiLens: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    reasoningEffort: ReasoningEffortSchema.optional(),
+    thinkingBudgetTokens: z.number().int().min(0).optional(),
+    requireThinking: z.boolean().optional()
+  }).optional(),
+  matrixEscalation: z.object({
+    closeCallMargin: z.number().min(0).optional(),
+    borderlineMargin: z.number().min(0).optional(),
+    confidenceThreshold: z.number().min(0).max(1).optional()
+  }).optional(),
+  /**
+   * Retired: the multi-agent judge tier. Accepted so existing configs still load;
+   * nothing reads it.
+   */
+  multiAgent: z.unknown().optional().describe("Retired. Accepted and ignored.")
+}).strict();
+var ProviderTempCleanupConfigSchema = z.object({
+  roots: z.array(z.string()).optional(),
+  maxAgeHours: z.number().min(1).optional()
+}).strict();
+var PruneRetentionConfigSchema = z.object({
+  ttls: z.record(z.string(), z.number().int().min(1)).optional()
+}).strict();
+var BranchCleanupConfigSchema = z.object({
+  automatic: z.boolean().optional(),
+  idleDays: z.number().int().min(1).optional(),
+  holdDays: z.number().int().min(1).optional()
+}).strict();
+var CleanupConfigSchema = z.object({
+  providerTemp: ProviderTempCleanupConfigSchema.optional(),
+  prune: PruneRetentionConfigSchema.optional(),
+  branches: BranchCleanupConfigSchema.optional()
+}).strict();
+var ExecutionTransportModeSchema = z.enum([
+  "auto",
+  "headless",
+  "tmux-exec",
+  "interactive"
+]);
+var ExecutionTransportConfigSchema = z.object({
+  default: ExecutionTransportModeSchema.optional(),
+  providers: z.record(z.string(), ExecutionTransportModeSchema).optional()
+}).strict();
+var ExecutionConfigSchema = z.object({
+  // Legacy project config key accepted for backwards-compatible `build config set`.
+  timeout: ConfigNumberSchema.optional(),
+  defaultTimeout: ConfigNumberSchema.optional(),
+  concurrencyMultiplier: ConfigNumberSchema.optional(),
+  transport: ExecutionTransportConfigSchema.optional(),
+  fuzzyFileMatching: FuzzyFileMatchingSchema.optional(),
+  failover: z.boolean().optional(),
+  // failover for run --model and read-only calls; default true
+  biomeRepair: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    reasoningEffort: ReasoningEffortSchema.optional()
+  }).optional()
+}).strict();
+var FeaturesConfigSchema = z.object({
+  competeZeroFlag: z.boolean().optional()
+}).loose();
+var RoutingModeSchema = z.enum(["frugal", "balanced", "quality", "speed"]);
+var TaskTypeTraitsSchema = z.object({
+  code: z.boolean().optional(),
+  reasoning: z.boolean().optional(),
+  longContext: z.boolean().optional(),
+  fast: z.boolean().optional(),
+  thinking: z.boolean().optional()
+}).strict();
+var TaskTypePreferenceSchema = z.object({
+  traits: TaskTypeTraitsSchema.default({}),
+  preferredTier: z.enum(["premium", "standard", "economy"]).optional()
+}).strict();
+var TierThresholdsSchema = z.object({
+  basicMax: z.number().min(0.05).max(0.95).optional(),
+  standardMax: z.number().min(0.05).max(0.95).optional()
+}).strict();
+var RoutingBehaviorSchema = z.enum(["legacy", "adaptive"]);
+var RoutingConfigSchema = z.object({
+  behavior: RoutingBehaviorSchema.optional(),
+  mode: RoutingModeSchema.optional(),
+  taskTypePreferences: z.record(z.string(), TaskTypePreferenceSchema).optional(),
+  thresholds: TierThresholdsSchema.optional()
+}).strict();
+var VerificationConfigSchema = z.object({
+  format: z.union([z.string(), z.array(z.string())]).optional(),
+  build: z.union([z.string(), z.array(z.string())]).optional(),
+  typecheck: z.union([z.string(), z.array(z.string())]).optional(),
+  lint: z.union([z.string(), z.array(z.string())]).optional(),
+  test: z.union([z.string(), z.array(z.string())]).optional(),
+  audit: z.union([z.string(), z.array(z.string())]).optional(),
+  coverage: z.union([z.string(), z.array(z.string())]).optional()
+}).optional();
+function isSafeCiAuthorityPathEntry(value) {
+  const raw = value.trim();
+  if (!raw || raw === "." || raw === "./" || raw.includes("\0")) return false;
+  if (raw.startsWith("/") || raw.startsWith("\\")) return false;
+  if (raw.startsWith("\\\\")) return false;
+  if (/^[a-zA-Z]:/.test(raw)) return false;
+  const withForward = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!withForward || withForward === ".") return false;
+  if (withForward.startsWith("/") || withForward.startsWith("//")) return false;
+  if (/^[a-zA-Z]:/.test(withForward)) return false;
+  const segments = withForward.split("/");
+  if (segments.includes("..")) return false;
+  const cleaned = segments.filter((segment) => segment.length > 0 && segment !== ".").join("/");
+  if (!cleaned || cleaned === ".") return false;
+  return true;
+}
+var SAFE_CI_REPO_RELATIVE_PATH_PATTERN = /^(?!\s*$)(?!\s*(?:\.[/\\]+)*\.(?:[/\\]+)?\s*$)(?!\s*[A-Za-z]:)(?!\s*[/\\])(?!\s*\.\.(?:[/\\]|$))(?!.*(?:^|[/\\])\.\.(?:[/\\]|$))[^\0]+$/;
+var SAFE_CI_PATH_ENTRY_MESSAGE = "path entries must be repo-relative (no absolute, UNC, drive, empty, dot-only, or parent traversal)";
+var CiSafePathListSchema = z.array(
+  z.string().trim().min(1).max(500).regex(SAFE_CI_REPO_RELATIVE_PATH_PATTERN, SAFE_CI_PATH_ENTRY_MESSAGE).refine(isSafeCiAuthorityPathEntry, {
+    message: SAFE_CI_PATH_ENTRY_MESSAGE
+  })
+).max(64);
+var CiValidationProfileSchema = z.object({
+  id: z.string().trim().regex(
+    /^[a-z][a-z0-9_-]{0,31}$/,
+    "validation profile id must be a lowercase identifier (not reserved full)"
+  ).refine((id) => id !== "full", {
+    message: "validation profile id must not be the reserved value 'full'"
+  }),
+  include: CiSafePathListSchema.min(1).max(32),
+  extensions: z.array(
+    z.string().trim().regex(
+      /^\.[A-Za-z0-9_+.-]{1,32}$/,
+      "extensions must be case-sensitive tokens with a leading dot (e.g. .md)"
+    )
+  ).min(1).max(16)
+}).strict();
+var CiConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  commands: z.union([z.string(), z.array(z.string())]).optional(),
+  authorityPaths: CiSafePathListSchema.optional(),
+  authorityPathsComplete: z.boolean().optional(),
+  /**
+   * Trusted-base exact paths/prefixes eligible for automatic merge.
+   * Separate from validation authority; empty/omitted is fail-closed.
+   */
+  autoMergePaths: CiSafePathListSchema.optional(),
+  /**
+   * Trusted-base validation profiles for optional narrowing (max 8).
+   * Unique ids; nonempty include paths and extensions. Runtime fail-closes
+   * on overlap, incomplete authority, or non-regular change metadata.
+   */
+  validationProfiles: z.array(CiValidationProfileSchema).max(8).optional(),
+  statusContext: z.string().trim().min(1).max(100).optional(),
+  autoMerge: z.boolean().optional(),
+  mergeMethod: z.enum(["merge", "squash", "rebase"]).optional(),
+  maxConcurrent: z.number().int().min(1).max(8).optional(),
+  /**
+   * Let the local merge queue land waiting reviewed PRs as one batch PR
+   * through one gate. Default false.
+   */
+  mergeBatching: z.boolean().optional(),
+  /**
+   * Let merge-queue workers on different hosts take turns landing through a lease ref on the
+   * remote, so one host's landing does not discard another's gate. Efficiency only; default
+   * true. BUILD_LOCAL_CI_LANDING_LEASE=0 also turns it off.
+   */
+  landingLease: z.boolean().optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.authorityPathsComplete === true) {
+    const paths = value.authorityPaths ?? [];
+    if (paths.length === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["authorityPathsComplete"],
+        message: "authorityPathsComplete=true requires at least one valid authorityPaths entry"
+      });
+    }
+  }
+  const profiles = value.validationProfiles ?? [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (let index = 0; index < profiles.length; index += 1) {
+    const id = profiles[index]?.id;
+    if (!id) continue;
+    if (seenIds.has(id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["validationProfiles", index, "id"],
+        message: `duplicate validation profile id '${id}'`
+      });
+    }
+    seenIds.add(id);
+  }
+}).optional();
+var ProgressNarrationConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  provider: z.string().trim().min(1).optional(),
+  model: z.string().trim().min(1).optional(),
+  minIntervalMs: z.int().positive().max(6e5).optional(),
+  maxAgeMs: z.int().positive().max(6e5).optional(),
+  maxChars: z.int().positive().max(160).optional(),
+  timeoutMs: z.int().positive().max(12e4).optional(),
+  maxConsecutiveFailures: z.int().positive().max(20).optional()
+}).strict().optional();
+var AskPresetSchema = z.object({
+  to: z.string().optional(),
+  model: z.string().optional(),
+  effort: z.string().optional()
+}).strict();
+var InheritanceConfigSchema = z.object({
+  automated: z.enum(["build", "native", "native+build"]).optional(),
+  ask: z.enum(["build", "native", "native+build"]).optional()
+}).strict().optional();
+var AskConfigSchema = z.object({
+  presets: z.record(
+    z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "preset names are kebab-case"),
+    AskPresetSchema
+  ).optional(),
+  /**
+   * Time budget for one consult, in whole seconds. Wall-clock only — no cost,
+   * spend, or token figure participates ([B5]). Defaults live in
+   * src/core/ask/ask-budget.ts (hard 900, idle warn 300, idle kill 600,
+   * stdin deadline 30).
+   */
+  timeoutSeconds: z.int().positive().optional(),
+  idleWarnSeconds: z.int().positive().optional(),
+  idleKillSeconds: z.int().positive().optional(),
+  /** Deadline for the non-TTY stdin read (first byte through EOF). */
+  stdinDeadlineSeconds: z.int().positive().optional()
+}).strict().optional();
+var RolesSubagentsSchema = z.preprocess(
+  (value) => {
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "advisory" || normalized === "off") {
+        return normalized;
+      }
+      if (normalized !== "") {
+        const parsed = Number(normalized);
+        return Number.isNaN(parsed) ? value : parsed;
+      }
+    }
+    return value;
+  },
+  z.union([z.int().positive(), z.literal("advisory"), z.literal("off")])
+);
+var RolesReviewerGateSchema = z.enum(["off", "advisory", "high-severity-blocks"]);
+var RolesReviewerThresholdSchema = z.enum(["critical", "high", "medium", "low"]);
+var RolesReviewerPolicySchema = z.enum([
+  "off",
+  "advisory",
+  "block:critical",
+  "block:high",
+  "block:medium",
+  "block:low",
+  "repair:critical",
+  "repair:high",
+  "repair:medium",
+  "repair:low"
+]);
+var RolesExecutorTransportSchema = z.enum(["auto", "headless", "tmux-exec"]);
+var RolesReasoningEffortSchema = ReasoningEffortSchema;
+var RolesOrchestratorSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  modelRole: z.string().optional(),
+  fallbackModelRole: z.string().optional(),
+  // Retired: still read this release.
+  reasoningEffort: RolesReasoningEffortSchema.optional(),
+  /** Removed; accepted for one release and ignored. */
+  candidates: z.unknown().optional(),
+  /** Removed; accepted for one release and ignored. */
+  onExhausted: z.unknown().optional()
+}).strict().superRefine((value, ctx) => {
+  if (!value.provider && (value.model || value.modelRole || value.fallbackModelRole)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["provider"],
+      message: "provider is required when orchestrator model or modelRole is configured"
+    });
+  }
+});
+var RolesExecutorSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  modelRole: z.string().optional(),
+  subagents: RolesSubagentsSchema.optional(),
+  transport: RolesExecutorTransportSchema.optional(),
+  reasoningEffort: RolesReasoningEffortSchema.optional(),
+  /** Removed; accepted for one release and ignored. */
+  candidates: z.unknown().optional(),
+  /** Removed; accepted for one release and ignored. */
+  onExhausted: z.unknown().optional()
+}).strict();
+var RolesReviewerSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  modelRole: z.string().optional(),
+  policy: RolesReviewerPolicySchema.optional(),
+  gate: RolesReviewerGateSchema.optional(),
+  threshold: RolesReviewerThresholdSchema.optional(),
+  /**
+   * Retired: still read this release; use `provider` or defaults.providerOrder.
+   * Preferred provider ids for automatic reviewer selection (highest first),
+   * then the remaining enabled providers in registry order.
+   */
+  providerPreference: z.array(z.string().trim().min(1)).optional(),
+  reasoningEffort: RolesReasoningEffortSchema.optional(),
+  /** Removed; accepted for one release and ignored. */
+  candidates: z.unknown().optional(),
+  /** Removed; accepted for one release and ignored. */
+  onExhausted: z.unknown().optional()
+}).strict();
+var RolesConfigSchema = z.object({
+  orchestrator: RolesOrchestratorSchema.optional(),
+  executor: RolesExecutorSchema.optional(),
+  reviewer: RolesReviewerSchema.optional()
+}).strict();
+var ProviderInvocationConfigSchema = z.object({
+  /**
+   * Absolute directory roots under which invoke workingDirectory must resolve.
+   * When omitted, invoke defaults to the process cwd realpath as the sole root.
+   * Dangerous roots (`/`, `$HOME`, system tmp, etc.) are always refused.
+   */
+  allowedRoots: z.array(z.string().min(1)).optional()
+}).strict();
+var GitAttributionModeSchema = z.enum(["allow", "human-only"]);
+var GitMessageStyleSchema = z.enum(["plain", "conventional"]);
+var GitConfigSchema = z.object({
+  attribution: GitAttributionModeSchema.optional(),
+  messageStyle: GitMessageStyleSchema.optional()
+}).strict();
+var BuildConfigSchema = z.object({
+  $schema: z.string().optional(),
+  defaultProvider: z.string().optional(),
+  providers: ProvidersConfigSchema.optional(),
+  quality: QualityConfigSchema.optional(),
+  telemetry: TelemetryConfigSchema.optional(),
+  variants: VariantsConfigSchema.optional(),
+  optimization: OptimizationConfigSchema.optional(),
+  execution: ExecutionConfigSchema.optional(),
+  worktree: WorktreeConfigSchema.optional(),
+  defaults: DefaultsConfigSchema.optional(),
+  compete: CompeteConfigSchema,
+  planExecute: PlanExecuteConfigSchema.optional(),
+  routing: RoutingConfigSchema.optional(),
+  automation: AutomationConfigSchema.optional(),
+  judge: JudgeConfigSchema.optional(),
+  sync: SyncConfigSchema.optional(),
+  features: FeaturesConfigSchema.optional(),
+  cleanup: CleanupConfigSchema.optional(),
+  verification: VerificationConfigSchema,
+  ci: CiConfigSchema,
+  progressNarration: ProgressNarrationConfigSchema,
+  ask: AskConfigSchema,
+  inheritance: InheritanceConfigSchema,
+  roles: RolesConfigSchema.optional(),
+  providerInvocation: ProviderInvocationConfigSchema.optional(),
+  git: GitConfigSchema.optional()
+}).strip();
+var KNOWN_BUILD_CONFIG_ROOTS = Object.keys(BuildConfigSchema.shape);
+var FirstTimeSetupV2StateSchema = z.object({
+  version: z.literal(2),
+  defaultsInitialized: z.boolean(),
+  defaultsInitializedAt: z.iso.datetime().optional(),
+  completed: z.boolean(),
+  completedAt: z.iso.datetime().optional(),
+  readyProviderIds: z.array(z.string().min(1))
+}).passthrough().refine((state) => !state.completed || state.readyProviderIds.length > 0, {
+  message: "Completed first-run state requires at least one ready provider",
+  path: ["readyProviderIds"]
+}).refine((state) => !state.completed || state.defaultsInitialized, {
+  message: "Completed first-run state requires initialized defaults",
+  path: ["defaultsInitialized"]
+});
+var LegacyFirstTimeSetupStateSchema = z.object({
+  version: z.never().optional(),
+  completed: z.boolean(),
+  timestamp: z.iso.datetime().optional(),
+  provider: z.string().optional()
+}).passthrough();
+var FirstTimeSetupStateSchema = z.union([
+  FirstTimeSetupV2StateSchema,
+  LegacyFirstTimeSetupStateSchema
+]);
+var UserPreferencesSchema = z.object({
+  version: z.string(),
+  userId: z.string(),
+  modelRouting: ModelRoutingPreferencesSchema,
+  preferences: z.object({
+    cursor: z.object({
+      defaultModel: z.string(),
+      userChosenDefault: z.string().optional(),
+      lastModelChange: z.iso.datetime().optional(),
+      firstTimeSetup: z.object({
+        completed: z.boolean(),
+        timestamp: z.iso.datetime().optional(),
+        autoModelChosen: z.boolean().optional()
+      }),
+      usageHistory: z.object({
+        lastUsed: z.string().optional(),
+        usageCount: z.number(),
+        modelChanges: z.array(
+          z.object({
+            from: z.string(),
+            to: z.string(),
+            timestamp: z.iso.datetime(),
+            context: ModelChangeContextTypeSchema
+          })
+        ).optional()
+      })
+    })
+  }),
+  globalDefaults: z.object({
+    cursorModel: z.string(),
+    defaultProvider: z.string().optional(),
+    defaultModel: z.string().optional(),
+    aiJudgeModel: z.string().optional()
+  }),
+  migrations: z.object({
+    lastAppliedVersion: z.string()
+  }),
+  firstTimeSetup: FirstTimeSetupStateSchema.optional()
+});
+var SystemConfigSchema = z.object({
+  providers: z.object({
+    cursor: z.object({
+      enabled: z.boolean(),
+      model: z.string(),
+      systemDefaults: z.object({
+        autoModelForNewUsers: z.boolean(),
+        allowUserOverride: z.boolean(),
+        restrictedModels: z.array(z.string())
+      })
+    })
+  })
+});
+var ConfigSourceTypeSchema = z.enum([
+  "cli",
+  "project",
+  "user",
+  "system",
+  "default",
+  "env",
+  "profile",
+  "merged"
+]);
+var DEFAULT_CONFIG = {
+  providers: {
+    claude: {
+      enabled: true
+      // model omitted: resolved at runtime from providers.yaml registry default
+    },
+    codex: {
+      enabled: true
+      // model omitted: resolved at runtime from providers.yaml registry default
+    },
+    cursor: {
+      enabled: true
+      // model omitted: resolved at runtime from providers.yaml registry default
+    }
+  },
+  quality: {
+    coverage: {
+      enabled: true,
+      threshold: 80
+    },
+    lint: {
+      enabled: true
+    },
+    security: {
+      enabled: true
+    }
+  },
+  // `database` is deliberately omitted: telemetry resolves to the Build data
+  // root, and a default here would be written into every generated config and
+  // then honored as a repo-local override.
+  telemetry: {
+    enabled: true
+  },
+  // No provider lists or panels: speed and cost follow the provider order, quality
+  // (best) runs its first 3 installed providers, and the is-it-done check runs on
+  // the provider that did the work.
+  optimization: {
+    speed: {
+      modelRole: "fast",
+      parallel: { low: 2, medium: 3, high: 4 },
+      maxConcurrent: { low: 2, medium: 3, high: 6 },
+      earlyExit: true,
+      streamResults: true
+    },
+    quality: {
+      parallel: { low: 2, medium: 3, high: 4 },
+      maxConcurrent: { low: 2, medium: 3, high: 4 },
+      aiJudge: true,
+      synthesize: true,
+      earlyExit: true,
+      streamResults: true,
+      autoloop: true,
+      autoloopMaxIterations: { low: 3, medium: 4, high: 5 },
+      autoloopTimeboxMinutes: { low: 45, medium: 60, high: 90 },
+      autoloopMinProgress: 0.15,
+      autoloopJudge: true,
+      autoloopQualityGates: true
+    },
+    cost: {
+      modelRole: "fast",
+      compete: false,
+      maxConcurrent: 1,
+      autoloop: false
+    }
+  },
+  execution: {
+    defaultTimeout: 30,
+    concurrencyMultiplier: 2,
+    fuzzyFileMatching: {
+      enabled: false,
+      // Opt-in for backwards compatibility
+      basenameMatch: true,
+      normalizedPath: true,
+      caseInsensitive: false
+    }
+  },
+  planExecute: {
+    blockerMode: "non-interactive"
+  },
+  worktree: {
+    poolSize: 4,
+    maxConcurrent: MAX_CONCURRENT_DEFAULT,
+    cleanupInterval: 36e5,
+    // 1 hour
+    healthCheckInterval: 3e5
+    // 5 minutes
+  },
+  sync: {
+    routeMain: false,
+    // Push directly to main; QG self-heals failures via fix PRs
+    autoPublish: false,
+    // Publishing a new branch requires an explicit user preference or --publish
+    protectMain: "confirm",
+    // Prompt on protected branches; block non-interactive commits by default
+    checkoutMain: false
+    // Auto-checkout main after successful sync
+  },
+  routing: {
+    behavior: "legacy",
+    mode: "balanced"
+  }
+};
+var DEFAULT_USER_PREFERENCES = {
+  version: "1.0",
+  userId: `${process.env.USER || "unknown"}@${hostname()}`,
+  preferences: {
+    cursor: {
+      defaultModel: "auto",
+      userChosenDefault: void 0,
+      lastModelChange: void 0,
+      firstTimeSetup: {
+        completed: false
+      },
+      usageHistory: {
+        usageCount: 0
+      }
+    }
+  },
+  globalDefaults: {
+    cursorModel: "auto",
+    defaultProvider: void 0,
+    defaultModel: void 0,
+    aiJudgeModel: void 0
+  },
+  migrations: {
+    lastAppliedVersion: "1.0"
+  }
+};
+
+// src/core/config/canonical-read.ts
+import { existsSync, readFileSync } from "fs";
+import { parse as parseJsonc } from "jsonc-parser";
+var RETIRED_BUILD_CONFIG_ROOTS = /* @__PURE__ */ new Set(["tui", "lifecycle"]);
+function buildConfigCandidates(filePath) {
+  const base = filePath.replace(/\.(jsonc|json)$/i, "");
+  return [`${base}.jsonc`, `${base}.json`];
+}
+function selectedBuildConfigCandidate(filePath) {
+  const candidates = buildConfigCandidates(filePath);
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+var BuildConfigReadError = class extends Error {
+  constructor(filePath, reason, diagnostics, cause) {
+    const detail = diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+    super(`Invalid Build configuration at ${filePath} (${reason}): ${detail}`);
+    this.filePath = filePath;
+    this.reason = reason;
+    this.diagnostics = diagnostics;
+    this.name = "BuildConfigReadError";
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+  filePath;
+  reason;
+  diagnostics;
+  code = "BUILD_CONFIG_READ_INVALID";
+};
+function nodeErrorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) return void 0;
+  const code = error.code;
+  return typeof code === "string" || typeof code === "number" ? String(code) : void 0;
+}
+function offsetToLineColumn(source, offset) {
+  const lines = source.slice(0, offset).split("\n");
+  return {
+    line: lines.length,
+    column: (lines[lines.length - 1]?.length ?? 0) + 1
+  };
+}
+function parseDiagnostics(source, errors) {
+  return errors.map((error) => {
+    const location = offsetToLineColumn(source, error.offset);
+    return {
+      message: `JSONC parse error ${error.error} at line ${location.line}, column ${location.column}`,
+      code: error.error,
+      offset: error.offset,
+      line: location.line,
+      column: location.column
+    };
+  });
+}
+function readCanonicalBuildConfig(filePath) {
+  let source;
+  try {
+    source = readFileSync(filePath, "utf8");
+  } catch (error) {
+    if (nodeErrorCode(error) === "ENOENT") {
+      return { status: "missing", filePath };
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      status: "invalid",
+      filePath,
+      error: new BuildConfigReadError(
+        filePath,
+        "unreadable",
+        [{ message: `Unable to read config file: ${detail}`, code: nodeErrorCode(error) }],
+        error
+      )
+    };
+  }
+  return parseCanonicalBuildConfig(source, filePath);
+}
+function parseCanonicalBuildConfig(source, filePath) {
+  const errors = [];
+  const parsed = parseJsonc(source, errors, {
+    allowTrailingComma: true,
+    allowEmptyContent: false,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    return {
+      status: "invalid",
+      filePath,
+      error: new BuildConfigReadError(filePath, "parse", parseDiagnostics(source, errors))
+    };
+  }
+  const validation = BuildConfigSchema.safeParse(parsed);
+  if (!validation.success) {
+    const diagnostics = validation.error.issues.map((issue) => {
+      const path = issue.path.map(String).join(".");
+      return {
+        message: `${path || "<root>"}: ${issue.message}`,
+        path: path || void 0,
+        code: issue.code
+      };
+    });
+    return {
+      status: "invalid",
+      filePath,
+      error: new BuildConfigReadError(filePath, "schema", diagnostics, validation.error),
+      parsed
+    };
+  }
+  const unknownTopLevelKeys = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? Object.keys(parsed).filter(
+    (key) => !KNOWN_BUILD_CONFIG_ROOTS.includes(key) && !RETIRED_BUILD_CONFIG_ROOTS.has(key)
+  ) : [];
+  if (unknownTopLevelKeys.length > 0) {
+    return {
+      status: "invalid",
+      filePath,
+      error: new BuildConfigReadError(
+        filePath,
+        "schema",
+        unknownTopLevelKeys.map((key) => ({
+          message: `${key}: Unknown top-level configuration key`,
+          path: key,
+          code: "unrecognized_key"
+        }))
+      ),
+      parsed
+    };
+  }
+  return {
+    status: "valid",
+    filePath,
+    config: validation.data,
+    unknownTopLevelKeys: []
+  };
+}
+function isBuildConfigReadError(error) {
+  return error instanceof BuildConfigReadError;
+}
+function consumeBuildConfigRead(result) {
+  if (result.status === "missing") return null;
+  if (result.status === "invalid") throw result.error;
+  return result.config;
+}
+
+export {
+  JudgeTypeSchema,
+  LEGACY_REPO_LOCAL_TELEMETRY_DATABASE,
+  TelemetryConfigSchema,
+  ReasoningEffortSchema,
+  RolesConfigSchema,
+  BuildConfigSchema,
+  KNOWN_BUILD_CONFIG_ROOTS,
+  UserPreferencesSchema,
+  DEFAULT_CONFIG,
+  DEFAULT_USER_PREFERENCES,
+  buildConfigCandidates,
+  selectedBuildConfigCandidate,
+  BuildConfigReadError,
+  readCanonicalBuildConfig,
+  parseCanonicalBuildConfig,
+  isBuildConfigReadError,
+  consumeBuildConfigRead
+};
+//# sourceMappingURL=chunk-FKCG7K6H.js.map