@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-G36W2T2S.js

@@ -0,0 +1,1143 @@
+import {
+  MAX_CONCURRENT_DEFAULT
+} from "./chunk-XB5YLCLB.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.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 normalizeLegacyJudgeType(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "hybrid") {
+    return "multi-lens";
+  }
+  if (normalized === "agentic") {
+    return "multi-agent";
+  }
+  return normalized;
+}
+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) Poetic 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({
+  /** Ordered routes per model family */
+  routes: z.record(ModelFamilySchema, z.array(ModelRoutingRouteSchema)).optional(),
+  /** Infra-only failover policy */
+  failover: ModelRoutingFailoverSchema
+}).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 `poetic 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 TelemetryConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  database: z.string().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({
+  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(),
+  reasoningEffort: ReasoningEffortSchema.optional(),
+  strategy: z.string().trim().min(1),
+  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({
+  providerPreference: z.array(z.string().trim().min(1)).optional(),
+  modelRole: z.string().trim().min(1).optional(),
+  fallbackModelRole: z.string().trim().min(1).optional(),
+  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({
+  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()
+}).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 PlanExecuteBlockerModeSchema = z.enum(["non-interactive", "interactive"]);
+var CompeteConfigSchema = z.record(z.string(), z.unknown()).optional();
+var PlanExecuteConfigSchema = z.object({
+  blockerMode: PlanExecuteBlockerModeSchema.optional()
+}).strict();
+var LifecycleHookConfigSchema = z.object({
+  module: z.string().trim().min(1),
+  events: z.array(z.string().trim().min(1)).optional(),
+  enabled: z.boolean().optional(),
+  timeoutMs: z.number().int().positive().optional()
+}).strict();
+var LifecycleConfigSchema = z.object({
+  hooks: z.array(LifecycleHookConfigSchema).optional()
+}).strict();
+var WorktreeConfigSchema = z.object({
+  poolSize: z.number().optional(),
+  maxConcurrent: z.number().optional(),
+  cleanupInterval: z.number().optional(),
+  healthCheckInterval: z.number().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(),
+  strategy: z.string().optional(),
+  model: z.string().optional(),
+  routingPolicy: z.enum(["strict", "reroute"]).optional(),
+  providerOrder: z.array(z.string()).optional(),
+  synthesis: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    providerOrder: z.array(z.string()).optional()
+  }).optional(),
+  splitter: z.object({
+    model: z.string().optional()
+  }).optional(),
+  intent: z.object({
+    decompositionHints: z.array(z.string()).optional(),
+    nonGoals: z.array(z.string()).optional(),
+    disableRepoContext: z.boolean().optional(),
+    decomposition: z.object({
+      providerOrder: z.array(z.string()).optional(),
+      routingPolicy: z.enum(["strict", "reroute"]).optional()
+    }).optional()
+  }).optional(),
+  judge: z.object({
+    type: z.preprocess(normalizeLegacyJudgeType, z.enum(["ai", "multi-lens", "multi-agent"])).optional(),
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    providerOrder: z.array(z.string()).optional()
+  }).optional(),
+  providers: z.record(
+    z.string(),
+    z.object({
+      model: z.string().optional(),
+      strategy: z.string().optional(),
+      modelOrder: z.array(z.string()).optional()
+    })
+  ).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(),
+  /**
+   * Thinking budget token hint for judge execution (provider-specific).
+   *
+   * For Claude CLI, Poetic uses env-based toggles (e.g. MAX_THINKING_TOKENS / ANTHROPIC_MAX_THINKING_TOKENS).
+   */
+  thinkingBudgetTokens: z.number().int().min(0).optional(),
+  /**
+   * When true, Poetic 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(),
+    thinkingBudgetTokens: z.number().int().min(0).optional(),
+    requireThinking: z.boolean().optional()
+  }).optional(),
+  multiLens: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    thinkingBudgetTokens: z.number().int().min(0).optional(),
+    requireThinking: z.boolean().optional()
+  }).optional(),
+  multiAgent: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    thinkingBudgetTokens: z.number().int().min(0).optional(),
+    requireThinking: z.boolean().optional(),
+    workerModel: z.string().optional(),
+    parentMaxTurns: z.number().int().min(1).optional(),
+    parentReasoningEffort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
+    workerReasoningEffort: z.preprocess((value) => {
+      if (value === void 0 || value === null) return value;
+      const normalized = normalizeReasoningEffortInput(value);
+      return normalized ?? value;
+    }, z.enum(["low", "medium", "high", "xhigh", "max"]).nullable().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()
+}).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 CleanupConfigSchema = z.object({
+  providerTemp: ProviderTempCleanupConfigSchema.optional(),
+  prune: PruneRetentionConfigSchema.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 `poetic config set`.
+  timeout: ConfigNumberSchema.optional(),
+  defaultTimeout: ConfigNumberSchema.optional(),
+  concurrencyMultiplier: ConfigNumberSchema.optional(),
+  transport: ExecutionTransportConfigSchema.optional(),
+  fuzzyFileMatching: FuzzyFileMatchingSchema.optional(),
+  biomeRepair: z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    reasoningEffort: ReasoningEffortSchema.optional()
+  }).optional()
+}).strict();
+var FeaturesConfigSchema = z.object({
+  competeResolverV2: z.boolean().optional(),
+  competeZeroFlag: z.boolean().optional(),
+  competeCompletionMode: 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).default(0.3),
+  standardMax: z.number().min(0.05).max(0.95).default(0.7)
+}).strict();
+var RoutingBehaviorSchema = z.enum(["legacy", "adaptive"]);
+var RoutingConfigSchema = z.object({
+  behavior: RoutingBehaviorSchema.default("legacy"),
+  mode: RoutingModeSchema.default("balanced"),
+  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()
+}).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()
+}).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 TuiConfigSchema = z.object({
+  keybindings: z.record(z.string(), z.string()).optional(),
+  notifications: z.object({ bell: z.boolean().optional() }).optional()
+}).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 AskConfigSchema = z.object({
+  presets: z.record(
+    z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "preset names are kebab-case"),
+    AskPresetSchema
+  ).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 RolesExecutorTransportSchema = z.enum(["auto", "headless", "tmux-exec"]);
+var RolesReasoningEffortSchema = ReasoningEffortSchema;
+var RolesOnExhaustedSchema = z.enum([
+  "halt-before-mutation",
+  "halt-before-integration",
+  "halt-and-disclose",
+  "skip-and-annotate"
+]);
+var RoleCandidateSchema = 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(),
+  reasoningEffort: RolesReasoningEffortSchema.optional(),
+  subagents: RolesSubagentsSchema.optional(),
+  transport: RolesExecutorTransportSchema.optional(),
+  mode: z.enum(["executor", "serial-orchestrator"]).optional()
+}).strict();
+function refineNoCandidateMixture(value, ctx) {
+  if (!Array.isArray(value.candidates) || value.candidates.length === 0) return;
+  const conflicting = [];
+  if (value.provider !== void 0) conflicting.push("provider");
+  if (value.model !== void 0) conflicting.push("model");
+  if (value.modelRole !== void 0) conflicting.push("modelRole");
+  if (value.fallbackModelRole !== void 0) conflicting.push("fallbackModelRole");
+  if (value.reasoningEffort !== void 0) conflicting.push("reasoningEffort");
+  if (value.subagents !== void 0) conflicting.push("subagents");
+  if (value.transport !== void 0) conflicting.push("transport");
+  if (value.providerPreference !== void 0) conflicting.push("providerPreference");
+  if (conflicting.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["candidates"],
+      message: `candidates cannot be combined with flat binding fields in the same layer: ${conflicting.join(", ")}. Use either a candidates ladder or the flat binding, not both.`
+    });
+  }
+}
+var RolesOrchestratorSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  modelRole: z.string().optional(),
+  fallbackModelRole: z.string().optional(),
+  reasoningEffort: RolesReasoningEffortSchema.optional(),
+  /** Ordered candidate ladder (see role-candidates.ts). Mutually exclusive with flat fields. */
+  candidates: z.array(RoleCandidateSchema).min(
+    1,
+    "candidates must contain at least one entry; remove the field to fall back to lower-precedence configuration"
+  ).optional(),
+  /** Ladder exhaustion policy. */
+  onExhausted: RolesOnExhaustedSchema.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"
+    });
+  }
+  refineNoCandidateMixture(value, ctx);
+});
+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(),
+  /** Ordered candidate ladder (see role-candidates.ts). Mutually exclusive with flat fields. */
+  candidates: z.array(RoleCandidateSchema).min(
+    1,
+    "candidates must contain at least one entry; remove the field to fall back to lower-precedence configuration"
+  ).optional(),
+  /** Ladder exhaustion policy. */
+  onExhausted: RolesOnExhaustedSchema.optional()
+}).strict().superRefine(refineNoCandidateMixture);
+var RolesReviewerSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  modelRole: z.string().optional(),
+  gate: RolesReviewerGateSchema.optional(),
+  /**
+   * Preferred provider ids for automatic reviewer selection (highest first).
+   * Candidates still must be enabled, not excluded, and have a matching model
+   * role. Remaining enabled providers are appended in registry order after
+   * the preference list so an incomplete preference never silently blocks
+   * selection.
+   */
+  providerPreference: z.array(z.string().trim().min(1)).optional(),
+  reasoningEffort: RolesReasoningEffortSchema.optional(),
+  /** Ordered candidate ladder (see role-candidates.ts). Mutually exclusive with flat fields / providerPreference. */
+  candidates: z.array(RoleCandidateSchema).min(
+    1,
+    "candidates must contain at least one entry; remove the field to fall back to lower-precedence configuration"
+  ).optional(),
+  /** Ladder exhaustion policy. */
+  onExhausted: RolesOnExhaustedSchema.optional()
+}).strict().superRefine(refineNoCandidateMixture);
+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 PoeticConfigSchema = 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(),
+  lifecycle: LifecycleConfigSchema.optional(),
+  routing: RoutingConfigSchema.optional(),
+  automation: AutomationConfigSchema.optional(),
+  judge: JudgeConfigSchema.optional(),
+  sync: SyncConfigSchema.optional(),
+  features: FeaturesConfigSchema.optional(),
+  cleanup: CleanupConfigSchema.optional(),
+  verification: VerificationConfigSchema,
+  ci: CiConfigSchema,
+  tui: TuiConfigSchema,
+  progressNarration: ProgressNarrationConfigSchema,
+  ask: AskConfigSchema,
+  roles: RolesConfigSchema.optional(),
+  providerInvocation: ProviderInvocationConfigSchema.optional()
+}).strip();
+var KNOWN_POETIC_CONFIG_ROOTS = Object.keys(PoeticConfigSchema.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: "auto"
+      // Default for new users
+    }
+  },
+  quality: {
+    coverage: {
+      enabled: true,
+      threshold: 80
+    },
+    lint: {
+      enabled: true
+    },
+    security: {
+      enabled: true
+    }
+  },
+  telemetry: {
+    enabled: true,
+    database: ".poetic/telemetry/db/variants.db"
+  },
+  variants: {
+    strategies: {
+      conservative: { weight: 0.4 },
+      innovative: { weight: 0.3 },
+      hybrid: { weight: 0.3 }
+    }
+  },
+  optimization: {
+    reasoningEffortByRole: {
+      fast: "high",
+      quality: "high",
+      reasoning: "high",
+      long_context: "medium"
+    },
+    speed: {
+      providerPreference: ["codex", "claude", "cursor", "opencode"],
+      modelRole: "fast",
+      fallbackModelRole: "default",
+      parallel: { low: 2, medium: 3, high: 4 },
+      maxConcurrent: { low: 2, medium: 3, high: 6 },
+      earlyExit: true,
+      streamResults: true
+    },
+    quality: {
+      variants: [
+        { provider: "claude", modelRole: "quality", strategy: "conservative", mode: "local" },
+        {
+          provider: "codex",
+          modelRole: "quality",
+          fallbackModelRole: "default",
+          strategy: "hybrid",
+          mode: "local"
+        },
+        { provider: "cursor", modelRole: "quality", strategy: "innovative", mode: "local" }
+      ],
+      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: {
+      providerPreference: ["codex", "claude", "cursor", "opencode"],
+      // `cost` before `fast`: the cheapest tier is not always the fastest one.
+      // A provider that declares no `cost` role falls back to its `fast` role,
+      // which is what this mode resolved before, so the only provider whose
+      // resolution changes is one that declares `cost`. Providers declaring
+      // neither role are unaffected: `fast` already missed and fell through to
+      // capability matching before this change.
+      modelRole: "cost",
+      fallbackModelRole: "fast",
+      compete: false,
+      maxConcurrent: 1,
+      autoloop: false
+    },
+    autoloop: {
+      semanticVerifierProviderPreference: ["claude", "codex"],
+      semanticVerifierModelRole: "fast",
+      fallbackModelRole: "default"
+    }
+  },
+  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";
+function poeticConfigCandidates(filePath) {
+  const base = filePath.replace(/\.(jsonc|json)$/i, "");
+  return [`${base}.jsonc`, `${base}.json`];
+}
+function selectedPoeticConfigCandidate(filePath) {
+  const candidates = poeticConfigCandidates(filePath);
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+var PoeticConfigReadError = class extends Error {
+  constructor(filePath, reason, diagnostics, cause) {
+    const detail = diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+    super(`Invalid Poetic configuration at ${filePath} (${reason}): ${detail}`);
+    this.filePath = filePath;
+    this.reason = reason;
+    this.diagnostics = diagnostics;
+    this.name = "PoeticConfigReadError";
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+  filePath;
+  reason;
+  diagnostics;
+  code = "POETIC_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 readCanonicalPoeticConfig(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 PoeticConfigReadError(
+        filePath,
+        "unreadable",
+        [{ message: `Unable to read config file: ${detail}`, code: nodeErrorCode(error) }],
+        error
+      )
+    };
+  }
+  const errors = [];
+  const parsed = parseJsonc(source, errors, {
+    allowTrailingComma: true,
+    allowEmptyContent: false,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    return {
+      status: "invalid",
+      filePath,
+      error: new PoeticConfigReadError(filePath, "parse", parseDiagnostics(source, errors))
+    };
+  }
+  const validation = PoeticConfigSchema.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 PoeticConfigReadError(filePath, "schema", diagnostics, validation.error),
+      parsed
+    };
+  }
+  const unknownTopLevelKeys = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? Object.keys(parsed).filter(
+    (key) => !KNOWN_POETIC_CONFIG_ROOTS.includes(key)
+  ) : [];
+  if (unknownTopLevelKeys.length > 0) {
+    return {
+      status: "invalid",
+      filePath,
+      error: new PoeticConfigReadError(
+        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 isPoeticConfigReadError(error) {
+  return error instanceof PoeticConfigReadError;
+}
+function consumePoeticConfigRead(result) {
+  if (result.status === "missing") return null;
+  if (result.status === "invalid") throw result.error;
+  return result.config;
+}
+
+export {
+  TelemetryConfigSchema,
+  DefaultsConfigSchema,
+  RolesConfigSchema,
+  PoeticConfigSchema,
+  KNOWN_POETIC_CONFIG_ROOTS,
+  UserPreferencesSchema,
+  SystemConfigSchema,
+  DEFAULT_CONFIG,
+  DEFAULT_USER_PREFERENCES,
+  poeticConfigCandidates,
+  selectedPoeticConfigCandidate,
+  PoeticConfigReadError,
+  readCanonicalPoeticConfig,
+  isPoeticConfigReadError,
+  consumePoeticConfigRead
+};
+//# sourceMappingURL=chunk-G36W2T2S.js.map