@poetic-ai/poetic 1.42.0

package/dist/chunk-AT4TNPWW.js

@@ -0,0 +1,2931 @@
+import {
+  findPoeticPackageRoot
+} from "./chunk-GSGD5E4C.js";
+import {
+  getExecutionContext
+} from "./chunk-UI2F6DJ5.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  findProjectRoot,
+  getConfigPaths,
+  resolveProvidersConfigPath
+} from "./chunk-L6OM4A22.js";
+import {
+  validateConfigPath
+} from "./chunk-XZE4XARH.js";
+import {
+  debugLog,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  KEYS
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/config/provider-registry.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir } from "os";
+import { join, resolve as resolve3, sep } from "path";
+import { fileURLToPath } from "url";
+import yaml from "js-yaml";
+import { z as z2 } from "zod";
+
+// src/core/providers/generated/catalog-digest.ts
+var PROVIDER_CATALOG_SHA256 = "436ed6466f6b99fc21ef1e09ac23735ba4733abe4f8288fbd446ea03996352b5";
+
+// src/core/providers/refresh/overlay.ts
+import { existsSync, readFileSync } from "fs";
+import * as fs from "fs/promises";
+import { z } from "zod";
+var REFRESH_OVERLAY_SCHEMA_VERSION = 1;
+var UsdPer1MSchema = z.union([
+  z.number().nonnegative(),
+  z.string().regex(/^\d+(?:\.\d+)?$/, "Must be non-negative USD")
+]);
+var OverlayModelAvailableEntrySchema = z.object({
+  id: z.string().trim().min(1),
+  display_name: z.string().min(1),
+  full_name: z.string().optional(),
+  capabilities: z.array(z.string()),
+  context_window: z.number().int().positive().optional(),
+  max_output_tokens: z.number().int().positive().optional(),
+  reasoning_effort_levels: z.array(z.string()).optional(),
+  notes: z.string().optional()
+}).strict();
+var OverlayPricingRowSchema = z.object({
+  input_per_1m_tokens: UsdPer1MSchema.optional(),
+  output_per_1m_tokens: UsdPer1MSchema.optional(),
+  cache_read_per_1m_tokens: UsdPer1MSchema.optional(),
+  cache_write_per_1m_tokens: UsdPer1MSchema.optional(),
+  context_window: z.number().int().positive().optional(),
+  features: z.record(z.string(), z.boolean()).optional(),
+  notes: z.string().optional(),
+  last_updated: z.string().optional()
+}).strict();
+var REFRESH_SOURCES = [
+  "API",
+  "doc-poll",
+  "pricing-only",
+  "discovery",
+  "static"
+];
+var OverlaySliceProvenanceSchema = z.object({
+  source: z.enum(REFRESH_SOURCES),
+  fetchedAt: z.string().min(1),
+  freshnessMs: z.number().int().nonnegative().optional()
+}).strict();
+var OverlayProviderPayloadSchema = z.object({
+  models: z.object({
+    available: z.array(OverlayModelAvailableEntrySchema),
+    /** Treat available as the complete provider inventory, not an additive patch. */
+    replaceInventory: z.literal(true).optional()
+  }).strict().optional(),
+  pricing: z.object({
+    models: z.record(z.string(), OverlayPricingRowSchema)
+  }).strict().optional(),
+  /** Provider-level freshness / provenance. */
+  provenance: OverlaySliceProvenanceSchema.optional(),
+  /** Per-slice freshness / provenance (models vs pricing). */
+  slices: z.object({
+    models: OverlaySliceProvenanceSchema.optional(),
+    pricing: OverlaySliceProvenanceSchema.optional()
+  }).strict().optional()
+}).strict();
+var RefreshOverlayDocumentSchema = z.object({
+  schemaVersion: z.literal(REFRESH_OVERLAY_SCHEMA_VERSION),
+  baseCatalogDigest: z.string().min(1),
+  providers: z.record(z.string(), OverlayProviderPayloadSchema)
+}).strict();
+var REFRESH_OVERLAY_RERUN_GUIDANCE = "Refresh overlay ignored because the release catalog digest changed. Run: poetic provider refresh";
+function noticeFromRefreshOverlayDisposition(disposition) {
+  if (disposition.status === "degraded") {
+    return {
+      status: "degraded",
+      reason: disposition.reason,
+      message: disposition.warning,
+      guidance: REFRESH_OVERLAY_RERUN_GUIDANCE
+    };
+  }
+  if (disposition.status === "rejected") {
+    return {
+      status: "rejected",
+      reason: disposition.reason,
+      message: disposition.error,
+      guidance: "Refresh overlay is invalid and was ignored. Run: poetic provider refresh"
+    };
+  }
+  return void 0;
+}
+function getRefreshOverlayOperatorNotice(overlayPath, expectedBaseCatalogDigest) {
+  if (!existsSync(overlayPath)) return void 0;
+  try {
+    const disposition = resolveRefreshOverlayDisposition(readFileSync(overlayPath, "utf8"), {
+      expectedBaseCatalogDigest
+    });
+    return noticeFromRefreshOverlayDisposition(disposition);
+  } catch {
+    return void 0;
+  }
+}
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (value && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = sortKeysDeep(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function emptyRefreshOverlay(baseCatalogDigest) {
+  return {
+    schemaVersion: REFRESH_OVERLAY_SCHEMA_VERSION,
+    baseCatalogDigest,
+    providers: {}
+  };
+}
+function serializeRefreshOverlay(overlay) {
+  const parsed = RefreshOverlayDocumentSchema.safeParse(overlay);
+  if (!parsed.success) {
+    throw new Error(
+      `Cannot serialize invalid refresh overlay: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`
+    );
+  }
+  return `${JSON.stringify(sortKeysDeep(parsed.data), null, 2)}
+`;
+}
+function parseRefreshOverlayValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return { ok: false, error: "Refresh overlay must be a JSON object" };
+  }
+  const parsed = RefreshOverlayDocumentSchema.safeParse(value);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: `Invalid refresh overlay schema: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+    };
+  }
+  return { ok: true, overlay: parsed.data };
+}
+function parseRefreshOverlay(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Refresh overlay is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  return parseRefreshOverlayValue(value);
+}
+function resolveRefreshOverlayDisposition(input, options) {
+  const parsed = typeof input === "string" ? parseRefreshOverlay(input) : parseRefreshOverlayValue(input);
+  if (!parsed.ok) {
+    return { status: "rejected", reason: "invalid_schema", error: parsed.error };
+  }
+  if (options.expectedBaseCatalogDigest !== parsed.overlay.baseCatalogDigest) {
+    return {
+      status: "degraded",
+      reason: "base_digest_mismatch",
+      warning: `Refresh overlay base catalog digest mismatch: overlay=${parsed.overlay.baseCatalogDigest} expected=${options.expectedBaseCatalogDigest}; overlay ignored`,
+      overlay: parsed.overlay
+    };
+  }
+  return { status: "ready", overlay: parsed.overlay };
+}
+async function loadRefreshOverlayFile(overlayPath, options) {
+  try {
+    const stat = await fs.lstat(overlayPath);
+    if (stat.isSymbolicLink()) {
+      return {
+        status: "rejected",
+        reason: "invalid_schema",
+        error: `Provider refresh refuses a symlinked overlay: ${overlayPath}`
+      };
+    }
+    if (!stat.isFile()) {
+      return {
+        status: "rejected",
+        reason: "invalid_schema",
+        error: `Provider refresh overlay target is not a regular file: ${overlayPath}`
+      };
+    }
+    const raw = await fs.readFile(overlayPath, "utf8");
+    return resolveRefreshOverlayDisposition(raw, options);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { status: "absent" };
+    }
+    throw error;
+  }
+}
+
+// src/core/config/cache-fingerprint.ts
+import { createHash } from "crypto";
+import { statSync } from "fs";
+import { resolve } from "path";
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function fingerprintEnvironment(env, include = (name) => name.startsWith("POETIC_")) {
+  const entries = Object.entries(env).filter(([name, value]) => include(name) && value !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([name, value]) => [name, digest(value ?? "")]);
+  return digest(JSON.stringify(entries));
+}
+function fingerprintFile(filePath) {
+  const normalized = resolve(filePath);
+  try {
+    const stat = statSync(normalized);
+    return JSON.stringify({
+      path: normalized,
+      exists: true,
+      dev: stat.dev,
+      ino: stat.ino,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      ctimeMs: stat.ctimeMs
+    });
+  } catch (error) {
+    const code = error.code;
+    return JSON.stringify({ path: normalized, exists: false, code: code ?? "UNKNOWN" });
+  }
+}
+function fingerprintFiles(filePaths) {
+  return digest(JSON.stringify([...new Set(filePaths)].sort().map(fingerprintFile)));
+}
+function combineCacheFingerprints(...parts) {
+  return digest(JSON.stringify(parts.filter((part) => part !== void 0)));
+}
+
+// src/core/config/config-errors.ts
+var InvalidExplicitConfigError = class extends Error {
+  constructor(message, sourceError) {
+    super(message);
+    this.sourceError = sourceError;
+    this.name = "InvalidExplicitConfigError";
+  }
+  sourceError;
+  code = "POETIC_INVALID_EXPLICIT_CONFIG";
+};
+function isInvalidExplicitConfigError(error) {
+  return error instanceof InvalidExplicitConfigError || error instanceof Error && error.code === "POETIC_INVALID_EXPLICIT_CONFIG";
+}
+function isConfigValidityError(error) {
+  if (isInvalidExplicitConfigError(error)) return true;
+  return error instanceof Error && error.code === "POETIC_CONFIG_READ_INVALID";
+}
+function rethrowConfigValidityError(error) {
+  if (isConfigValidityError(error)) throw error;
+}
+
+// src/core/config/registry/dynamic-keys.ts
+var DYNAMIC_KEYS = [
+  //  Per-command idle timeouts
+  // Source: src/core/providers/shared/base-runner.ts
+  //   process.env[`POETIC_IDLE_WARN_${commandName}_MS`]
+  {
+    pattern: /^POETIC_IDLE_WARN_[A-Z][A-Z0-9_]*_MS$/,
+    extract: (name) => {
+      const m = name.match(/^POETIC_IDLE_WARN_([A-Z][A-Z0-9_]*)_MS$/);
+      if (!m || m[1] === void 0) return null;
+      return { command: m[1] };
+    },
+    category: "provider",
+    status: "active",
+    description: "Per-command idle warning threshold: POETIC_IDLE_WARN_<CMD>_MS",
+    type: "number"
+  },
+  {
+    pattern: /^POETIC_IDLE_KILL_[A-Z][A-Z0-9_]*_MS$/,
+    extract: (name) => {
+      const m = name.match(/^POETIC_IDLE_KILL_([A-Z][A-Z0-9_]*)_MS$/);
+      if (!m || m[1] === void 0) return null;
+      return { command: m[1] };
+    },
+    category: "provider",
+    status: "active",
+    description: "Per-command idle kill threshold: POETIC_IDLE_KILL_<CMD>_MS",
+    type: "number"
+  },
+  //  Per-provider timeout overrides
+  // Source: src/core/timeout/timeout-config.ts
+  //   `POETIC_TIMEOUT_${normalizedProvider.toUpperCase()}_${mode.toUpperCase()}`
+  //   `POETIC_TIMEOUT_DEFAULT_${mode.toUpperCase()}`
+  // Modes observed: LOCAL, CLOUD, API, REMOTE, MS, and any future mode string.
+  {
+    pattern: /^POETIC_TIMEOUT_[A-Z][A-Z0-9_]*_[A-Z][A-Z0-9]*$/,
+    extract: (name) => {
+      const m = name.match(/^POETIC_TIMEOUT_([A-Z][A-Z0-9_]*)_([A-Z][A-Z0-9]*)$/);
+      if (!m || m[1] === void 0 || m[2] === void 0) return null;
+      return { provider: m[1], mode: m[2] };
+    },
+    category: "provider",
+    status: "active",
+    description: "Per-provider/mode timeout override (ms): POETIC_TIMEOUT_<PROVIDER>_<MODE> or POETIC_TIMEOUT_DEFAULT_<MODE>",
+    type: "number"
+  },
+  //  Per-provider timeout from provider-timeout.ts
+  // Source: src/core/providers/shared/provider-timeout.ts
+  //   `POETIC_TIMEOUT_${providerId.toUpperCase()}_MS`
+  // This is a subset of the pattern above; the combined pattern already covers it.
+  //  Per-provider sandbox toggles
+  // Source: src/core/sandbox/index.ts
+  //   process.env[`POETIC_SANDBOX_${normalizedName}_ENABLED`]
+  //   process.env[`POETIC_SANDBOX_${normalizedId}_ENABLED`]
+  {
+    pattern: /^POETIC_SANDBOX_[A-Z][A-Z0-9_]*_ENABLED$/,
+    extract: (name) => {
+      const m = name.match(/^POETIC_SANDBOX_([A-Z][A-Z0-9_]*)_ENABLED$/);
+      if (!m || m[1] === void 0) return null;
+      return { provider: m[1] };
+    },
+    category: "sandbox",
+    status: "active",
+    description: "Per-provider sandbox enable toggle: POETIC_SANDBOX_<PROVIDER>_ENABLED",
+    type: "boolean"
+  },
+  //  Per-provider execution policy enforcement
+  // Source: src/orchestrator/execution-policy.ts
+  //   `POETIC_EXECUTION_POLICY_ENFORCE_${provider.toUpperCase()}`
+  {
+    pattern: /^POETIC_EXECUTION_POLICY_ENFORCE_[A-Z][A-Z0-9_]*$/,
+    extract: (name) => {
+      const m = name.match(/^POETIC_EXECUTION_POLICY_ENFORCE_([A-Z][A-Z0-9_]*)$/);
+      if (!m || m[1] === void 0) return null;
+      return { provider: m[1] };
+    },
+    category: "orchestrator",
+    status: "active",
+    description: "Per-provider execution policy enforcement toggle: POETIC_EXECUTION_POLICY_ENFORCE_<PROVIDER>",
+    type: "boolean"
+  },
+  //  Per-provider config overrides
+  // Source: src/core/config/provider-registry.ts
+  //   POETIC_PROVIDER_<ID>_<KEY>=value (e.g. POETIC_PROVIDER_CODEX_TIMEOUT_MS,
+  //   POETIC_PROVIDER_CLAUDE_ENABLED, POETIC_PROVIDER_GEMINI_MODELS_DEFAULT).
+  // Static REGISTRY entries that begin with POETIC_PROVIDER_ are checked
+  // first by isRecognizedEnvVar; this fallback recognizes the dynamic
+  // <PROVIDER>_<KEY> shape so legitimate overrides aren't flagged. The
+  // provider/key boundary is registry-dependent because both may contain
+  // underscores; ProviderRegistry resolves the longest registered prefix.
+  {
+    pattern: /^POETIC_PROVIDER_[A-Z0-9][A-Z0-9_-]*_[A-Z][A-Z0-9_]*$/,
+    extract: (name) => {
+      const m = name.match(/^POETIC_PROVIDER_([A-Z0-9][A-Z0-9_-]*_[A-Z][A-Z0-9_]*)$/);
+      if (!m || m[1] === void 0) return null;
+      return { providerAndKey: m[1] };
+    },
+    category: "provider",
+    status: "active",
+    description: "Per-provider config override: POETIC_PROVIDER_<ID>_<KEY>",
+    type: "string"
+  }
+];
+
+// src/core/config/env-var-registry.ts
+var REGISTRY = Object.fromEntries(
+  Object.entries(KEYS).map(([name, spec]) => [
+    name,
+    {
+      category: spec.category,
+      status: spec.status,
+      description: spec.description,
+      ...spec.replacement !== void 0 ? { replacement: spec.replacement } : {}
+    }
+  ])
+);
+function isRecognizedEnvVar(name) {
+  if (REGISTRY[name]) return true;
+  return DYNAMIC_KEYS.some((spec) => spec.pattern.test(name));
+}
+function getEnvVarEntry(name) {
+  return REGISTRY[name];
+}
+function levenshtein(a, b, maxDist) {
+  if (Math.abs(a.length - b.length) > maxDist) return maxDist + 1;
+  const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  const curr = new Array(b.length + 1);
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      curr[j] = a[i - 1] === b[j - 1] ? prev[j - 1] : 1 + Math.min(prev[j], curr[j - 1], prev[j - 1]);
+    }
+    for (let j = 0; j <= b.length; j++) prev[j] = curr[j];
+  }
+  return prev[b.length];
+}
+function closestRegisteredKeys(unknown, maxDist, limit) {
+  const candidates = [];
+  for (const name of Object.keys(REGISTRY)) {
+    const dist = levenshtein(unknown, name, maxDist);
+    if (dist <= maxDist) candidates.push({ name, dist });
+  }
+  candidates.sort((a, b) => a.dist - b.dist);
+  return candidates.slice(0, limit).map((c) => c.name);
+}
+function validateEnvironmentVars() {
+  const unrecognized = [];
+  for (const key of Object.keys(process.env)) {
+    if (!key.startsWith("POETIC_")) continue;
+    if (!isRecognizedEnvVar(key)) {
+      unrecognized.push(key);
+    }
+  }
+  if (process.env.POETIC_STRICT_ENV === "1" && unrecognized.length > 0) {
+    for (const key of unrecognized) {
+      const suggestions = closestRegisteredKeys(key, 2, 3);
+      const hint = suggestions.length > 0 ? ` (did you mean: ${suggestions.join(", ")}?)` : "";
+      console.warn(`[poetic] POETIC_STRICT_ENV: unrecognized env var: ${key}${hint}`);
+    }
+  }
+  return unrecognized;
+}
+
+// src/core/config/project-trust.ts
+import { realpathSync } from "fs";
+import { isAbsolute, resolve as resolve2 } from "path";
+var PROJECT_EXECUTION_TRUST_ENV = "POETIC_TRUST_PROJECT_PROVIDER_TEMPLATES";
+function isTrustedProjectRoot(projectRoot) {
+  const projectTrustValue = String(process.env[PROJECT_EXECUTION_TRUST_ENV] ?? "").trim();
+  if (!projectTrustValue || !isAbsolute(projectTrustValue)) return false;
+  try {
+    return realpathSync(resolve2(projectTrustValue)) === realpathSync(projectRoot);
+  } catch {
+    return false;
+  }
+}
+function formatProjectTrustInstruction(projectRoot) {
+  let canonical = projectRoot;
+  try {
+    canonical = realpathSync(projectRoot);
+  } catch {
+  }
+  return `  export ${PROJECT_EXECUTION_TRUST_ENV}=${JSON.stringify(canonical)}`;
+}
+
+// src/core/config/provider-registry-reload-invalidators.ts
+var reloadInvalidators = /* @__PURE__ */ new Set();
+function registerProviderRegistryReloadInvalidator(invalidator) {
+  reloadInvalidators.add(invalidator);
+  return () => {
+    reloadInvalidators.delete(invalidator);
+  };
+}
+function runProviderRegistryReloadInvalidators() {
+  for (const invalidator of reloadInvalidators) {
+    invalidator();
+  }
+}
+
+// src/core/config/provider-registry.ts
+var __filename = fileURLToPath(import.meta.url);
+function getEmbeddedProviderConfigPaths() {
+  const packageRoot = findPoeticPackageRoot(__filename);
+  if (!packageRoot) return [];
+  return [
+    // A source checkout authors the canonical YAML directly. Prefer it over the
+    // ignored generated asset so a stale prebuild output cannot shadow or break
+    // local authoring. The YAML path is not published in the npm package.
+    resolve3(packageRoot, ".poetic/config/providers.yaml"),
+    // Installed runtimes therefore require the packaged, digest-checked asset.
+    resolve3(packageRoot, ".poetic/providers/catalog.json")
+  ];
+}
+function getUserProviderRegistryPaths(cwd = process.cwd()) {
+  let home = "";
+  try {
+    home = homedir() ?? "";
+  } catch {
+    home = "";
+  }
+  if (!home) home = (process.env.HOME ?? process.env.USERPROFILE ?? "").trim();
+  const canonicalUserDir = getConfigPaths(cwd).userConfigDir;
+  const defaultUserDir = home ? join(home, ".poetic", "config") : "";
+  return [
+    join(canonicalUserDir, "providers.yaml"),
+    // ~/.config/poetic is the pre-default (XDG) registry location, kept as a
+    // compatibility fallback for the default layout only. An explicit
+    // POETIC_CONFIG_DIR/XDG root is authoritative and must not be contaminated
+    // by state from another user-config tree.
+    ...home && resolve3(canonicalUserDir) === resolve3(defaultUserDir) ? [join(home, ".config", "poetic", "providers.yaml")] : []
+  ];
+}
+function getConfiguredProviderRegistryPaths(cwd = process.cwd()) {
+  const projectRoot = findProjectRoot(cwd) ?? cwd;
+  return [
+    ...getUserProviderRegistryPaths(projectRoot),
+    resolveProvidersConfigPath({ cwd: projectRoot }),
+    resolve3(projectRoot, ".poetic", "config", "provider-registry.yaml.v1.backup")
+  ];
+}
+function getProviderRegistryInputPaths(cwd = process.cwd()) {
+  const projectRoot = findProjectRoot(cwd) ?? cwd;
+  return [
+    ...getEmbeddedProviderConfigPaths(),
+    resolve3(projectRoot, ".poetic", "cache", "model-update", "refresh-overlay.json"),
+    ...getConfiguredProviderRegistryPaths(projectRoot)
+  ];
+}
+var REMOVED_BUILTIN_PROVIDER_IDS = /* @__PURE__ */ new Set(["glm"]);
+var PROJECT_POLICY_PROVIDER_FIELDS = [
+  "enabled",
+  "order",
+  "concurrency_hint",
+  "concurrency",
+  "timeout_ms",
+  "health_check_timeout_ms",
+  "memory",
+  "polling",
+  "bot_identity",
+  "env",
+  "retry",
+  "circuit_breaker",
+  "rate_limits",
+  "workspace_edits",
+  "generation",
+  "task_settings",
+  "options"
+];
+var PROJECT_TRUSTED_EXTENSION_FIELDS = [
+  "transport",
+  "api",
+  "auth",
+  "cli",
+  "exec",
+  "engine",
+  "plugins",
+  "route_id",
+  "route",
+  "allow_unsafe_binary",
+  "requires",
+  "requires_if"
+];
+var EXECUTION_SENSITIVE_PROVIDER_FIELDS = ["cli", "exec", "engine", "plugins"];
+var CURSOR_ID_SYNTAX_ADMISSION_PATTERN = "^[a-z0-9][a-z0-9._-]{0,63}$";
+var DateLikeStringSchema = z2.union([z2.string(), z2.date()]).transform((value) => value instanceof Date ? value.toISOString() : value);
+function normalizeProviderConfigId(providerId) {
+  const normalized = providerId.trim().toLowerCase();
+  if (normalized === "cursor-cli") return "cursor";
+  if (normalized === "copilot-cli") return "copilot";
+  if (normalized === "anti-gravity" || normalized === "antigravity-cli" || normalized === "agy") {
+    return "antigravity";
+  }
+  return normalized;
+}
+function dropRemovedBuiltinProviders(raw) {
+  if (!raw || typeof raw !== "object") return raw;
+  const providers = raw.providers;
+  if (!providers || typeof providers !== "object") return raw;
+  for (const providerId of REMOVED_BUILTIN_PROVIDER_IDS) {
+    delete providers[providerId];
+  }
+  return raw;
+}
+function ensureCursorIdSyntaxAdmissionPattern(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const providers = raw.providers;
+  if (!providers || typeof providers !== "object" || Array.isArray(providers)) return raw;
+  const cursor = providers.cursor;
+  if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) return raw;
+  const models = cursor.models;
+  if (!models || typeof models !== "object" || Array.isArray(models)) return raw;
+  const patterns = models.allowed_patterns;
+  if (!Array.isArray(patterns)) return raw;
+  if (!patterns.every((pattern) => typeof pattern === "string")) return raw;
+  if (patterns.includes(CURSOR_ID_SYNTAX_ADMISSION_PATTERN)) return raw;
+  models.allowed_patterns = [
+    ...patterns,
+    CURSOR_ID_SYNTAX_ADMISSION_PATTERN
+  ];
+  return raw;
+}
+function projectProjectRegistryPolicy(projectRaw, embeddedRaw, options) {
+  if (!projectRaw || typeof projectRaw !== "object" || Array.isArray(projectRaw)) {
+    return projectRaw;
+  }
+  const embeddedProvidersValue = embeddedRaw && typeof embeddedRaw === "object" && !Array.isArray(embeddedRaw) ? embeddedRaw.providers : null;
+  if (!embeddedProvidersValue || typeof embeddedProvidersValue !== "object" || Array.isArray(embeddedProvidersValue)) {
+    return projectRaw;
+  }
+  const projectProvidersValue = projectRaw.providers;
+  if (!projectProvidersValue || typeof projectProvidersValue !== "object" || Array.isArray(projectProvidersValue)) {
+    return projectRaw;
+  }
+  const embeddedProviders = embeddedProvidersValue;
+  const projectedProviders = {};
+  for (const [providerId, providerValue] of Object.entries(
+    projectProvidersValue
+  )) {
+    if (!(providerId in embeddedProviders)) {
+      projectedProviders[providerId] = providerValue;
+      continue;
+    }
+    if (!providerValue || typeof providerValue !== "object" || Array.isArray(providerValue)) {
+      projectedProviders[providerId] = providerValue;
+      continue;
+    }
+    const sourceProvider = providerValue;
+    const provider = {};
+    for (const field of PROJECT_POLICY_PROVIDER_FIELDS) {
+      if (sourceProvider[field] !== void 0) provider[field] = sourceProvider[field];
+    }
+    if (options.trusted) {
+      for (const field of PROJECT_TRUSTED_EXTENSION_FIELDS) {
+        if (sourceProvider[field] !== void 0) provider[field] = sourceProvider[field];
+      }
+    } else if (sourceProvider.api && typeof sourceProvider.api === "object" && !Array.isArray(sourceProvider.api)) {
+      const sourceApi = sourceProvider.api;
+      const api = {};
+      for (const field of [
+        "stream",
+        "max_tokens",
+        "max_tool_iterations",
+        "per_tool_timeout_ms"
+      ]) {
+        if (sourceApi[field] !== void 0) api[field] = sourceApi[field];
+      }
+      if (Object.keys(api).length > 0) provider.api = api;
+    }
+    const modelsValue = sourceProvider.models;
+    if (modelsValue && typeof modelsValue === "object" && !Array.isArray(modelsValue)) {
+      const sourceModels = modelsValue;
+      const models = {};
+      for (const field of ["default", "default_reasoning_effort", "roles", "mappings"]) {
+        if (sourceModels[field] !== void 0) models[field] = sourceModels[field];
+      }
+      provider.models = models;
+    }
+    projectedProviders[providerId] = provider;
+  }
+  return {
+    providers: projectedProviders
+  };
+}
+function applyRefreshOverlay(baseRaw, overlay) {
+  if (!baseRaw || typeof baseRaw !== "object" || Array.isArray(baseRaw)) return baseRaw;
+  const base = structuredClone(baseRaw);
+  const providers = base.providers;
+  if (!providers || typeof providers !== "object" || Array.isArray(providers)) return baseRaw;
+  for (const [providerId, payload] of Object.entries(overlay.providers)) {
+    const provider = providers[providerId];
+    if (!provider || typeof provider !== "object" || Array.isArray(provider)) continue;
+    const providerObject = provider;
+    if (payload.models) {
+      const models = providerObject.models;
+      if (models && typeof models === "object" && !Array.isArray(models)) {
+        const modelObject = models;
+        if (payload.models.replaceInventory) {
+          modelObject.available = payload.models.available;
+          const access = modelObject.access;
+          if (access && typeof access === "object" && !Array.isArray(access)) {
+            const accessObject = access;
+            const overrides = accessObject.overrides;
+            if (overrides && typeof overrides === "object" && !Array.isArray(overrides)) {
+              const availableIds = new Set(payload.models.available.map((entry) => entry.id));
+              accessObject.overrides = Object.fromEntries(
+                Object.entries(overrides).filter(
+                  ([modelId]) => availableIds.has(modelId)
+                )
+              );
+            }
+          }
+        } else {
+          const current = Array.isArray(modelObject.available) ? modelObject.available : [];
+          const overlayById = new Map(payload.models.available.map((entry) => [entry.id, entry]));
+          const merged = current.map((entry) => {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
+            const id = entry.id;
+            const updated = typeof id === "string" ? overlayById.get(id) : void 0;
+            if (!updated) return entry;
+            overlayById.delete(id);
+            return { ...entry, ...updated };
+          });
+          modelObject.available = [...merged, ...overlayById.values()];
+        }
+      }
+    }
+    if (payload.pricing) {
+      const pricing = providerObject.pricing;
+      if (pricing && typeof pricing === "object" && !Array.isArray(pricing)) {
+        const pricingObject = pricing;
+        const currentModels = pricingObject.models && typeof pricingObject.models === "object" && !Array.isArray(pricingObject.models) ? pricingObject.models : {};
+        pricingObject.models = Object.fromEntries(
+          Object.entries({ ...currentModels, ...payload.pricing.models }).map(([id, row]) => [
+            id,
+            currentModels[id] && typeof currentModels[id] === "object" ? { ...currentModels[id], ...row } : row
+          ])
+        );
+      }
+    }
+  }
+  return base;
+}
+var RetryConfigSchema = z2.object({
+  max_attempts: z2.number().int().min(1).max(10),
+  initial_delay_ms: z2.number().int().min(0),
+  max_delay_ms: z2.number().int().min(0),
+  backoff_multiplier: z2.number().min(1)
+}).strict();
+var CircuitBreakerConfigSchema = z2.object({
+  failure_threshold: z2.number().int().min(1),
+  cooldown_ms: z2.number().int().min(0),
+  half_open_max_attempts: z2.number().int().min(1).optional()
+}).strict();
+var RateLimitEntrySchema = z2.object({
+  rpm: z2.number().int().min(1),
+  // Requests per minute
+  bucket_size: z2.number().int().min(1),
+  // Token bucket burst capacity
+  refill_rate: z2.number().min(0)
+  // Tokens per second
+}).strict();
+var RateLimitsConfigSchema = z2.object({
+  rpm: z2.number().int().min(1).optional(),
+  // Default RPM (convenience alias)
+  bucket_size: z2.number().int().min(1).optional(),
+  // Default bucket size
+  refill_rate: z2.number().min(0).optional(),
+  // Default refill rate
+  default: RateLimitEntrySchema.optional(),
+  // Explicit default config
+  models: z2.record(z2.string(), RateLimitEntrySchema).optional()
+  // Per-model overrides
+}).strict();
+var MemoryConfigSchema = z2.object({
+  warn_threshold: z2.number().min(0).max(1),
+  critical_threshold: z2.number().min(0).max(1),
+  emergency_threshold: z2.number().min(0).max(1),
+  max_processes: z2.number().int().min(1)
+}).strict();
+var PollingConfigSchema = z2.object({
+  initial_interval_ms: z2.number().int().min(0),
+  max_interval_ms: z2.number().int().min(0),
+  backoff_multiplier: z2.number().min(1),
+  timeout_ms: z2.number().int().min(0).optional(),
+  show_progress: z2.boolean()
+}).strict();
+var CLIConfigSchema = z2.object({
+  command: z2.string(),
+  binary: z2.string(),
+  install_command: z2.string().default(""),
+  // Installation metadata for setup automation
+  // - manual: show instructions only (no command execution)
+  // - curl: requires explicit opt-in via POETIC_ALLOW_CURL_BASH=1
+  install_method: z2.enum(["npm", "brew", "pipx", "curl", "manual"]).optional().default("manual"),
+  min_node_version: z2.string().optional(),
+  risk_level: z2.enum(["safe", "needs-confirmation"]).optional().default("safe"),
+  install_note: z2.string().optional()
+}).strict();
+var AuthConfigSchema = z2.object({
+  type: z2.enum(["cli_login", "api_key", "oauth", "cli_wrapper"]),
+  env_vars: z2.array(z2.string()),
+  skip_env_var: z2.string().optional(),
+  note: z2.string().optional()
+}).strict();
+var TemplatedAuthConfigSchema = AuthConfigSchema.default({
+  type: "cli_login",
+  env_vars: [],
+  skip_env_var: "POETIC_SKIP_AUTH"
+});
+var ProviderReleaseStatusSchema = z2.enum([
+  "primary_validated",
+  "supported_validated",
+  "supported_beta",
+  "experimental"
+]);
+var JsonScalarSchema = z2.union([z2.string(), z2.number(), z2.boolean(), z2.null()]);
+var ProbeExpectationSchema = z2.union([
+  JsonScalarSchema,
+  z2.object({
+    present: z2.boolean().optional(),
+    truthy: z2.boolean().optional(),
+    equals: JsonScalarSchema.optional()
+  }).strict()
+]);
+var CommandProbeSchema = z2.object({
+  command_argv: z2.array(z2.string()).min(1),
+  parse_as: z2.enum(["json", "exit_code"]).optional().default("json"),
+  json_path: z2.string().optional(),
+  expect: ProbeExpectationSchema.optional(),
+  timeout_ms: z2.number().int().min(1).optional()
+}).strict();
+var ModelsDiscoverySchema = z2.object({
+  command_argv: z2.array(z2.string()).min(1),
+  json_path: z2.string().optional().default("$"),
+  id_path: z2.string().optional().default("id"),
+  ttl_hours: z2.number().positive().optional().default(24),
+  timeout_ms: z2.number().int().min(1).optional()
+}).strict();
+var LongContextPricingSchema = z2.object({
+  threshold_tokens: z2.number().int().optional(),
+  threshold: z2.number().int().optional(),
+  input_multiplier: z2.number().positive(),
+  output_multiplier: z2.number().positive(),
+  note: z2.string().optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.threshold_tokens === void 0 && value.threshold === void 0) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "long_context_pricing requires threshold_tokens or threshold",
+      path: ["threshold_tokens"]
+    });
+  }
+}).transform((value) => ({
+  threshold_tokens: value.threshold_tokens ?? value.threshold,
+  input_multiplier: value.input_multiplier,
+  output_multiplier: value.output_multiplier,
+  ...value.note ? { note: value.note } : {}
+}));
+var ModelInfoSchema = z2.object({
+  id: z2.string().trim().min(1),
+  display_name: z2.string(),
+  full_name: z2.string().optional(),
+  capabilities: z2.array(z2.string()),
+  context_window: z2.number().int().optional(),
+  long_context_pricing: LongContextPricingSchema.optional(),
+  context_window_beta: z2.object({
+    max_tokens: z2.number().int(),
+    beta_header: z2.string(),
+    pricing_note: z2.string().optional()
+  }).optional(),
+  max_output_tokens: z2.number().int().optional(),
+  /**
+   * Claude-CLI context-window selector to append to this model's `--model`
+   * value (only `[1m]` exists today).
+   *
+   * Deliberately top-level: the selector applies on every CLI backend, so
+   * nesting it under `bedrock` made it structurally impossible to declare for
+   * Anthropic first-party or Vertex. The nested
+   * `bedrock.claude_cli_context_selector` is still read as a fallback for
+   * configs written against the old shape.
+   *
+   * The backends are NOT identical, which is why one field plus a per-backend
+   * application rule beats duplicating it. What we actually know:
+   *   - Bedrock — TESTED (live probes 2026-07-26). opus-5 / fable-5 / opus-4-8 /
+   *     opus-4-7 / opus-4-6 / sonnet-4-6 report 200K bare and need the suffix;
+   *     sonnet-5 is 1M bare.
+   *   - Anthropic first-party — TESTED (live probes 2026-07-26, clean HOME so
+   *     only the API key could authenticate). opus-5 / sonnet-5 / fable-5 /
+   *     opus-4-8 / opus-4-7 are already 1M BARE; only opus-4-6 and sonnet-4-6
+   *     report 200K and need the suffix. Appending to an already-1M model is a
+   *     no-op we confirmed.
+   *   - Vertex — NOT TESTED. No Google Cloud credits, so no probe has run. It is
+   *     included on the strength of Anthropic's documentation, which says the
+   *     same models support 1M there and that a model ID without `[1m]` uses
+   *     200K on Vertex. Documentation, not measurement.
+   *
+   * Present ONLY for models where the selector is necessary on at least one
+   * backend. Models at 1M unsuffixed everywhere (claude-sonnet-5) omit it, as do
+   * models whose declared window is 200K.
+   *
+   * `z.literal` + the surrounding `.strict()` are load-bearing: without them a
+   * misspelled key or value is accepted and silently dropped, which looks
+   * identical to "this model does not need the selector".
+   */
+  claude_cli_context_selector: z2.literal("[1m]").optional(),
+  bedrock: z2.object({
+    base_model_id: z2.string(),
+    global: z2.string().optional(),
+    us: z2.string().optional(),
+    eu: z2.string().optional(),
+    jp: z2.string().optional(),
+    apac: z2.string().optional(),
+    /**
+     * Deprecated location for {@link ModelInfoSchema}'s top-level
+     * `claude_cli_context_selector`. Retained so existing/consumer configs
+     * keep working; new entries declare the top-level field instead.
+     */
+    claude_cli_context_selector: z2.literal("[1m]").optional()
+  }).strict().optional(),
+  thinking: z2.object({
+    supported: z2.boolean().optional(),
+    adaptive: z2.boolean().optional(),
+    budget_tokens_supported: z2.boolean().optional(),
+    min_budget_tokens: z2.number().int().optional(),
+    default_budget_tokens: z2.number().int().optional(),
+    max_budget_tokens: z2.number().int().optional()
+  }).optional(),
+  reasoning_effort_levels: z2.array(z2.string()).optional(),
+  // Templated CLI provider support (Phase 1)
+  canonical_id: z2.string().optional(),
+  // Stable identity for comparisons (e.g., "claude-sonnet-4-5")
+  routing_id: z2.string().optional(),
+  // Actual ID passed to CLI (e.g., "anthropic/claude-sonnet-4-5")
+  notes: z2.string().optional(),
+  deprecation: z2.record(z2.string(), z2.unknown()).optional(),
+  _model_update: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var ModelAccessClassSchema = z2.enum(["first_party_pool", "premium_pool"]);
+var ModelAccessConfigSchema = z2.object({
+  default: ModelAccessClassSchema,
+  overrides: z2.record(z2.string().trim().min(1), ModelAccessClassSchema).default({})
+}).strict();
+var ModelsConfigSchema = z2.object({
+  default: z2.string().trim().min(1),
+  default_reasoning_effort: z2.string().optional(),
+  roles: z2.record(z2.string().trim().min(1), z2.string().trim().min(1)).optional().default({}),
+  allowed_patterns: z2.array(z2.string()),
+  mappings: z2.record(z2.string().trim().min(1), z2.string().trim().min(1)),
+  // Zod v4: explicit key and value schemas
+  available: z2.array(ModelInfoSchema),
+  /**
+   * Admission policy for the exact-model invoke bridge.
+   *
+   * A provider whose `allowed_patterns` deliberately admit bounded future model-id
+   * SYNTAX (so a newly released id works before the catalog is refreshed) accepts ids
+   * that are well-formed but not in `available`. That is correct for ordinary
+   * execution and wrong for an exact pin, where a typo should be rejected before
+   * spawn rather than handed to the CLI.
+   *
+   * Set this on such a provider to make the exact bridge additionally require the
+   * resolved id to be present in the effective inventory. Providers that do not admit
+   * syntax-only ids leave it false and keep their declared resolution contract.
+   *
+   * This is model-resolution admission policy, NOT a runtime CLI quirk, so it belongs
+   * here rather than behind `getProviderRuntimeQuirks()`.
+   */
+  exact_invoke_requires_inventory: z2.boolean().optional().default(false),
+  access: ModelAccessConfigSchema.optional(),
+  discovery: ModelsDiscoverySchema.optional()
+}).strict().superRefine((models, ctx) => {
+  if (!models.access) return;
+  const availableIds = new Set(models.available.map((model) => model.id));
+  for (const modelId of Object.keys(models.access.overrides)) {
+    if (!availableIds.has(modelId)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: `models.access override references unavailable model: ${modelId}`,
+        path: ["access", "overrides", modelId]
+      });
+    }
+  }
+});
+var TemplatedModelsConfigSchema = z2.object({
+  default: z2.string().trim().min(1),
+  default_reasoning_effort: z2.string().optional(),
+  roles: z2.record(z2.string().trim().min(1), z2.string().trim().min(1)).optional().default({}),
+  allowed_patterns: z2.array(z2.string()).default([".*"]),
+  mappings: z2.record(z2.string().trim().min(1), z2.string().trim().min(1)).default({}),
+  available: z2.array(ModelInfoSchema).default([]),
+  /**
+   * See `ModelsConfigSchema.exact_invoke_requires_inventory`. Declared here too so the
+   * flag is readable off the `ProviderConfig` union without narrowing to the native
+   * branch first. It matters at least as much for templated providers, whose
+   * `allowed_patterns` default to `['.*']` and therefore admit any syntax.
+   */
+  exact_invoke_requires_inventory: z2.boolean().optional().default(false),
+  access: ModelAccessConfigSchema.optional(),
+  discovery: ModelsDiscoverySchema.optional()
+}).strict().superRefine((models, ctx) => {
+  if (!models.access) return;
+  const availableIds = new Set(models.available.map((model) => model.id));
+  for (const modelId of Object.keys(models.access.overrides)) {
+    if (!availableIds.has(modelId)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: `models.access override references unavailable model: ${modelId}`,
+        path: ["access", "overrides", modelId]
+      });
+    }
+  }
+});
+var TuiConversationOperationSchema = z2.enum(["start", "load/resume", "prompt", "cancel"]);
+var TuiConversationCapabilityConfigSchema = z2.object({
+  operations: z2.array(TuiConversationOperationSchema).min(1),
+  output: z2.enum(["streaming", "buffered"]),
+  read_only: z2.enum(["enforced", "unproven"]),
+  qualification: z2.enum(["version", "handshake"]).optional()
+}).strict();
+var CapabilitiesConfigSchema = z2.object({
+  streaming: z2.boolean(),
+  tool_use: z2.boolean(),
+  vision: z2.boolean(),
+  function_calling: z2.boolean(),
+  // Provider has some historically tracked subagent-capable behavior.
+  sub_agents: z2.boolean().optional().default(false),
+  // Poetic can invoke provider-native subagents for `run --subagents`.
+  provider_native_subagents: z2.boolean().optional().default(false),
+  // Provider-level execution capabilities (narrow matrix — model-level traits are out of scope)
+  // requires_pty: provider CLI needs a PTY for headless runs
+  requires_pty: z2.boolean().optional(),
+  // owns_rate_limit_token: provider enforces its own rate limit / handles 429 internally
+  owns_rate_limit_token: z2.boolean().optional(),
+  // supports_api_judge: provider has a non-CLI API channel usable by the judge/synthesis path
+  supports_api_judge: z2.boolean().optional(),
+  // supports_tui_agent_actions: provider may propose bounded TUI agent actions
+  supports_tui_agent_actions: z2.boolean().optional(),
+  // supports_ask_consult: provider has a tested read-only one-shot consultation path
+  supports_ask_consult: z2.boolean().optional(),
+  // requires_sandbox_interlock: provider must verify outer sandbox before spawning
+  requires_sandbox_interlock: z2.boolean().optional(),
+  // native_model_fallback: provider CLI supports a native fallback-model flag
+  // (e.g. Claude's --fallback-model). Gates role-candidate `fallbackModelRole`.
+  native_model_fallback: z2.boolean().optional(),
+  // Persistent TUI conversation support is a cohesive adapter contract rather
+  // than a set of independent booleans. Eligibility still requires runtime
+  // readiness, qualification (when declared), and enforced read-only posture.
+  tui_conversation: TuiConversationCapabilityConfigSchema.optional()
+}).strict();
+var TemplatedCapabilitiesConfigSchema = z2.object({
+  streaming: z2.boolean().default(false),
+  tool_use: z2.boolean().default(false),
+  vision: z2.boolean().default(false),
+  function_calling: z2.boolean().default(false),
+  // Provider has some historically tracked subagent-capable behavior.
+  sub_agents: z2.boolean().default(false),
+  // Poetic can invoke provider-native subagents for `run --subagents`.
+  provider_native_subagents: z2.boolean().default(false),
+  // Provider-level execution capabilities (narrow matrix — model-level traits are out of scope)
+  requires_pty: z2.boolean().optional(),
+  owns_rate_limit_token: z2.boolean().optional(),
+  supports_api_judge: z2.boolean().optional(),
+  supports_tui_agent_actions: z2.boolean().optional(),
+  supports_ask_consult: z2.boolean().optional(),
+  requires_sandbox_interlock: z2.boolean().optional(),
+  native_model_fallback: z2.boolean().optional(),
+  tui_conversation: TuiConversationCapabilityConfigSchema.optional()
+}).strict().default({
+  streaming: false,
+  tool_use: false,
+  vision: false,
+  function_calling: false,
+  sub_agents: false,
+  provider_native_subagents: false
+});
+var BotIdentityConfigSchema = z2.object({
+  display_name: z2.string(),
+  usernames: z2.array(z2.string())
+}).strict();
+var EnvConfigSchema = z2.record(z2.string(), z2.string());
+var ModelPricingSchema = z2.object({
+  // Prices may be stored as strings for precision/deterministic diffs (e.g. "3.00").
+  // Normalize to numbers at load time for runtime cost calculation.
+  input_per_1m_tokens: z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional(),
+  output_per_1m_tokens: z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional(),
+  cache_read_per_1m_tokens: z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional(),
+  cache_write_per_1m_tokens: z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional(),
+  input_per_1k_tokens: z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional(),
+  output_per_1k_tokens: z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional(),
+  base_rate_per_1k_tokens: z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional(),
+  premium_multiplier: z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional(),
+  context_window: z2.number().int().optional(),
+  long_context_pricing: LongContextPricingSchema.optional(),
+  features: z2.record(z2.string(), z2.boolean()).optional(),
+  // Telemetry-only placeholder: pricing is intentionally absent and
+  // missing-pricing telemetry errors log at debug instead of warn.
+  non_metered: z2.boolean().optional(),
+  notes: z2.string().optional(),
+  last_updated: DateLikeStringSchema.optional(),
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var ToolPricingSchema = z2.object({
+  cost_per_request: z2.number().min(0).optional(),
+  cost_per_read_1m_tokens: z2.number().min(0).optional(),
+  cost_per_write_1m_tokens: z2.number().min(0).optional(),
+  unit: z2.string().optional(),
+  notes: z2.string().optional(),
+  available_in: z2.array(z2.string()).optional()
+}).strict();
+var SubscriptionPricingSchema = z2.object({
+  monthly_cost: z2.number().min(0).optional(),
+  included_credits: z2.number().min(0).optional(),
+  overage_rate_per_credit: z2.number().min(0).optional(),
+  individual_monthly: z2.number().min(0).optional(),
+  business_monthly_per_user: z2.number().min(0).optional(),
+  enterprise_monthly_per_user: z2.number().min(0).optional()
+}).strict();
+var InfrastructurePricingSchema = z2.object({
+  cloud_execution_per_minute: z2.number().min(0).optional(),
+  premium_execution_per_minute: z2.number().min(0).optional(),
+  proxy_routing_per_request: z2.number().min(0).optional(),
+  notes: z2.string().optional()
+}).strict();
+var ProviderPricingSchema = z2.object({
+  billing_mode: z2.enum(["metered", "subscription", "hybrid"]),
+  currency: z2.string(),
+  last_updated: DateLikeStringSchema.optional(),
+  notes: z2.string().optional(),
+  exchange_rate_note: z2.string().optional(),
+  models: z2.record(z2.string(), ModelPricingSchema).optional(),
+  tools: z2.record(z2.string(), ToolPricingSchema).optional(),
+  subscription: SubscriptionPricingSchema.optional(),
+  infrastructure: InfrastructurePricingSchema.optional(),
+  features: z2.record(z2.string(), z2.unknown()).optional(),
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var RefreshStrategyConfigSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("direct"),
+    // Deterministic models API to poll; absent = doc-poll only (e.g. xAI).
+    models_api: z2.enum(["anthropic", "openai", "google"]).optional(),
+    doc_poll: z2.boolean(),
+    cli_inventory: z2.enum(["cursor", "grok"]).optional()
+  }).strict(),
+  z2.object({ kind: z2.literal("aggregator") }).strict(),
+  z2.object({
+    kind: z2.literal("static"),
+    reason: z2.string().trim().min(1).optional(),
+    cli_inventory: z2.enum(["cursor", "grok"]).optional()
+  }).strict()
+]);
+var DefaultPricingSchema = z2.object({
+  billing_mode: z2.string(),
+  currency: z2.string(),
+  unit: z2.string()
+}).strict();
+var ConcurrencyConfigSchema = z2.object({
+  max: z2.number().int().min(1),
+  hybrid_batching: z2.boolean().optional().default(false),
+  rationale: z2.string().trim().min(1)
+}).strict();
+var RouteConfigSchema = z2.object({
+  // Environment variables to inject (e.g., API keys, endpoints)
+  env: z2.record(z2.string(), z2.string()).optional(),
+  // Auth commands to run before execution.
+  //
+  // SECURITY: Prefer argv form (auth_check_argv/auth_command_argv). String form is
+  // treated as guidance-only and is not executed by Poetic.
+  auth_check: z2.string().optional(),
+  auth_command: z2.string().optional(),
+  auth_clear: z2.string().optional(),
+  auth_check_argv: z2.array(z2.string()).optional(),
+  auth_command_argv: z2.array(z2.string()).optional(),
+  auth_clear_argv: z2.array(z2.string()).optional(),
+  auth_probe: CommandProbeSchema.optional(),
+  // Model ID transform function name (if custom logic needed)
+  model_transform: z2.string().optional()
+}).strict();
+var WorkspaceEditsConfigSchema = z2.object({
+  // Detection mode: 'passthrough' (git-only), 'structured' (JSONL), or 'text-only' (analysis mode)
+  mode: z2.enum(["passthrough", "structured", "text-only"]),
+  // Whether to inject JSONL format instructions into prompts
+  inject_jsonl: z2.boolean().optional(),
+  // Whether to enforce FILE: specification in prompts
+  enforce_file_targets: z2.boolean().optional()
+}).strict();
+var GenerationConfigSchema = z2.object({
+  // Temperature controls output randomness (0.0 = deterministic, 1.0+ = creative)
+  // For code generation, 0.2-0.4 is recommended for more deterministic output
+  temperature: z2.number().min(0).max(2).optional(),
+  // Nucleus sampling threshold (0.0-1.0)
+  top_p: z2.number().min(0).max(1).optional(),
+  // Top-k sampling (limits token choices)
+  top_k: z2.number().int().min(1).optional(),
+  // Maximum output tokens
+  max_output_tokens: z2.number().int().min(1).optional()
+}).strict();
+var TaskSettingsSchema = z2.record(
+  z2.string(),
+  z2.object({
+    temperature: z2.number().min(0).max(2).optional(),
+    top_p: z2.number().min(0).max(1).optional(),
+    top_k: z2.number().int().min(1).optional(),
+    reasoning_effort: z2.preprocess((value) => {
+      if (value === void 0 || value === null) return void 0;
+      const normalized = normalizeReasoningEffortInput(value);
+      return normalized ?? value;
+    }, z2.enum(["low", "medium", "high", "xhigh", "max"]).optional()),
+    thinking_budget: z2.number().int().min(1).optional()
+  }).strict()
+).optional();
+var PluginVerifySchema = z2.object({
+  // Command to run for verification (e.g., "provider-plugin --version")
+  command: z2.string().optional(),
+  // File path that should exist (e.g., "~/.config/plugin/config.json")
+  file: z2.string().optional(),
+  // Pattern to match in command output
+  pattern: z2.string().optional()
+}).strict();
+var PluginConfigureStepSchema = z2.object({
+  // Description of what this step does
+  description: z2.string(),
+  // Command to run (if automated)
+  command: z2.string().optional(),
+  // Manual instructions (if user action required)
+  instructions: z2.string().optional()
+}).strict();
+var RequirementSchema = z2.union([
+  z2.object({ provider: z2.string() }).strict(),
+  z2.object({ plugin: z2.string() }).strict(),
+  z2.object({ binary: z2.string() }).strict()
+]);
+var PluginSchema = z2.object({
+  // Unique identifier (e.g., "provider-plugin")
+  id: z2.string(),
+  // Display name (e.g., "Provider Plugin")
+  name: z2.string(),
+  // Human-readable description
+  description: z2.string(),
+  // Plugin type (free-form: 'auth', 'tools', 'slash', 'agents', etc.)
+  type: z2.string(),
+  // Installation command
+  install_command: z2.string(),
+  // Installation method
+  install_method: z2.enum(["npm", "brew", "pipx", "curl", "manual"]),
+  // Risk level for user confirmation
+  risk_level: z2.enum(["safe", "needs-confirmation"]),
+  // Verification checks
+  verify: PluginVerifySchema.optional(),
+  // Configuration steps (optional)
+  configure: z2.array(PluginConfigureStepSchema).optional(),
+  // Plugin dependencies (optional)
+  requires: z2.array(RequirementSchema).optional()
+}).strict();
+var ProviderOptionSchema = z2.object({
+  // Option type
+  type: z2.enum(["enum", "string", "bool"]),
+  // Allowed values (for enum type)
+  allowed: z2.array(z2.string()).optional(),
+  // Default value
+  default: z2.union([z2.string(), z2.boolean()]),
+  // Description (shown in wizard)
+  description: z2.string()
+}).strict();
+var ProviderOptionsSchema = z2.record(z2.string(), ProviderOptionSchema);
+var ConditionalRequiresSchema = z2.record(z2.string(), z2.array(RequirementSchema));
+var ProviderRequiresSchema = z2.object({
+  // Always-required dependencies
+  requires: z2.array(RequirementSchema).optional(),
+  // Conditionally-required dependencies based on option values
+  requires_if: ConditionalRequiresSchema.optional()
+}).strict();
+var ApiConfigSchema = z2.object({
+  /** API base URL (host only, e.g., "https://api.anthropic.com"). */
+  base_url: z2.url(),
+  /** Environment variable name containing the API key. */
+  api_key_env_var: z2.string(),
+  /** Whether to use streaming responses (default: true). */
+  stream: z2.boolean().optional().default(true),
+  /** Additional HTTP headers to send with requests. */
+  headers: z2.record(z2.string(), z2.string()).optional(),
+  /** Max output tokens per API call. */
+  max_tokens: z2.number().int().positive().optional(),
+  /** Max tool-use iterations in the agentic loop (default: 50). */
+  max_tool_iterations: z2.number().int().min(1).max(200).optional().default(50),
+  /** Timeout per individual tool execution in ms (default: 30000). */
+  per_tool_timeout_ms: z2.number().int().min(1e3).optional().default(3e4)
+}).strict().optional();
+var TemplatedCLIExecutionSchema = z2.object({
+  // Base command arguments (before prompt)
+  args: z2.array(z2.string()),
+  // Command-line flags (e.g., {"--quiet": true, "--cwd": "{{workspace}}"})
+  flags: z2.record(z2.string(), z2.union([z2.boolean(), z2.string()])).optional(),
+  // Prompt placement: 'positional' (in args array) or 'stdin'
+  prompt_placement: z2.enum(["positional", "stdin"]),
+  // Whether to add "--" before the prompt when using positional prompt placement.
+  // Defaults to true (safer); set false for CLIs that don't support "--".
+  double_dash_before_prompt: z2.boolean().optional(),
+  // Whether stdin is supported as fallback
+  stdin_fallback: z2.boolean().optional(),
+  // Template variables available for interpolation
+  // (e.g., {{prompt}}, {{model.routing_id}}, {{workspace}})
+  template_vars: z2.array(z2.string()).optional()
+}).strict();
+var NativeProviderConfigSchema = z2.object({
+  // Basic metadata
+  id: z2.string(),
+  name: z2.string(),
+  display_name: z2.string(),
+  description: z2.string(),
+  vendor: z2.string(),
+  enabled: z2.boolean(),
+  experimental: z2.boolean(),
+  release_status: ProviderReleaseStatusSchema.optional(),
+  order: z2.number().int(),
+  // Provider type and transport
+  type: z2.enum(["cli", "api", "cloud_cli", "cli_wrapper"]),
+  transport: z2.enum(["cli", "api", "hybrid"]),
+  channels: z2.array(z2.string()),
+  // CLI configuration
+  cli: CLIConfigSchema,
+  // API transport configuration (optional, for direct API inference)
+  api: ApiConfigSchema,
+  // Authentication
+  auth: AuthConfigSchema,
+  // Models
+  models: ModelsConfigSchema,
+  // Capabilities
+  capabilities: CapabilitiesConfigSchema,
+  // Performance
+  concurrency_hint: z2.enum(["low", "medium", "high"]),
+  concurrency: ConcurrencyConfigSchema.optional(),
+  // Timeouts
+  timeout_ms: z2.number().int().min(1),
+  health_check_timeout_ms: z2.number().int().min(1).optional(),
+  // Memory management
+  memory: MemoryConfigSchema,
+  // Polling (optional, for cloud providers)
+  polling: PollingConfigSchema.optional(),
+  // Bot identity (optional, for cloud providers)
+  bot_identity: BotIdentityConfigSchema.optional(),
+  // Environment variables
+  env: EnvConfigSchema,
+  // Retry and circuit breaker (optional overrides)
+  retry: RetryConfigSchema.optional(),
+  circuit_breaker: CircuitBreakerConfigSchema.optional(),
+  // Rate limits (optional overrides, new in v2.1)
+  rate_limits: RateLimitsConfigSchema.optional(),
+  // Pricing (optional, new in v2.0)
+  pricing: ProviderPricingSchema.optional(),
+  // Refresh strategy for `poetic provider refresh` (optional; providers
+  // without a declaration are treated as static by the refresh dispatcher).
+  refresh_strategy: RefreshStrategyConfigSchema.optional(),
+  // Engine type. 'templated_cli' is DEPRECATED: the templated CLI engine was
+  // removed (2026-06) and providers declaring it are no longer registered —
+  // the registry emits a TMPL-001 warning instead. The value stays in the
+  // schema only so user overlays still validate and the project-config
+  // trust-gating security checks below keep rejecting untrusted templated
+  // providers explicitly rather than failing on an unknown enum value.
+  engine: z2.enum(["native", "templated_cli"]).optional().default("native"),
+  // Templated CLI execution config (deprecated with engine=templated_cli)
+  exec: TemplatedCLIExecutionSchema.optional(),
+  // Route configuration (for model ID transforms and env injection)
+  route_id: z2.string().optional(),
+  // Reference to named route (future: top-level routes: section)
+  route: RouteConfigSchema.optional(),
+  // Inline route override
+  // Workspace edit detection strategy
+  workspace_edits: WorkspaceEditsConfigSchema.optional(),
+  // Generation parameters (temperature, topP, etc.)
+  generation: GenerationConfigSchema.optional(),
+  // Task-type-aware generation settings (overrides generation defaults)
+  task_settings: TaskSettingsSchema,
+  // Binary allowlist for security (only used if engine=templated_cli)
+  allow_unsafe_binary: z2.boolean().optional().default(false),
+  // Explicit opt-in for non-allowlisted binaries
+  // Plugin system (generic, any provider)
+  plugins: z2.array(PluginSchema).optional(),
+  // Provider options (generic, any provider)
+  options: ProviderOptionsSchema.optional(),
+  // Dependency management (generic, any provider)
+  requires: z2.array(RequirementSchema).optional(),
+  requires_if: ConditionalRequiresSchema.optional()
+}).strict();
+var TemplatedProviderConfigSchema = z2.object({
+  // Basic metadata
+  id: z2.string(),
+  name: z2.string(),
+  display_name: z2.string().optional().default(""),
+  description: z2.string().optional().default(""),
+  vendor: z2.string().optional().default("custom"),
+  enabled: z2.boolean().optional().default(true),
+  experimental: z2.boolean().optional().default(false),
+  release_status: ProviderReleaseStatusSchema.optional(),
+  order: z2.number().int().optional().default(99),
+  // Provider type and transport
+  type: z2.enum(["cli", "api", "cloud_cli", "cli_wrapper"]).optional().default("cli_wrapper"),
+  transport: z2.enum(["cli", "api", "hybrid"]).optional().default("cli"),
+  channels: z2.array(z2.string()).optional().default(["cli"]),
+  // CLI configuration
+  cli: CLIConfigSchema,
+  // API transport configuration (optional, for direct API inference)
+  api: ApiConfigSchema,
+  // Authentication
+  auth: TemplatedAuthConfigSchema,
+  // Models
+  models: TemplatedModelsConfigSchema,
+  // Capabilities
+  capabilities: TemplatedCapabilitiesConfigSchema,
+  // Performance
+  concurrency_hint: z2.enum(["low", "medium", "high"]).optional().default("low"),
+  concurrency: ConcurrencyConfigSchema.optional(),
+  // Timeouts
+  timeout_ms: z2.number().int().min(1).optional().default(6e5),
+  health_check_timeout_ms: z2.number().int().min(1).optional(),
+  // Memory management
+  memory: MemoryConfigSchema.default({
+    warn_threshold: 0.85,
+    critical_threshold: 0.9,
+    emergency_threshold: 0.95,
+    max_processes: 3
+  }),
+  // Polling (optional, for cloud providers)
+  polling: PollingConfigSchema.optional(),
+  // Bot identity (optional, for cloud providers)
+  bot_identity: BotIdentityConfigSchema.optional(),
+  // Environment variables
+  env: EnvConfigSchema.default({}),
+  // Retry and circuit breaker (optional overrides)
+  retry: RetryConfigSchema.optional(),
+  circuit_breaker: CircuitBreakerConfigSchema.optional(),
+  // Rate limits (optional overrides)
+  rate_limits: RateLimitsConfigSchema.optional(),
+  // Pricing (optional)
+  pricing: ProviderPricingSchema.optional(),
+  // Engine selection (templated)
+  engine: z2.literal("templated_cli"),
+  // Templated CLI execution config (required)
+  exec: TemplatedCLIExecutionSchema,
+  // Route configuration (optional)
+  route_id: z2.string().optional(),
+  route: RouteConfigSchema.optional(),
+  // Workspace edit detection strategy (optional)
+  workspace_edits: WorkspaceEditsConfigSchema.optional(),
+  // Generation parameters (temperature, topP, etc.)
+  generation: GenerationConfigSchema.optional(),
+  // Task-type-aware generation settings (overrides generation defaults)
+  task_settings: TaskSettingsSchema,
+  // Binary allowlist override
+  allow_unsafe_binary: z2.boolean().optional().default(false),
+  // Plugin system (generic, any provider)
+  plugins: z2.array(PluginSchema).optional(),
+  // Provider options (generic, any provider)
+  options: ProviderOptionsSchema.optional(),
+  // Dependency management (generic, any provider)
+  requires: z2.array(RequirementSchema).optional(),
+  requires_if: ConditionalRequiresSchema.optional()
+}).strict().transform((provider) => ({
+  ...provider,
+  display_name: provider.display_name?.trim() ? provider.display_name : provider.name,
+  description: provider.description ?? ""
+}));
+var ProviderConfigSchema = z2.union([
+  TemplatedProviderConfigSchema,
+  NativeProviderConfigSchema
+]);
+var DefaultsConfigSchema = z2.object({
+  timeout_ms: z2.number().int().min(1),
+  retry: RetryConfigSchema,
+  circuit_breaker: CircuitBreakerConfigSchema,
+  rate_limits: RateLimitsConfigSchema.optional(),
+  memory: MemoryConfigSchema,
+  polling: PollingConfigSchema,
+  pricing: DefaultPricingSchema.optional()
+}).strict();
+var MetadataConfigSchema = z2.object({
+  schema_version: z2.string(),
+  generated_at: DateLikeStringSchema,
+  description: z2.string(),
+  documentation: z2.string(),
+  migration_notes: z2.string().optional(),
+  last_updated: DateLikeStringSchema.optional()
+}).strict();
+var ProviderRegistryConfigSchema = z2.object({
+  version: z2.string(),
+  defaults: DefaultsConfigSchema,
+  guidance_profiles: z2.record(z2.string(), z2.unknown()).optional(),
+  judge: z2.record(z2.string(), z2.unknown()).optional(),
+  providers: z2.record(z2.string(), ProviderConfigSchema),
+  metadata: MetadataConfigSchema
+}).strict();
+function cloneProviderRegistryValue(value) {
+  return structuredClone(value);
+}
+function verifySchemaDefinitions() {
+  const schemas = {
+    RetryConfigSchema,
+    CircuitBreakerConfigSchema,
+    MemoryConfigSchema,
+    PollingConfigSchema,
+    CLIConfigSchema,
+    AuthConfigSchema,
+    ModelInfoSchema,
+    ModelsConfigSchema,
+    TuiConversationCapabilityConfigSchema,
+    CapabilitiesConfigSchema,
+    BotIdentityConfigSchema,
+    EnvConfigSchema,
+    ModelPricingSchema,
+    ToolPricingSchema,
+    SubscriptionPricingSchema,
+    InfrastructurePricingSchema,
+    ProviderPricingSchema,
+    DefaultPricingSchema,
+    PluginVerifySchema,
+    PluginConfigureStepSchema,
+    RequirementSchema,
+    PluginSchema,
+    ProviderOptionSchema,
+    ProviderOptionsSchema,
+    ConditionalRequiresSchema,
+    ProviderRequiresSchema,
+    ProviderConfigSchema,
+    DefaultsConfigSchema,
+    MetadataConfigSchema,
+    ProviderRegistryConfigSchema
+  };
+  for (const [name, schema] of Object.entries(schemas)) {
+    if (!schema || !("_zod" in schema)) {
+      throw new Error(
+        `Schema ${name} is undefined or invalid. This indicates a schema definition error. Check that all nested schemas in ${name} are properly defined. Common issue: Zod v4 requires z.record(keySchema, valueSchema) with explicit parameters.`
+      );
+    }
+  }
+}
+verifySchemaDefinitions();
+var ProviderRegistry = class _ProviderRegistry {
+  static instance = null;
+  static configPath = null;
+  static configSources = [];
+  static cacheKey = null;
+  static cacheMode = null;
+  static cacheProjectRoot = null;
+  constructor() {
+  }
+  static replaceCachedRegistry(config, configPath, cacheKey, cacheMode, projectRoot, configSources = [configPath]) {
+    const replacedExistingCache = _ProviderRegistry.instance !== null && (_ProviderRegistry.configPath !== configPath || _ProviderRegistry.cacheKey !== cacheKey || _ProviderRegistry.cacheMode !== cacheMode);
+    _ProviderRegistry.instance = config;
+    _ProviderRegistry.configPath = configPath;
+    _ProviderRegistry.configSources = [...configSources];
+    _ProviderRegistry.cacheKey = cacheKey;
+    _ProviderRegistry.cacheMode = cacheMode;
+    _ProviderRegistry.cacheProjectRoot = projectRoot;
+    if (replacedExistingCache) {
+      runProviderRegistryReloadInvalidators();
+    }
+    return config;
+  }
+  /**
+   * Load the unified provider registry from YAML
+   *
+   * @param configPath - Path to providers.yaml (defaults to .poetic/config/providers.yaml)
+   * @returns Validated and merged configuration
+   */
+  static load(configPath, cwd = process.cwd()) {
+    const projectRoot = findProjectRoot(cwd) ?? cwd;
+    configPath = configPath ? resolve3(projectRoot, configPath) : void 0;
+    const envCacheKey = _ProviderRegistry.buildEnvOverrideCacheKey();
+    const requestedCacheKey = _ProviderRegistry.buildCacheKey(configPath, envCacheKey, projectRoot);
+    if (_ProviderRegistry.instance && (_ProviderRegistry.cacheKey === requestedCacheKey || !configPath && _ProviderRegistry.cacheMode === "explicit" && _ProviderRegistry.configPath !== null && _ProviderRegistry.canReuseExplicitCacheForImplicit(
+      _ProviderRegistry.configPath,
+      projectRoot
+    ) && _ProviderRegistry.cacheKey === _ProviderRegistry.buildCacheKey(_ProviderRegistry.configPath, envCacheKey, projectRoot))) {
+      return _ProviderRegistry.instance;
+    }
+    const embeddedConfigPaths = getEmbeddedProviderConfigPaths();
+    const isTrustedProjectForTemplatedProviders = () => isTrustedProjectRoot(projectRoot);
+    const projectTrustInstruction = formatProjectTrustInstruction(projectRoot);
+    const loadYamlRawIfExists = (filePath) => {
+      if (!existsSync2(filePath)) return null;
+      try {
+        const rawYaml = readFileSync2(filePath, "utf-8");
+        return yaml.load(rawYaml);
+      } catch (error) {
+        throw new Error(
+          `Failed to load YAML at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    };
+    const loadEmbeddedRaw = () => {
+      for (const embeddedConfigPath of embeddedConfigPaths) {
+        if (!existsSync2(embeddedConfigPath)) continue;
+        try {
+          const bytes = readFileSync2(embeddedConfigPath);
+          if (embeddedConfigPath.endsWith("catalog.json")) {
+            const digest2 = createHash2("sha256").update(bytes).digest("hex");
+            if (digest2 !== PROVIDER_CATALOG_SHA256) {
+              throw new Error(
+                `Provider catalog digest mismatch: expected ${PROVIDER_CATALOG_SHA256}, received ${digest2}`
+              );
+            }
+          }
+          const raw = yaml.load(bytes.toString("utf8"));
+          if (!raw) continue;
+          return { path: embeddedConfigPath, raw };
+        } catch (error) {
+          throw new Error(
+            `Failed to load packaged provider catalog at ${embeddedConfigPath}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      return null;
+    };
+    const deepMerge = (base, overlay) => {
+      if (!overlay || typeof overlay !== "object") return base;
+      if (!base || typeof base !== "object") return overlay;
+      const baseObj = base;
+      const overlayObj = overlay;
+      const out = { ...baseObj };
+      for (const [key, overlayValue] of Object.entries(overlayObj)) {
+        const baseValue = baseObj[key];
+        if (key === "providers" && overlayValue && typeof overlayValue === "object" && !Array.isArray(overlayValue)) {
+          const existingProviders = baseValue && typeof baseValue === "object" && !Array.isArray(baseValue) ? baseValue : {};
+          const overlayProviders = overlayValue;
+          const mergedProviders = { ...existingProviders };
+          for (const [providerId, providerOverlay] of Object.entries(overlayProviders)) {
+            const existingProvider = existingProviders[providerId];
+            if (existingProvider && typeof existingProvider === "object" && !Array.isArray(existingProvider) && providerOverlay && typeof providerOverlay === "object" && !Array.isArray(providerOverlay)) {
+              mergedProviders[providerId] = deepMerge(existingProvider, providerOverlay);
+            } else {
+              mergedProviders[providerId] = providerOverlay;
+            }
+          }
+          out.providers = mergedProviders;
+          continue;
+        }
+        if (overlayValue && typeof overlayValue === "object" && !Array.isArray(overlayValue) && !(overlayValue instanceof Date) && baseValue && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date)) {
+          out[key] = deepMerge(baseValue, overlayValue);
+          continue;
+        }
+        out[key] = overlayValue;
+      }
+      return out;
+    };
+    const isFullRegistrySnapshot = (raw, base) => {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return false;
+      if (!base || typeof base !== "object" || Array.isArray(base)) return false;
+      const rawObject = raw;
+      const baseObject = base;
+      const rawProviders = rawObject.providers;
+      const baseProviders = baseObject.providers;
+      if (!rawProviders || typeof rawProviders !== "object" || Array.isArray(rawProviders) || !baseProviders || typeof baseProviders !== "object" || Array.isArray(baseProviders)) {
+        return false;
+      }
+      return "version" in rawObject && "defaults" in rawObject && "metadata" in rawObject && Object.keys(rawProviders).length > 0;
+    };
+    const migrateLegacyFullSnapshotOverlay = (raw, base) => {
+      if (!isFullRegistrySnapshot(raw, base)) return raw;
+      const migrated = cloneProviderRegistryValue(raw);
+      const migratedProviders = migrated.providers;
+      const baseProviders = base.providers;
+      for (const [providerId, providerValue] of Object.entries(migratedProviders)) {
+        const baseProviderValue = baseProviders[providerId];
+        if (!baseProviderValue || typeof baseProviderValue !== "object" || Array.isArray(baseProviderValue)) {
+          continue;
+        }
+        if (!providerValue || typeof providerValue !== "object" || Array.isArray(providerValue)) {
+          continue;
+        }
+        const provider = providerValue;
+        const modelsValue = provider.models;
+        const baseModelsValue = baseProviderValue.models;
+        if (!modelsValue || typeof modelsValue !== "object" || Array.isArray(modelsValue)) {
+          continue;
+        }
+        if (!baseModelsValue || typeof baseModelsValue !== "object" || Array.isArray(baseModelsValue)) {
+          continue;
+        }
+        const models = modelsValue;
+        const baseModels = baseModelsValue;
+        if (Array.isArray(baseModels.available) && Array.isArray(models.available)) {
+          const availableById = /* @__PURE__ */ new Map();
+          const combinedAvailable = [...baseModels.available, ...models.available];
+          if (combinedAvailable.every(
+            (entry) => entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.id === "string"
+          )) {
+            for (const entry of combinedAvailable) {
+              availableById.set(entry.id, entry);
+            }
+            models.available = [...availableById.values()];
+          }
+        }
+        if (Array.isArray(baseModels.allowed_patterns) && Array.isArray(models.allowed_patterns) && [...baseModels.allowed_patterns, ...models.allowed_patterns].every(
+          (pattern) => typeof pattern === "string"
+        )) {
+          models.allowed_patterns = [
+            .../* @__PURE__ */ new Set([...baseModels.allowed_patterns, ...models.allowed_patterns])
+          ];
+        }
+        for (const key of ["mappings", "roles"]) {
+          const baseRecord = baseModels[key];
+          const overlayRecord = models[key];
+          if (baseRecord && typeof baseRecord === "object" && !Array.isArray(baseRecord) && overlayRecord && typeof overlayRecord === "object" && !Array.isArray(overlayRecord)) {
+            models[key] = {
+              ...baseRecord,
+              ...overlayRecord
+            };
+          }
+        }
+      }
+      return migrated;
+    };
+    const mergeUserAvailableModels = (raw, base) => {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+      if (!base || typeof base !== "object" || Array.isArray(base)) return raw;
+      const projected = cloneProviderRegistryValue(raw);
+      const projectedProviders = projected.providers;
+      const baseProviders = base.providers;
+      if (!projectedProviders || typeof projectedProviders !== "object" || Array.isArray(projectedProviders) || !baseProviders || typeof baseProviders !== "object" || Array.isArray(baseProviders)) {
+        return projected;
+      }
+      for (const [providerId, providerValue] of Object.entries(
+        projectedProviders
+      )) {
+        const baseProviderValue = baseProviders[providerId];
+        if (!providerValue || typeof providerValue !== "object" || Array.isArray(providerValue) || !baseProviderValue || typeof baseProviderValue !== "object" || Array.isArray(baseProviderValue)) {
+          continue;
+        }
+        const models = providerValue.models;
+        const baseModels = baseProviderValue.models;
+        if (!models || typeof models !== "object" || Array.isArray(models) || !baseModels || typeof baseModels !== "object" || Array.isArray(baseModels)) {
+          continue;
+        }
+        const userAvailable = models.available;
+        const baseAvailable = baseModels.available;
+        if (!Array.isArray(userAvailable) || !Array.isArray(baseAvailable)) continue;
+        const combined = [...baseAvailable, ...userAvailable];
+        if (!combined.every(
+          (entry) => entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.id === "string"
+        )) {
+          continue;
+        }
+        const availableById = /* @__PURE__ */ new Map();
+        for (const entry of combined) {
+          const entryObject = entry;
+          const id = entryObject.id;
+          const existing = availableById.get(id);
+          availableById.set(
+            id,
+            existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing, ...entryObject } : entry
+          );
+        }
+        models.available = [...availableById.values()];
+      }
+      return projected;
+    };
+    const listTemplatedProviderIds = (raw) => {
+      if (!raw || typeof raw !== "object") return [];
+      const providers = raw.providers;
+      if (!providers || typeof providers !== "object") return [];
+      const templated = [];
+      for (const [id, value] of Object.entries(providers)) {
+        if (!value || typeof value !== "object") continue;
+        const engine = value.engine;
+        if (engine === "templated_cli") {
+          templated.push(id);
+        }
+      }
+      return templated;
+    };
+    const getRawProvider = (raw, providerId) => {
+      if (!raw || typeof raw !== "object") return void 0;
+      const providers = raw.providers;
+      if (!providers || typeof providers !== "object") return void 0;
+      return providers[providerId];
+    };
+    const stableJson = (value) => {
+      if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(",")}]`;
+      }
+      if (value && typeof value === "object") {
+        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+      }
+      return JSON.stringify(value);
+    };
+    const normalizeProviderForTrustComparison = (providerId, provider) => {
+      try {
+        return ProviderConfigSchema.parse(provider);
+      } catch (error) {
+        debugLog(
+          `[provider-registry] Failed to normalize templated provider "${providerId}" for trust comparison`,
+          error instanceof Error ? error.message : String(error)
+        );
+        return provider;
+      }
+    };
+    const listUntrustedTemplatedProviderIds = (raw, trustedRaw) => listTemplatedProviderIds(raw).filter((providerId) => {
+      const candidate = getRawProvider(raw, providerId);
+      const trusted = getRawProvider(trustedRaw, providerId);
+      return !trusted || stableJson(normalizeProviderForTrustComparison(providerId, candidate)) !== stableJson(normalizeProviderForTrustComparison(providerId, trusted));
+    });
+    const listUntrustedExecutionFieldChanges = (raw, trustedRaw) => {
+      if (!raw || typeof raw !== "object") return [];
+      const providers = raw.providers;
+      if (!providers || typeof providers !== "object" || Array.isArray(providers)) return [];
+      const changes = [];
+      for (const [providerId, candidate] of Object.entries(providers)) {
+        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+        const candidateProvider = candidate;
+        const trusted = getRawProvider(trustedRaw, providerId);
+        const trustedProvider = trusted && typeof trusted === "object" && !Array.isArray(trusted) ? trusted : null;
+        if (!trustedProvider) {
+          const declaredFields = EXECUTION_SENSITIVE_PROVIDER_FIELDS.filter(
+            (field) => candidateProvider[field] !== void 0
+          );
+          if (declaredFields.length > 0) {
+            changes.push({ providerId, fields: [...declaredFields] });
+          }
+          continue;
+        }
+        const effective = normalizeProviderForTrustComparison(
+          providerId,
+          deepMerge(trustedProvider, candidateProvider)
+        );
+        const baseline = normalizeProviderForTrustComparison(providerId, trustedProvider);
+        const changedFields = EXECUTION_SENSITIVE_PROVIDER_FIELDS.filter((field) => {
+          if (candidateProvider[field] === void 0) return false;
+          return stableJson(effective?.[field]) !== stableJson(baseline?.[field]);
+        });
+        if (changedFields.length > 0) {
+          changes.push({ providerId, fields: [...changedFields] });
+        }
+      }
+      return changes;
+    };
+    const listUntrustedApiIdentityChanges = (projectRaw, effectiveRaw, trustedRaw) => {
+      if (!projectRaw || typeof projectRaw !== "object" || Array.isArray(projectRaw)) return [];
+      const projectProviders = projectRaw.providers;
+      if (!projectProviders || typeof projectProviders !== "object" || Array.isArray(projectProviders)) {
+        return [];
+      }
+      const changes = [];
+      for (const [providerId, projectValue] of Object.entries(
+        projectProviders
+      )) {
+        if (!projectValue || typeof projectValue !== "object" || Array.isArray(projectValue)) {
+          continue;
+        }
+        const projectProvider = projectValue;
+        const effectiveProviderValue = getRawProvider(effectiveRaw, providerId);
+        const trustedProviderValue = getRawProvider(trustedRaw, providerId);
+        if (!effectiveProviderValue || typeof effectiveProviderValue !== "object" || Array.isArray(effectiveProviderValue)) {
+          continue;
+        }
+        const effectiveProvider = effectiveProviderValue;
+        const trustedProvider = trustedProviderValue && typeof trustedProviderValue === "object" && !Array.isArray(trustedProviderValue) ? trustedProviderValue : {};
+        const effectiveApi = effectiveProvider.api && typeof effectiveProvider.api === "object" && !Array.isArray(effectiveProvider.api) ? effectiveProvider.api : {};
+        const trustedApi = trustedProvider.api && typeof trustedProvider.api === "object" && !Array.isArray(trustedProvider.api) ? trustedProvider.api : {};
+        const projectApi = projectProvider.api && typeof projectProvider.api === "object" && !Array.isArray(projectProvider.api) ? projectProvider.api : {};
+        const effectiveChannels = Array.isArray(effectiveProvider.channels) ? effectiveProvider.channels : [];
+        const apiCanRun = effectiveProvider.transport === "api" || effectiveChannels.includes("api");
+        if (!apiCanRun) continue;
+        const fields = [];
+        if (projectProvider.transport !== void 0 && effectiveProvider.transport === "api" && trustedProvider.transport !== "api") {
+          fields.push("transport");
+        }
+        for (const field of ["base_url", "api_key_env_var"]) {
+          if (projectApi[field] !== void 0 && stableJson(effectiveApi[field]) !== stableJson(trustedApi[field])) {
+            fields.push(`api.${field}`);
+          }
+        }
+        if (fields.length > 0) {
+          changes.push({ providerId, fields });
+        }
+      }
+      return changes;
+    };
+    const describeExecutionFieldChanges = (changes) => changes.map(({ providerId, fields }) => `${providerId} (${fields.join(", ")})`).join(", ");
+    const buildUntrustedExecutionFieldError = (changes, root) => new Error(
+      `Security: Project config changes provider execution fields (${describeExecutionFieldChanges(changes)}) which are not allowed unless POETIC_TRUST_PROJECT_PROVIDER_TEMPLATES names this canonical project root.
+
+These fields can select the binary Poetic executes or installs, or redirect a credentialed API request, so a cloned repo could otherwise redirect a built-in provider to attacker-controlled code or infrastructure:
+  - User config: ${getUserProviderRegistryPaths(root)[0]}
+  - Project config: .poetic/config/providers.yaml (requires explicit trust)
+
+Providers are trusted only when their normalized execution config matches the embedded template.
+
+To trust only this project, run:
+` + projectTrustInstruction
+    );
+    const isAutoLoadedProjectRegistryPath = (candidatePath, root) => [
+      resolveProvidersConfigPath({ cwd: root }),
+      resolve3(root, ".poetic", "config", "provider-registry.yaml.v1.backup")
+    ].some((registryPath) => resolve3(registryPath) === resolve3(candidatePath));
+    const embedded = loadEmbeddedRaw();
+    if (!embedded) {
+      throw new Error("Failed to load the provider catalog. Run the provider generator and retry.");
+    }
+    if (configPath) {
+      const pathValidation = validateConfigPath(configPath, projectRoot, { allowTempDir: false });
+      if (!pathValidation.isValid) {
+        throw new Error(
+          `Security Error: Invalid config path "${configPath}": ${pathValidation.reason}. Risk level: ${pathValidation.riskLevel}`
+        );
+      }
+      const raw = loadYamlRawIfExists(pathValidation.normalizedPath);
+      if (!raw) {
+        throw new Error(
+          `Failed to read unified provider config at ${pathValidation.normalizedPath}`
+        );
+      }
+      const templatedProviders = listUntrustedTemplatedProviderIds(raw, embedded.raw);
+      const projectPoeticDir = resolve3(projectRoot, ".poetic");
+      const isProjectConfig = pathValidation.normalizedPath.startsWith(projectPoeticDir + sep);
+      if (isProjectConfig && templatedProviders.length > 0 && !isTrustedProjectForTemplatedProviders()) {
+        throw new Error(
+          `Security: Project config contains templated_cli providers (${templatedProviders.join(", ")}) which are not allowed unless POETIC_TRUST_PROJECT_PROVIDER_TEMPLATES names this canonical project root.
+
+Templated CLI providers execute external binaries and should normally be configured in user scope:
+  - User config: ${getUserProviderRegistryPaths(projectRoot)[0]}
+  - Project config: .poetic/config/providers.yaml (requires explicit trust)
+
+Built-in templated providers are trusted only when their normalized config matches the embedded template.
+
+To trust only this project, run:
+` + projectTrustInstruction
+        );
+      }
+      if (isProjectConfig && isAutoLoadedProjectRegistryPath(pathValidation.normalizedPath, projectRoot) && !isTrustedProjectForTemplatedProviders()) {
+        const executionFieldChanges = listUntrustedExecutionFieldChanges(raw, embedded.raw);
+        if (executionFieldChanges.length > 0) {
+          throw buildUntrustedExecutionFieldError(executionFieldChanges, projectRoot);
+        }
+      }
+      if (isProjectConfig && isAutoLoadedProjectRegistryPath(pathValidation.normalizedPath, projectRoot) && !isTrustedProjectForTemplatedProviders()) {
+        const apiIdentityChanges = listUntrustedApiIdentityChanges(raw, raw, embedded.raw);
+        if (apiIdentityChanges.length > 0) {
+          throw buildUntrustedExecutionFieldError(apiIdentityChanges, projectRoot);
+        }
+      }
+      const withEnvOverrides2 = _ProviderRegistry.applyEnvOverrides(
+        dropRemovedBuiltinProviders(ensureCursorIdSyntaxAdmissionPattern(raw))
+      );
+      const validated2 = _ProviderRegistry.parseRegistryConfig(withEnvOverrides2);
+      return _ProviderRegistry.replaceCachedRegistry(
+        validated2,
+        pathValidation.normalizedPath,
+        requestedCacheKey,
+        "explicit",
+        projectRoot,
+        [pathValidation.normalizedPath]
+      );
+    }
+    let mergedRaw = embedded.raw;
+    const overlayPath = resolve3(
+      projectRoot,
+      ".poetic",
+      "cache",
+      "model-update",
+      "refresh-overlay.json"
+    );
+    let appliedOverlayPath;
+    if (existsSync2(overlayPath)) {
+      const disposition = resolveRefreshOverlayDisposition(readFileSync2(overlayPath, "utf8"), {
+        expectedBaseCatalogDigest: PROVIDER_CATALOG_SHA256
+      });
+      if (disposition.status === "ready") {
+        mergedRaw = applyRefreshOverlay(mergedRaw, disposition.overlay);
+        appliedOverlayPath = overlayPath;
+      } else if (disposition.status !== "absent") {
+        debugLog(
+          disposition.status === "degraded" ? disposition.warning : `Refresh overlay ignored: ${disposition.error}`
+        );
+      }
+    }
+    let securityMergedRaw = mergedRaw;
+    let trustedMergedRaw = mergedRaw;
+    let loadedProjectRaw = null;
+    const loadedConfigSources = [
+      embedded.path,
+      ...appliedOverlayPath ? [appliedOverlayPath] : []
+    ];
+    const projectConfigV2 = resolveProvidersConfigPath({ cwd: projectRoot });
+    const projectConfigV1 = resolve3(
+      projectRoot,
+      ".poetic",
+      "config",
+      "provider-registry.yaml.v1.backup"
+    );
+    const discoveredProjectConfigPath = existsSync2(projectConfigV2) ? projectConfigV2 : existsSync2(projectConfigV1) ? projectConfigV1 : null;
+    const projectConfigPath = discoveredProjectConfigPath && resolve3(discoveredProjectConfigPath) !== resolve3(embedded.path) ? discoveredProjectConfigPath : null;
+    let loadedConfigPath = embedded.path;
+    if (projectConfigPath) {
+      const configParentDir = resolve3(projectRoot, ".poetic", "config");
+      if (!existsSync2(configParentDir)) {
+        throw new Error(
+          `Poetic not initialized: directory '${configParentDir}' does not exist.
+Run 'poetic init' to initialize Poetic in this project.`
+        );
+      }
+      const pathValidation = validateConfigPath(projectConfigPath, projectRoot, {
+        allowTempDir: false
+      });
+      if (!pathValidation.isValid) {
+        throw new Error(
+          `Security Error: Invalid config path "${projectConfigPath}": ${pathValidation.reason}. Risk level: ${pathValidation.riskLevel}`
+        );
+      }
+      const projectRaw = loadYamlRawIfExists(pathValidation.normalizedPath);
+      if (!projectRaw) {
+        throw new Error(
+          `Failed to read unified provider config at ${pathValidation.normalizedPath}`
+        );
+      }
+      loadedProjectRaw = projectRaw;
+      const templatedProviders = listUntrustedTemplatedProviderIds(projectRaw, embedded.raw);
+      if (templatedProviders.length > 0 && !isTrustedProjectForTemplatedProviders()) {
+        throw new Error(
+          `Security: Project config contains templated_cli providers (${templatedProviders.join(", ")}) which are not allowed unless POETIC_TRUST_PROJECT_PROVIDER_TEMPLATES names this canonical project root.
+
+Templated CLI providers execute external binaries and should normally be configured in user scope:
+  - User config: ${getUserProviderRegistryPaths(projectRoot)[0]}
+  - Project config: .poetic/config/providers.yaml (requires explicit trust)
+
+Built-in templated providers are trusted only when their normalized config matches the embedded template.
+
+To trust only this project, run:
+` + projectTrustInstruction
+        );
+      }
+      const projectIsTrusted = isTrustedProjectForTemplatedProviders();
+      securityMergedRaw = deepMerge(securityMergedRaw, projectRaw);
+      if (!projectIsTrusted) {
+        const executionFieldChanges = listUntrustedExecutionFieldChanges(projectRaw, embedded.raw);
+        if (executionFieldChanges.length > 0) {
+          throw buildUntrustedExecutionFieldError(executionFieldChanges, projectRoot);
+        }
+      }
+      const projectedProjectRaw = projectProjectRegistryPolicy(projectRaw, embedded.raw, {
+        trusted: projectIsTrusted
+      });
+      mergedRaw = deepMerge(mergedRaw, projectedProjectRaw);
+      loadedConfigPath = pathValidation.normalizedPath;
+      loadedConfigSources.push(pathValidation.normalizedPath);
+    }
+    const userRegistryPaths = getUserProviderRegistryPaths(projectRoot);
+    for (const [index, candidate] of userRegistryPaths.entries()) {
+      const userRaw = loadYamlRawIfExists(candidate);
+      if (userRaw) {
+        const migratedUserOverlay = index > 0 ? migrateLegacyFullSnapshotOverlay(userRaw, mergedRaw) : userRaw;
+        const userOverlay = mergeUserAvailableModels(migratedUserOverlay, mergedRaw);
+        mergedRaw = deepMerge(mergedRaw, userOverlay);
+        securityMergedRaw = deepMerge(securityMergedRaw, userOverlay);
+        trustedMergedRaw = deepMerge(trustedMergedRaw, userOverlay);
+        loadedConfigSources.push(candidate);
+        break;
+      }
+    }
+    if (loadedProjectRaw && !isTrustedProjectForTemplatedProviders()) {
+      const apiIdentityChanges = listUntrustedApiIdentityChanges(
+        loadedProjectRaw,
+        securityMergedRaw,
+        trustedMergedRaw
+      );
+      if (apiIdentityChanges.length > 0) {
+        throw buildUntrustedExecutionFieldError(apiIdentityChanges, projectRoot);
+      }
+    }
+    const withEnvOverrides = _ProviderRegistry.applyEnvOverrides(
+      dropRemovedBuiltinProviders(ensureCursorIdSyntaxAdmissionPattern(mergedRaw))
+    );
+    const validated = _ProviderRegistry.parseRegistryConfig(withEnvOverrides);
+    return _ProviderRegistry.replaceCachedRegistry(
+      validated,
+      loadedConfigPath,
+      requestedCacheKey,
+      "implicit",
+      projectRoot,
+      loadedConfigSources
+    );
+  }
+  /**
+   * Resolve every live registry read through the same active-root view.
+   *
+   * A prior explicit-root load establishes which project this process is
+   * serving. Rechecking that root on each read preserves file/environment
+   * fingerprint invalidation without letting a later process.cwd() change
+   * silently switch the live registry to another checkout.
+   */
+  static getActiveRegistry(registryOverride) {
+    if (registryOverride) {
+      return registryOverride;
+    }
+    if (!_ProviderRegistry.instance || !_ProviderRegistry.cacheProjectRoot) {
+      return _ProviderRegistry.load();
+    }
+    if (_ProviderRegistry.cacheMode === "explicit" && _ProviderRegistry.configPath) {
+      return _ProviderRegistry.load(_ProviderRegistry.configPath, _ProviderRegistry.cacheProjectRoot);
+    }
+    return _ProviderRegistry.load(void 0, _ProviderRegistry.cacheProjectRoot);
+  }
+  /**
+   * Get configuration for a specific provider
+   *
+   * @param providerId - Provider identifier (e.g., 'claude', 'codex')
+   * @returns Provider configuration with defaults applied
+   */
+  static getProviderConfig(providerId, registryOverride) {
+    const registry = _ProviderRegistry.getActiveRegistry(registryOverride);
+    const normalizedProviderId = normalizeProviderConfigId(providerId);
+    const providerConfig = registry.providers[providerId] ?? registry.providers[normalizedProviderId];
+    if (!providerConfig) {
+      const availableProviders = Object.values(registry.providers).filter((provider) => provider.enabled).sort((a, b) => a.order - b.order).map((provider) => provider.id).join(", ");
+      throw new Error(
+        `Provider '${providerId}' not found in unified config. Available providers: ${availableProviders}`
+      );
+    }
+    return cloneProviderRegistryValue({
+      ...providerConfig,
+      retry: providerConfig.retry || registry.defaults.retry,
+      circuit_breaker: providerConfig.circuit_breaker || registry.defaults.circuit_breaker,
+      polling: providerConfig.polling || registry.defaults.polling
+    });
+  }
+  /**
+   * Get all provider IDs
+   *
+   * @returns Array of provider IDs
+   */
+  static getAllProviderIds() {
+    const registry = _ProviderRegistry.getActiveRegistry();
+    return Object.keys(registry.providers);
+  }
+  /**
+   * Get all enabled providers
+   *
+   * @returns Array of enabled provider configurations
+   */
+  static getEnabledProviders(registryOverride) {
+    const registry = _ProviderRegistry.getActiveRegistry(registryOverride);
+    return Object.values(registry.providers).filter((p) => p.enabled).sort((a, b) => a.order - b.order);
+  }
+  /**
+   * Check if a provider is enabled
+   *
+   * @param providerId - Provider identifier
+   * @returns True if provider exists and is enabled
+   */
+  static isProviderEnabled(providerId) {
+    const registry = _ProviderRegistry.getActiveRegistry();
+    const normalizedProviderId = normalizeProviderConfigId(providerId);
+    const providerConfig = registry.providers[providerId] ?? registry.providers[normalizedProviderId];
+    return providerConfig?.enabled || false;
+  }
+  /**
+   * Report the source path the currently-cached registry was actually loaded
+   * from.
+   *
+   * This is the coherent provenance signal: when the project providers.yaml is
+   * absent and `load()` falls back to the embedded template seed, this returns
+   * the embedded template path that was actually used — NOT the nonexistent
+   * project `.poetic/config/providers.yaml` path. Diagnostics and logs should
+   * read this instead of recomputing the project path (e.g. via
+   * `resolveProvidersConfigPath`), which would falsely claim a project registry
+   * that is not present on disk.
+   *
+   * Returns `null` when no registry has been loaded yet in this process.
+   *
+   * @returns Absolute path of the loaded registry source, or `null`.
+   */
+  static getLoadedConfigPath() {
+    return _ProviderRegistry.configPath;
+  }
+  /**
+   * Report every source that contributed to the currently-cached registry,
+   * ordered from lowest to highest precedence.
+   */
+  static getLoadedConfigSources() {
+    return [..._ProviderRegistry.configSources];
+  }
+  /**
+   * Force reload configuration from disk
+   * Useful for testing or when config file has been modified
+   */
+  /**
+   * Per-provider `concurrency.max` set in USER-scope provider config only.
+   *
+   * Deliberately NOT read through `getProviderConfig()`. That returns the merged
+   * embedded < project < user view, and `concurrency` is in
+   * PROJECT_POLICY_PROVIDER_FIELDS — a list retained even for UNTRUSTED project
+   * snapshots — so a cloned repository's `.poetic/config/providers.yaml` can set
+   * it. The orchestrator raises how many provider processes actually run from
+   * this value, spending the operator's host resources and account quota, so it
+   * must come from config the operator owns. A project may still ship a lower
+   * value for its own planning; it just cannot raise process concurrency.
+   *
+   * Returns raw declared maxima without validation or clamping; the caller owns
+   * normalization and correctness ceilings. Unreadable or malformed user config
+   * yields an empty map rather than failing the run: the shipped baseline is
+   * always a safe fallback.
+   */
+  static getUserScopeProviderConcurrencyMax(cwd = process.cwd()) {
+    const projectRoot = findProjectRoot(cwd) ?? cwd;
+    const result = {};
+    for (const candidate of getUserProviderRegistryPaths(projectRoot)) {
+      if (!existsSync2(candidate)) continue;
+      let raw;
+      try {
+        raw = yaml.load(readFileSync2(candidate, "utf-8"));
+      } catch {
+        return {};
+      }
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        continue;
+      }
+      const providers = raw.providers;
+      if (!providers || typeof providers !== "object" || Array.isArray(providers)) {
+        return result;
+      }
+      for (const [providerId, providerValue] of Object.entries(
+        providers
+      )) {
+        if (!providerValue || typeof providerValue !== "object" || Array.isArray(providerValue)) {
+          continue;
+        }
+        const concurrency = providerValue.concurrency;
+        if (!concurrency || typeof concurrency !== "object" || Array.isArray(concurrency)) {
+          continue;
+        }
+        const max = concurrency.max;
+        if (typeof max === "number" && Number.isFinite(max)) {
+          result[providerId] = max;
+        }
+      }
+      return result;
+    }
+    return result;
+  }
+  static reload() {
+    _ProviderRegistry.instance = null;
+    _ProviderRegistry.configPath = null;
+    _ProviderRegistry.configSources = [];
+    _ProviderRegistry.cacheKey = null;
+    _ProviderRegistry.cacheMode = null;
+    _ProviderRegistry.cacheProjectRoot = null;
+    runProviderRegistryReloadInvalidators();
+  }
+  static buildEnvOverrideCacheKey() {
+    return fingerprintEnvironment(
+      { ...process.env, ...getExecutionContext().envOverrides },
+      (name) => name.startsWith("POETIC_PROVIDER_") || [
+        "POETIC_TRUST_PROJECT_PROVIDER_TEMPLATES",
+        "POETIC_CONFIG_DIR",
+        "XDG_CONFIG_HOME",
+        "HOME",
+        "USERPROFILE"
+      ].includes(name)
+    );
+  }
+  static buildCacheKey(configPath, envKey, projectRoot) {
+    if (configPath) {
+      return combineCacheFingerprints(
+        `path:${resolve3(configPath)}`,
+        `root:${projectRoot}`,
+        envKey,
+        fingerprintFiles([configPath])
+      );
+    }
+    return combineCacheFingerprints(
+      `root:${projectRoot}`,
+      envKey,
+      fingerprintFiles(getProviderRegistryInputPaths(projectRoot))
+    );
+  }
+  static canReuseExplicitCacheForImplicit(configPath, projectRoot) {
+    return resolve3(configPath) !== resolveProvidersConfigPath({ cwd: projectRoot });
+  }
+  /**
+   * Apply environment variable overrides
+   * Supports: POETIC_PROVIDER_<ID>_<KEY>=value
+   *
+   * Examples:
+   * - POETIC_PROVIDER_CODEX_TIMEOUT_MS=900000
+   * - POETIC_PROVIDER_CLAUDE_ENABLED=false
+   * - POETIC_PROVIDER_GEMINI_MODELS_DEFAULT=gemini-2.5-flash
+   *
+   * @param config - Parsed YAML configuration
+   * @returns Configuration with environment overrides applied
+   */
+  static applyEnvOverrides(config) {
+    if (!config || typeof config !== "object") {
+      return config;
+    }
+    const result = cloneProviderRegistryValue(config);
+    const runtimeEnv = {
+      ...process.env,
+      ...getExecutionContext().envOverrides
+    };
+    for (const [key, value] of Object.entries(runtimeEnv)) {
+      if (!key.startsWith("POETIC_PROVIDER_")) {
+        continue;
+      }
+      if (getEnvVarEntry(key)) {
+        continue;
+      }
+      const overrideName = key.substring("POETIC_PROVIDER_".length);
+      if (!overrideName.includes("_")) {
+        continue;
+      }
+      const providers = result.providers;
+      const providerEntries = providers && typeof providers === "object" ? Object.keys(providers) : [];
+      const providerId = providerEntries.filter((id) => overrideName.startsWith(`${id.toUpperCase()}_`)).sort((a, b) => b.length - a.length)[0];
+      if (!providerId) {
+        const claimedProvider = overrideName.split("_")[0]?.toLowerCase() ?? overrideName;
+        throw new InvalidExplicitConfigError(
+          `Environment variable ${key} targets unknown provider '${claimedProvider}'.`
+        );
+      }
+      const configKey = overrideName.slice(providerId.length + 1).toLowerCase();
+      const providerConfig = providers[providerId];
+      if (providerConfig && typeof providerConfig === "object") {
+        _ProviderRegistry.setNestedValue(
+          providerConfig,
+          configKey,
+          String(value ?? ""),
+          key
+        );
+      }
+    }
+    return result;
+  }
+  static dynamicProviderOverrideKeys() {
+    const runtimeEnv = {
+      ...process.env,
+      ...getExecutionContext().envOverrides
+    };
+    return Object.keys(runtimeEnv).filter((key) => {
+      if (!key.startsWith("POETIC_PROVIDER_") || getEnvVarEntry(key)) return false;
+      return key.substring("POETIC_PROVIDER_".length).includes("_");
+    });
+  }
+  static parseRegistryConfig(config) {
+    try {
+      return ProviderRegistryConfigSchema.parse(config);
+    } catch (error) {
+      if (error instanceof z2.ZodError) {
+        const issues = error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+        const overrideKeys = _ProviderRegistry.dynamicProviderOverrideKeys();
+        if (overrideKeys.length > 0) {
+          throw new InvalidExplicitConfigError(
+            `Invalid provider environment override (${overrideKeys.join(", ")}):
+${issues}`,
+            error
+          );
+        }
+        throw new Error(`Unified provider config validation failed:
+${issues}`);
+      }
+      if (error instanceof TypeError && error.message.includes("_zod")) {
+        throw new Error(
+          `Schema validation failed due to undefined nested schema. This typically indicates incorrect Zod v4 syntax (e.g., z.record() requires two parameters). Original error: ${error.message}
+
+Fix: Change z.record(z.string()) to z.record(z.string(), z.string()) in schema definitions.`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Set a nested value in an object using underscore notation
+   *
+   * @param obj - Object to modify
+   * @param path - Underscore-separated path (TIMEOUT_MS -> timeout_ms, MODELS_DEFAULT -> models.default)
+   * @param value - Value to set
+   */
+  static setNestedValue(obj, path, value, envKey) {
+    const normalizedPath = path.toLowerCase();
+    if (normalizedPath in obj) {
+      obj[normalizedPath] = _ProviderRegistry.coerceOverrideValue(
+        value,
+        obj[normalizedPath],
+        envKey
+      );
+      return;
+    }
+    const parts = normalizedPath.split("_");
+    if (parts[0] === "models" && parts.length > 1) {
+      if (typeof obj.models !== "object" || obj.models === null || Array.isArray(obj.models)) {
+        obj.models = {};
+      }
+      const nestedPath = parts.slice(1).join("_");
+      if (nestedPath === "default" && !("default" in obj.models)) {
+        obj.models.default = value;
+        return;
+      }
+      _ProviderRegistry.setNestedValue(
+        obj.models,
+        nestedPath,
+        value,
+        envKey
+      );
+      return;
+    }
+    for (let i = 1; i < parts.length; i++) {
+      const firstKey = parts.slice(0, i).join("_");
+      const restKey = parts.slice(i).join("_");
+      if (firstKey in obj && typeof obj[firstKey] === "object" && obj[firstKey] !== null) {
+        _ProviderRegistry.setNestedValue(
+          obj[firstKey],
+          restKey,
+          value,
+          envKey
+        );
+        return;
+      }
+    }
+    throw new InvalidExplicitConfigError(
+      `Environment variable ${envKey} targets unknown provider configuration key '${normalizedPath}'.`
+    );
+  }
+  /**
+   * Parse environment variable value to appropriate type
+   *
+   * @param value - String value from environment
+   * @returns Parsed value (boolean, number, or string)
+   */
+  static coerceOverrideValue(value, destination, envKey) {
+    if (typeof destination === "boolean") {
+      const normalized = value.trim().toLowerCase();
+      if (["1", "true", "yes", "on"].includes(normalized)) return true;
+      if (["0", "false", "no", "off"].includes(normalized)) return false;
+      throw new InvalidExplicitConfigError(
+        `Environment variable ${envKey} must be a boolean (true/false, yes/no, on/off, or 1/0).`
+      );
+    }
+    if (typeof destination === "number") {
+      const numeric = Number(value);
+      if (Number.isFinite(numeric)) return numeric;
+      throw new InvalidExplicitConfigError(
+        `Environment variable ${envKey} must be a finite number.`
+      );
+    }
+    return value;
+  }
+  /**
+   * Get global defaults
+   *
+   * @returns Global defaults configuration
+   */
+  static getDefaults() {
+    const registry = _ProviderRegistry.getActiveRegistry();
+    return registry.defaults;
+  }
+  /**
+   * Get configuration metadata
+   *
+   * @returns Configuration metadata
+   */
+  static getMetadata() {
+    const registry = _ProviderRegistry.getActiveRegistry();
+    return registry.metadata;
+  }
+  /**
+   * Resolve a model name for a specific provider
+   * Applies model mappings and validates against allowed patterns
+   *
+   * @param providerId - Provider identifier
+   * @param model - Model name to resolve (may be generic like 'gpt-4')
+   * @returns Resolved provider-specific model name
+   */
+  static resolveModel(providerId, model, registryOverride) {
+    const config = _ProviderRegistry.getProviderConfig(providerId, registryOverride);
+    const trimmedModel = !model || model.trim() === "" ? config.models.default : model.trim();
+    if (trimmedModel in config.models.mappings) {
+      const mapped = config.models.mappings[trimmedModel];
+      if (mapped !== void 0) {
+        return mapped;
+      }
+    }
+    for (const pattern of config.models.allowed_patterns) {
+      let regex;
+      try {
+        regex = new RegExp(pattern);
+      } catch (error) {
+        debugLog(
+          `Skipping invalid allowed_patterns regex for provider '${providerId}': ${pattern} (${error instanceof Error ? error.message : String(error)})`
+        );
+        continue;
+      }
+      if (regex.test(trimmedModel)) {
+        return trimmedModel;
+      }
+    }
+    const availableModels = config.models.available.map((info) => info.id);
+    if (availableModels.includes(trimmedModel)) {
+      return trimmedModel;
+    }
+    const validModels = availableModels.length > 0 ? availableModels.join(", ") : "None";
+    const validPatterns = config.models.allowed_patterns.length > 0 ? config.models.allowed_patterns.join(", ") : "None";
+    const registrySources = !registryOverride || registryOverride === _ProviderRegistry.instance ? _ProviderRegistry.getLoadedConfigSources() : [];
+    const sourceDetail = registrySources.length > 0 ? ` Registry sources: ${registrySources.join(", ")}.` : "";
+    throw new Error(
+      `Model '${trimmedModel}' is not available for provider '${providerId}'. Available models: ${validModels}. Allowed patterns: ${validPatterns}.${sourceDetail}`
+    );
+  }
+  /**
+   * Get bot identity configuration for cloud providers
+   *
+   * @param providerId - Provider identifier
+   * @returns Bot identity config if provider is cloud-based, undefined otherwise
+   */
+  static getBotIdentity(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.bot_identity;
+  }
+  /**
+   * Get timeout for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Timeout in milliseconds
+   */
+  static getTimeout(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.timeout_ms;
+  }
+  /**
+   * Get retry configuration for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Retry configuration with defaults applied
+   */
+  static getRetryConfig(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.retry || _ProviderRegistry.getDefaults().retry;
+  }
+  /**
+   * Get circuit breaker configuration for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Circuit breaker configuration with defaults applied
+   */
+  static getCircuitBreakerConfig(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.circuit_breaker || _ProviderRegistry.getDefaults().circuit_breaker;
+  }
+  /**
+   * Get memory configuration for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Memory configuration
+   */
+  static getMemoryConfig(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.memory;
+  }
+  /**
+   * Get polling configuration for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Polling configuration if provider supports it, default otherwise
+   */
+  static getPollingConfig(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.polling || _ProviderRegistry.getDefaults().polling;
+  }
+  /**
+   * Get pricing configuration for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Pricing configuration if available, undefined otherwise
+   */
+  static getProviderPricing(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.pricing;
+  }
+  /**
+   * Get model pricing for a specific provider and model
+   *
+   * @param providerId - Provider identifier
+   * @param modelId - Model identifier
+   * @returns Model pricing if available, undefined otherwise
+   */
+  static getModelPricing(providerId, modelId) {
+    const pricing = _ProviderRegistry.getProviderPricing(providerId);
+    if (!pricing || !pricing.models) return void 0;
+    return pricing.models[modelId];
+  }
+  /**
+   * Resolve provider ID from model name using allowed_patterns
+   *
+   * @param model - Model name (e.g., 'gemini-2.5-flash', 'sonnet-4-5')
+   * @returns Provider ID if model matches a pattern, undefined otherwise
+   */
+  static resolveProviderByModel(model) {
+    if (!model) return void 0;
+    const registry = _ProviderRegistry.getActiveRegistry();
+    const isNonAuthoritativeOwnershipPattern = (pattern) => {
+      const normalized = pattern.trim();
+      return normalized === ".*" || normalized === "^.*$" || normalized === CURSOR_ID_SYNTAX_ADMISSION_PATTERN;
+    };
+    const matches = [];
+    for (const [providerId, provider] of Object.entries(registry.providers)) {
+      if (!provider.enabled) continue;
+      const patterns = provider.models.allowed_patterns || [];
+      let providerMatched = false;
+      for (const pattern of patterns) {
+        try {
+          const regex = new RegExp(pattern, "i");
+          if (regex.test(model)) {
+            if (isNonAuthoritativeOwnershipPattern(pattern)) {
+              continue;
+            }
+            providerMatched = true;
+            break;
+          }
+        } catch (error) {
+          emitWarning(
+            "CFG-003",
+            {
+              taskId: "provider-registry",
+              subsystem: "config",
+              executionPhase: "setup"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                providerId,
+                pattern,
+                error: error instanceof Error ? error.message : String(error),
+                operation: "resolveProviderByModel"
+              }
+            }
+          );
+        }
+      }
+      if (providerMatched) {
+        matches.push(providerId);
+      }
+    }
+    if (matches.length === 1) {
+      return matches[0];
+    }
+    return void 0;
+  }
+  /**
+   * Get plugins for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Array of plugins, or empty array if none defined
+   */
+  static getProviderPlugins(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.plugins || [];
+  }
+  /**
+   * Get options for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Provider options, or empty object if none defined
+   */
+  static getProviderOptions(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.options || {};
+  }
+  /**
+   * Get requirements for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Provider requirements with both unconditional and conditional deps
+   */
+  static getProviderRequirements(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return {
+      requires: config.requires || [],
+      requires_if: config.requires_if || {}
+    };
+  }
+  /**
+   * Get a specific plugin by ID from a provider
+   *
+   * @param providerId - Provider identifier
+   * @param pluginId - Plugin identifier
+   * @returns Plugin configuration if found, undefined otherwise
+   */
+  static getPlugin(providerId, pluginId) {
+    const plugins = _ProviderRegistry.getProviderPlugins(providerId);
+    return plugins.find((p) => p.id === pluginId);
+  }
+  /**
+   * Get a specific option by key from a provider
+   *
+   * @param providerId - Provider identifier
+   * @param optionKey - Option key
+   * @returns Provider option if found, undefined otherwise
+   */
+  static getOption(providerId, optionKey) {
+    const options = _ProviderRegistry.getProviderOptions(providerId);
+    return options[optionKey];
+  }
+  /**
+   * Get the default model for a provider, from static registry config.
+   * For runtime-observed defaults, use provider-specific discovery.
+   *
+   * @param providerId - Provider identifier
+   * @returns Default model ID, or undefined if not configured
+   */
+  static getDefaultModel(providerId, registryOverride) {
+    const config = _ProviderRegistry.getProviderConfig(providerId, registryOverride);
+    return config.models.default || void 0;
+  }
+  /**
+   * Get a model assigned to a provider-specific role, if configured.
+   *
+   * Roles encode product intent such as "quality" or "fast" without assuming
+   * the provider default is suitable for every outcome strategy.
+   *
+   * @param providerId - Provider identifier
+   * @param role - Model role name
+   * @returns Resolved model ID for the role, or undefined if the role is not configured
+   */
+  static getModelForRole(providerId, role, registryOverride) {
+    const trimmedRole = role.trim();
+    if (!trimmedRole) return void 0;
+    const config = _ProviderRegistry.getProviderConfig(providerId, registryOverride);
+    const configuredModel = config.models.roles?.[trimmedRole];
+    if (!configuredModel) return void 0;
+    return _ProviderRegistry.resolveModel(providerId, configuredModel, registryOverride);
+  }
+  /**
+   * Resolve a reviewer model across all enabled providers, excluding specified providers.
+   *
+   * Implements the cross-provider review rule from the Wave 2 design record:
+   * reviewer != orchestrator provider != executor provider (and any additional
+   * mutation-owner providers the caller passes). Callers pass the provider IDs
+   * already assigned to other stages so this method returns the first remaining
+   * provider that has a model for a role in the role chain.
+   *
+   * Default role chain mirrors judge-tier-selector.ts: `['reviewer', 'quality']`.
+   * Callers that honor a configured `roles.reviewer.modelRole` should pass a
+   * chain starting with that role (then the defaults) so automatic selection
+   * does not silently ignore the configured role.
+   *
+   * Candidate order: when `providerPreference` is provided, those ids are
+   * tried first (skipping excluded / disabled / unknown entries); remaining
+   * enabled providers are then appended in registry `order`. With no
+   * preference, only registry order is used (dormant-compatible).
+   *
+   * Returns null when no qualifying provider is found. Pure and static — reads
+   * only from the loaded registry and applies no side effects.
+   *
+   * @param excludeProviders - Provider IDs to skip (e.g. orchestrator + executor + mutation owners)
+   * @param options.roleChain - Model-role fallback chain (default: reviewer, quality)
+   * @param options.providerPreference - Preferred provider order for selection
+   * @returns Provider + resolved model + winning role, or null if none qualify
+   */
+  static resolveReviewerModel(excludeProviders, options = {}, registryOverride) {
+    const excludeSet = new Set(
+      excludeProviders.map((p) => p.trim().toLowerCase()).filter((p) => p.length > 0)
+    );
+    const roleChain = options.roleChain && options.roleChain.length > 0 ? options.roleChain.map((r) => r.trim()).filter((r) => r.length > 0) : ["reviewer", "quality"];
+    if (roleChain.length === 0) {
+      return null;
+    }
+    const enabled = _ProviderRegistry.getEnabledProviders(registryOverride);
+    const enabledById = new Map(enabled.map((p) => [p.id.toLowerCase(), p]));
+    const ordered = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const pref of options.providerPreference ?? []) {
+      const key = pref.trim().toLowerCase();
+      if (!key || seen.has(key) || excludeSet.has(key)) continue;
+      const match = enabledById.get(key);
+      if (match) {
+        ordered.push(match);
+        seen.add(key);
+      }
+    }
+    for (const providerConfig of enabled) {
+      const key = providerConfig.id.toLowerCase();
+      if (seen.has(key) || excludeSet.has(key)) continue;
+      ordered.push(providerConfig);
+      seen.add(key);
+    }
+    for (const providerConfig of ordered) {
+      const pid = providerConfig.id;
+      for (const role of roleChain) {
+        const model = _ProviderRegistry.getModelForRole(pid, role, registryOverride);
+        if (model) {
+          return { provider: pid, model, role };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the list of available models for a provider, from static registry config.
+   * `getDiscoveredModels()` currently returns this same static inventory.
+   * For observation-backed IDs, call `getCachedProviderModelIds` from
+   * `src/core/providers/model-discovery-cache.ts`.
+   *
+   * @param providerId - Provider identifier
+   * @returns Array of available model IDs from the static registry
+   */
+  static getAvailableModels(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.models.available.map((m) => m.id);
+  }
+  /**
+   * Get static model mappings for a provider (logical name → native CLI ID).
+   * For Cursor, also check getCachedCanonicalMappings() from
+   * src/core/providers/cursor/model-discovery.ts for discovery-fed mappings.
+   *
+   * @param providerId - Provider identifier
+   * @returns Record mapping logical model names to native CLI IDs
+   */
+  static getMappings(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return cloneProviderRegistryValue(config.models.mappings);
+  }
+  /**
+   * Return the static available-model list from this registry.
+   *
+   * Despite the name, this is not live discovery and does not read an
+   * observation cache. It is equivalent to `getAvailableModels()`.
+   *
+   * Callers that need observation-backed IDs should import the cache reader:
+   *
+   *   import { getCachedProviderModelIds } from
+   *     '../providers/model-discovery-cache.js';
+   *   const ids = getCachedProviderModelIds(providerId);
+   *
+   * That reader returns local cache evidence only (empty when none) and does
+   * not fall back to this registry.
+   *
+   * @param providerId - Provider identifier
+   * @returns Array of model IDs from the static registry
+   */
+  static getDiscoveredModels(providerId) {
+    const normalized = normalizeProviderConfigId(providerId);
+    return _ProviderRegistry.getAvailableModels(normalized);
+  }
+  /**
+   * Read a single capability flag for a provider.
+   *
+   * Returns the boolean value when explicitly set in providers.yaml, or
+   * `undefined` when the flag is absent (caller must decide the default).
+   *
+   * @param providerId - Provider identifier
+   * @param name - Capability key (e.g. 'supports_api_judge')
+   * @returns boolean if set, undefined if not declared
+   */
+  static getCapability(providerId, name) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    const value = config.capabilities[name];
+    return typeof value === "boolean" ? value : void 0;
+  }
+};
+function loadProviderRegistry(configPath) {
+  return ProviderRegistry.load(configPath);
+}
+function getProviderConfig(providerId, registryOverride) {
+  return ProviderRegistry.getProviderConfig(providerId, registryOverride);
+}
+function getCapability(providerId, name) {
+  return ProviderRegistry.getCapability(providerId, name);
+}
+
+export {
+  PROVIDER_CATALOG_SHA256,
+  REFRESH_OVERLAY_SCHEMA_VERSION,
+  OverlayModelAvailableEntrySchema,
+  OverlayPricingRowSchema,
+  getRefreshOverlayOperatorNotice,
+  emptyRefreshOverlay,
+  serializeRefreshOverlay,
+  resolveRefreshOverlayDisposition,
+  loadRefreshOverlayFile,
+  fingerprintEnvironment,
+  fingerprintFile,
+  fingerprintFiles,
+  combineCacheFingerprints,
+  InvalidExplicitConfigError,
+  isInvalidExplicitConfigError,
+  isConfigValidityError,
+  rethrowConfigValidityError,
+  isRecognizedEnvVar,
+  getEnvVarEntry,
+  validateEnvironmentVars,
+  isTrustedProjectRoot,
+  formatProjectTrustInstruction,
+  registerProviderRegistryReloadInvalidator,
+  getConfiguredProviderRegistryPaths,
+  getProviderRegistryInputPaths,
+  RetryConfigSchema,
+  CircuitBreakerConfigSchema,
+  RateLimitEntrySchema,
+  RateLimitsConfigSchema,
+  MemoryConfigSchema,
+  PollingConfigSchema,
+  CLIConfigSchema,
+  AuthConfigSchema,
+  TemplatedAuthConfigSchema,
+  ProbeExpectationSchema,
+  CommandProbeSchema,
+  ModelsDiscoverySchema,
+  ModelInfoSchema,
+  ModelAccessClassSchema,
+  ModelAccessConfigSchema,
+  ModelsConfigSchema,
+  TemplatedModelsConfigSchema,
+  CapabilitiesConfigSchema,
+  TemplatedCapabilitiesConfigSchema,
+  BotIdentityConfigSchema,
+  EnvConfigSchema,
+  ModelPricingSchema,
+  ToolPricingSchema,
+  SubscriptionPricingSchema,
+  InfrastructurePricingSchema,
+  ProviderPricingSchema,
+  RefreshStrategyConfigSchema,
+  DefaultPricingSchema,
+  ConcurrencyConfigSchema,
+  RouteConfigSchema,
+  WorkspaceEditsConfigSchema,
+  GenerationConfigSchema,
+  TaskSettingsSchema,
+  PluginVerifySchema,
+  PluginConfigureStepSchema,
+  RequirementSchema,
+  PluginSchema,
+  ProviderOptionSchema,
+  ProviderOptionsSchema,
+  ConditionalRequiresSchema,
+  ProviderRequiresSchema,
+  ApiConfigSchema,
+  TemplatedCLIExecutionSchema,
+  NativeProviderConfigSchema,
+  TemplatedProviderConfigSchema,
+  ProviderConfigSchema,
+  DefaultsConfigSchema,
+  MetadataConfigSchema,
+  ProviderRegistryConfigSchema,
+  ProviderRegistry,
+  loadProviderRegistry,
+  getProviderConfig,
+  getCapability
+};
+//# sourceMappingURL=chunk-AT4TNPWW.js.map