@poetic-ai/poetic 1.42.0

package/dist/chunk-SZ7DL357.js

@@ -0,0 +1,1047 @@
+import {
+  DEFAULT_CONFIG,
+  PoeticConfigReadError,
+  PoeticConfigSchema,
+  RolesConfigSchema,
+  TelemetryConfigSchema,
+  consumePoeticConfigRead,
+  poeticConfigCandidates,
+  readCanonicalPoeticConfig,
+  selectedPoeticConfigCandidate
+} from "./chunk-G36W2T2S.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  InvalidExplicitConfigError,
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  configExists,
+  getConfigPaths
+} from "./chunk-L6OM4A22.js";
+import {
+  getUserConfigDir,
+  getUserPreferencesPath
+} from "./chunk-UUH2RVKS.js";
+import {
+  sanitizeEnvPath
+} from "./chunk-XZE4XARH.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_COVERAGE_ENABLED,
+  POETIC_COVERAGE_THRESHOLD,
+  POETIC_PROFILES_DIR,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/config/legacy-normalization.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function normalizeLegacyIntoCanonical(configData) {
+  const defaults = { ...configData.defaults ?? {} };
+  if (!defaults.provider && isNonEmptyString(configData.defaultProvider)) {
+    defaults.provider = configData.defaultProvider.trim();
+  }
+  if (configData.providers && typeof configData.providers === "object") {
+    const legacyProviderDefaults = Object.fromEntries(
+      Object.entries(configData.providers).map(([provider, providerConfig]) => {
+        if (!providerConfig || typeof providerConfig !== "object") {
+          return [provider, void 0];
+        }
+        const normalized = {};
+        if (isNonEmptyString(providerConfig.model)) {
+          normalized.model = providerConfig.model.trim();
+        }
+        if (isNonEmptyString(providerConfig.strategy)) {
+          normalized.strategy = providerConfig.strategy.trim();
+        }
+        if (Array.isArray(providerConfig.modelOrder)) {
+          const modelOrder = providerConfig.modelOrder.filter(
+            (model) => isNonEmptyString(model)
+          );
+          if (modelOrder.length > 0) {
+            normalized.modelOrder = modelOrder.map((model) => model.trim());
+          }
+        }
+        return [provider, Object.keys(normalized).length > 0 ? normalized : void 0];
+      }).filter(([, providerConfig]) => providerConfig !== void 0)
+    );
+    if (Object.keys(legacyProviderDefaults).length > 0) {
+      defaults.providers = {
+        ...legacyProviderDefaults,
+        ...defaults.providers ?? {}
+      };
+    }
+  }
+  if (Object.keys(defaults).length === 0) {
+    return configData;
+  }
+  return {
+    ...configData,
+    defaults
+  };
+}
+function mirrorCanonicalOntoLegacy(configData) {
+  const defaults = configData.defaults;
+  if (!defaults) {
+    return configData;
+  }
+  let changed = false;
+  let defaultProvider = configData.defaultProvider;
+  let providers = configData.providers;
+  if (isNonEmptyString(defaults.provider) && typeof defaultProvider === "string") {
+    const winner = defaults.provider.trim();
+    if (defaultProvider !== winner) {
+      defaultProvider = winner;
+      changed = true;
+    }
+  }
+  if (defaults.providers && providers && typeof providers === "object") {
+    let providersChanged = false;
+    const nextProviders = { ...providers };
+    for (const [providerId, canonicalProvider] of Object.entries(defaults.providers)) {
+      if (!canonicalProvider || typeof canonicalProvider !== "object") continue;
+      const legacyProvider = nextProviders[providerId];
+      if (!legacyProvider || typeof legacyProvider !== "object") continue;
+      let providerChanged = false;
+      const nextLegacy = { ...legacyProvider };
+      if (isNonEmptyString(canonicalProvider.model) && typeof legacyProvider.model === "string") {
+        const winner = canonicalProvider.model.trim();
+        if (legacyProvider.model !== winner) {
+          nextLegacy.model = winner;
+          providerChanged = true;
+        }
+      }
+      if (isNonEmptyString(canonicalProvider.strategy) && typeof legacyProvider.strategy === "string") {
+        const winner = canonicalProvider.strategy.trim();
+        if (legacyProvider.strategy !== winner) {
+          nextLegacy.strategy = winner;
+          providerChanged = true;
+        }
+      }
+      if (Array.isArray(canonicalProvider.modelOrder) && Array.isArray(legacyProvider.modelOrder)) {
+        const winner = canonicalProvider.modelOrder.filter((model) => isNonEmptyString(model)).map((model) => model.trim());
+        if (JSON.stringify(legacyProvider.modelOrder) !== JSON.stringify(winner)) {
+          nextLegacy.modelOrder = winner;
+          providerChanged = true;
+        }
+      }
+      if (providerChanged) {
+        nextProviders[providerId] = nextLegacy;
+        providersChanged = true;
+      }
+    }
+    if (providersChanged) {
+      providers = nextProviders;
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return configData;
+  }
+  return {
+    ...configData,
+    ...defaultProvider !== configData.defaultProvider ? { defaultProvider } : {},
+    ...providers !== configData.providers ? { providers } : {}
+  };
+}
+function normalizeMergedConfigTree(configData) {
+  return mirrorCanonicalOntoLegacy(normalizeLegacyIntoCanonical(configData));
+}
+var PROVIDER_VENDOR_MODEL_ENV_ALIASES = {
+  claude: ["ANTHROPIC_MODEL"],
+  codex: ["OPENAI_MODEL"]
+};
+function readProviderModelFromEnv(provider, extraLegacyKeys = PROVIDER_VENDOR_MODEL_ENV_ALIASES[provider.toLowerCase().trim()] ?? []) {
+  const normalizedProvider = provider.toUpperCase().trim();
+  if (!normalizedProvider) return null;
+  const standardizedKey = `POETIC_${normalizedProvider}_DEFAULT_MODEL`;
+  const standardized = process.env[standardizedKey];
+  if (standardized) {
+    return { value: standardized, key: standardizedKey, kind: "standardized" };
+  }
+  const legacyKey = `POETIC_${normalizedProvider}_MODEL`;
+  const legacy = process.env[legacyKey];
+  if (legacy) {
+    return { value: legacy, key: legacyKey, kind: "legacy" };
+  }
+  for (const key of extraLegacyKeys) {
+    const value = process.env[key];
+    if (value) {
+      return { value, key, kind: "legacy" };
+    }
+  }
+  return null;
+}
+
+// src/core/config/loaders/jsonc-loader.ts
+async function readJsoncConfig(filePath) {
+  const result = readCanonicalPoeticConfig(filePath);
+  return result;
+}
+async function loadJsoncConfig(filePath) {
+  return consumePoeticConfigRead(await readJsoncConfig(filePath));
+}
+
+// src/core/config/profile-store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  closeSync as closeSync2,
+  existsSync,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join2 } from "path";
+import lockfile2 from "proper-lockfile";
+import { z } from "zod";
+
+// src/core/config/user-state-store.ts
+import { randomUUID } from "crypto";
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join } from "path";
+import lockfile from "proper-lockfile";
+var LOCK_STALE_MS = 3e4;
+var LOCK_RETRY_COUNT = 50;
+var LOCK_RETRY_MIN_MS = 10;
+var LOCK_RETRY_MAX_MS = 100;
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isUserState(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readAtPath(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { status: "missing", path: filePath };
+    }
+    throw error;
+  }
+  try {
+    const parsed = JSON.parse(raw.toString("utf8"));
+    if (!isUserState(parsed)) {
+      return {
+        status: "corrupt",
+        path: filePath,
+        error: "User state must contain a JSON object",
+        raw
+      };
+    }
+    return { status: "valid", path: filePath, data: parsed, raw };
+  } catch (error) {
+    return { status: "corrupt", path: filePath, error: errorMessage(error), raw };
+  }
+}
+function ensurePrivateDirectory(filePath) {
+  mkdirSync(dirname(filePath), { recursive: true, mode: 448 });
+}
+function lockTargetPath(filePath) {
+  return join(dirname(filePath), `.${basename(filePath)}.write-lock`);
+}
+function waitForRetry(delayMs) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs);
+}
+function acquireWriteLock(filePath) {
+  ensurePrivateDirectory(filePath);
+  const target = lockTargetPath(filePath);
+  const descriptor = openSync(target, "a", 384);
+  closeSync(descriptor);
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return lockfile.lockSync(target, {
+        stale: LOCK_STALE_MS,
+        realpath: false
+      });
+    } catch (error) {
+      if (error.code !== "ELOCKED" || attempt >= LOCK_RETRY_COUNT) {
+        throw error;
+      }
+      waitForRetry(Math.min(LOCK_RETRY_MIN_MS * 1.2 ** attempt, LOCK_RETRY_MAX_MS));
+    }
+  }
+}
+function uniqueTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function quarantineCorruptState(filePath, raw, parseError) {
+  const quarantinePath = `${filePath}.corrupt-${uniqueTimestamp()}-${process.pid}-${randomUUID()}`;
+  writeFileSync(quarantinePath, raw, { flag: "wx", mode: 384 });
+  return {
+    code: "CORRUPT_USER_STATE_QUARANTINED",
+    message: `Corrupt user state was preserved at ${quarantinePath}`,
+    sourcePath: filePath,
+    quarantinePath,
+    parseError
+  };
+}
+function atomicWriteState(filePath, state) {
+  const tempPath = join(
+    dirname(filePath),
+    `.${basename(filePath)}.${process.pid}-${Date.now()}-${randomUUID()}.tmp`
+  );
+  let tempExists = false;
+  try {
+    writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    tempExists = true;
+    renameSync(tempPath, filePath);
+    tempExists = false;
+  } finally {
+    if (tempExists) {
+      try {
+        unlinkSync(tempPath);
+      } catch {
+      }
+    }
+  }
+}
+function readUserState(options = {}) {
+  const filePath = options.filePath ?? getUserPreferencesPath();
+  const result = readAtPath(filePath);
+  if (result.status === "corrupt") {
+    return { status: result.status, path: result.path, error: result.error };
+  }
+  return result;
+}
+function mutateUserState(mutator, options = {}) {
+  const filePath = options.filePath ?? getUserPreferencesPath();
+  const release = acquireWriteLock(filePath);
+  try {
+    const existing = readAtPath(filePath);
+    const warnings = [];
+    let state;
+    if (existing.status === "valid") {
+      try {
+        options.validateExisting?.(existing.data);
+        state = existing.data;
+      } catch (error) {
+        warnings.push(quarantineCorruptState(filePath, existing.raw, errorMessage(error)));
+        state = options.recoverInvalidExisting?.(existing.data) ?? {};
+      }
+    } else if (existing.status === "corrupt") {
+      warnings.push(quarantineCorruptState(filePath, existing.raw, existing.error));
+      state = {};
+    } else {
+      state = {};
+    }
+    const value = mutator(state);
+    if (!isUserState(state)) {
+      throw new Error("User-state mutator must leave a JSON object");
+    }
+    if (options.deleteIfEmpty && Object.keys(state).length === 0) {
+      try {
+        unlinkSync(filePath);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    } else {
+      atomicWriteState(filePath, state);
+    }
+    return { path: filePath, state, value, warnings };
+  } finally {
+    release();
+  }
+}
+function readUserStateField(key, options = {}) {
+  const result = readUserState(options);
+  return result.status === "valid" ? result.data[key] : void 0;
+}
+function writeUserStateField(key, value, options = {}) {
+  return mutateUserState((state) => {
+    if (value === void 0) {
+      delete state[key];
+    } else {
+      state[key] = value;
+    }
+  }, options);
+}
+
+// src/core/config/profile-store.ts
+var PROFILE_NAME_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
+var ProfileProviderIdSchema = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "Invalid provider id");
+var ProfileProviderDefaultsSchema = z.object({
+  model: z.string().optional(),
+  strategy: z.string().optional(),
+  modelOrder: z.array(z.string()).optional()
+}).strict();
+var ProfileDataSchema = z.object({
+  $version: z.literal(1),
+  name: z.string().regex(PROFILE_NAME_RE),
+  createdAt: z.string().min(1),
+  updatedAt: z.string().min(1),
+  description: z.string().optional(),
+  defaults: z.object({
+    provider: ProfileProviderIdSchema.optional(),
+    model: z.string().optional(),
+    strategy: z.string().optional(),
+    providerOrder: z.array(z.string()).optional(),
+    providers: z.record(z.string(), ProfileProviderDefaultsSchema).optional(),
+    judge: z.object({
+      type: z.enum(["ai", "multi-lens", "multi-agent"]).optional(),
+      provider: ProfileProviderIdSchema.optional(),
+      model: z.string().optional(),
+      providerOrder: z.array(z.string()).optional()
+    }).strict().optional(),
+    synthesis: z.object({
+      provider: ProfileProviderIdSchema.optional(),
+      model: z.string().optional(),
+      providerOrder: z.array(z.string()).optional()
+    }).strict().optional(),
+    routingPolicy: z.string().optional(),
+    intent: z.object({
+      decomposition: z.object({
+        providerOrder: z.array(z.string()).optional(),
+        routingPolicy: z.string().optional()
+      }).strict().optional()
+    }).strict().optional()
+  }).strict().optional(),
+  telemetry: z.object({ enabled: z.boolean().optional(), silent: z.boolean().optional() }).strict().optional(),
+  execution: z.object({
+    transport: z.object({
+      default: z.enum(["auto", "headless", "tmux-exec", "interactive"]).optional(),
+      providers: z.record(z.string(), z.enum(["auto", "headless", "tmux-exec", "interactive"])).optional()
+    }).strict().optional()
+  }).strict().optional(),
+  roles: z.object({
+    orchestrator: z.object({
+      provider: ProfileProviderIdSchema.optional(),
+      model: z.string().optional(),
+      modelRole: z.string().optional(),
+      fallbackModelRole: z.string().optional(),
+      reasoningEffort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional()
+    }).strict().optional(),
+    executor: z.object({
+      provider: ProfileProviderIdSchema.optional(),
+      model: z.string().optional(),
+      modelRole: z.string().optional(),
+      subagents: z.union([z.number().int().positive(), z.enum(["advisory", "off"])]).optional(),
+      transport: z.enum(["auto", "headless", "tmux-exec"]).optional(),
+      reasoningEffort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional()
+    }).strict().optional(),
+    reviewer: z.object({
+      provider: ProfileProviderIdSchema.optional(),
+      model: z.string().optional(),
+      modelRole: z.string().optional(),
+      providerPreference: z.array(ProfileProviderIdSchema).optional(),
+      reasoningEffort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
+      gate: z.enum(["off", "advisory", "high-severity-blocks"]).optional()
+    }).strict().optional()
+  }).strict().optional(),
+  judge: z.object({
+    provider: ProfileProviderIdSchema.optional(),
+    model: z.string().optional(),
+    ai: z.object({ provider: ProfileProviderIdSchema.optional(), model: z.string().optional() }).strict().optional(),
+    multiLens: z.object({ provider: ProfileProviderIdSchema.optional(), model: z.string().optional() }).strict().optional(),
+    multiAgent: z.object({ provider: ProfileProviderIdSchema.optional(), model: z.string().optional() }).strict().optional()
+  }).strict().optional()
+}).strict();
+var SECRET_PATTERN_RE = /api[_-]?key|token|secret|password|credential|auth[_-]?key|access[_-]?key|private[_-]?key/i;
+function getProfilesDir() {
+  const { value: profilesDir, source } = readEnv(POETIC_PROFILES_DIR);
+  if (source === "env" && profilesDir) {
+    const sanitized = sanitizeEnvPath(profilesDir, POETIC_PROFILES_DIR.name, {
+      allowHomeDir: true,
+      allowTempDir: true
+    });
+    if (sanitized) return sanitized;
+  }
+  return join2(getUserConfigDir(), "profiles");
+}
+function profilePath(profilesDir, name) {
+  return join2(profilesDir, `${name}.json`);
+}
+function validateName(name) {
+  if (!PROFILE_NAME_RE.test(name)) {
+    throw new Error(`Invalid profile name "${name}". Names must match ${PROFILE_NAME_RE.source}`);
+  }
+}
+function parseProfileData(raw, label, expectedName) {
+  const parsed = parseJsonWithContext(raw, label);
+  const result = ProfileDataSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid profile ${label}: ${result.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+    );
+  }
+  if (expectedName && result.data.name !== expectedName) {
+    throw new Error(
+      `Invalid profile ${label}: name '${result.data.name}' does not match file '${expectedName}.json'`
+    );
+  }
+  return result.data;
+}
+function assertNoSecrets(data, path = "") {
+  if (!data || typeof data !== "object") return;
+  for (const [key, value] of Object.entries(data)) {
+    const currentPath = path ? `${path}.${key}` : key;
+    if (SECRET_PATTERN_RE.test(key)) {
+      throw new Error(
+        `Profile contains a field that looks like a secret at "${currentPath}". Secrets must not be stored in profiles. Use env vars or a credential helper.`
+      );
+    }
+    assertNoSecrets(value, currentPath);
+  }
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+function withProfilesWriteLock(profilesDir, action) {
+  ensureDir(profilesDir);
+  const lockTarget = join2(profilesDir, ".profiles-write-lock");
+  const descriptor = openSync2(lockTarget, "a", 384);
+  closeSync2(descriptor);
+  let release;
+  for (let attempt = 0; release === void 0; attempt += 1) {
+    try {
+      release = lockfile2.lockSync(lockTarget, { realpath: false, stale: 3e4 });
+    } catch (error) {
+      if (error.code !== "ELOCKED" || attempt >= 50) throw error;
+      Atomics.wait(
+        new Int32Array(new SharedArrayBuffer(4)),
+        0,
+        0,
+        Math.min(10 * 1.2 ** attempt, 100)
+      );
+    }
+  }
+  try {
+    return action();
+  } finally {
+    release();
+  }
+}
+function atomicWriteUnlocked(filePath, content) {
+  const tmp = `${filePath}.${process.pid}-${randomUUID2()}.tmp`;
+  try {
+    writeFileSync2(tmp, content, { encoding: "utf8", flag: "wx", mode: 384 });
+    renameSync2(tmp, filePath);
+  } catch (error) {
+    try {
+      unlinkSync2(tmp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function readActiveProfileName() {
+  const envProfile = process.env.POETIC_ACTIVE_PROFILE?.trim();
+  if (envProfile) {
+    return envProfile || void 0;
+  }
+  const value = readUserStateField("activeProfile");
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function writeActiveProfileName(name) {
+  return writeUserStateField("activeProfile", name ?? void 0);
+}
+function listProfiles() {
+  const profilesDir = getProfilesDir();
+  const active = readActiveProfileName();
+  if (!existsSync(profilesDir)) return [];
+  const entries = [];
+  for (const file of readdirSync(profilesDir)) {
+    if (!file.endsWith(".json")) continue;
+    const stem = file.slice(0, -5);
+    if (!PROFILE_NAME_RE.test(stem)) continue;
+    try {
+      const raw = readFileSync2(join2(profilesDir, file), "utf8");
+      const data = parseProfileData(raw, `profiles/${file}`, stem);
+      entries.push({
+        name: stem,
+        active: stem === active,
+        createdAt: data.createdAt ?? "",
+        description: data.description
+      });
+    } catch {
+    }
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+function profileExists(name) {
+  const profilesDir = getProfilesDir();
+  return existsSync(profilePath(profilesDir, name));
+}
+function readProfile(name) {
+  validateName(name);
+  const profilesDir = getProfilesDir();
+  const p = profilePath(profilesDir, name);
+  if (!existsSync(p)) {
+    throw new Error(`Profile "${name}" not found`);
+  }
+  const raw = readFileSync2(p, "utf8");
+  return parseProfileData(raw, `profiles/${name}.json`, name);
+}
+function writeProfile(data) {
+  validateName(data.name);
+  assertNoSecrets(data.defaults);
+  assertNoSecrets(data.telemetry);
+  const profilesDir = getProfilesDir();
+  ensureDir(profilesDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    ...data,
+    $version: 1,
+    updatedAt: now,
+    createdAt: data.createdAt || now
+  };
+  ProfileDataSchema.parse(record);
+  withProfilesWriteLock(profilesDir, () => {
+    atomicWriteUnlocked(profilePath(profilesDir, data.name), JSON.stringify(record, null, 2));
+  });
+}
+function createProfile(name, options = {}) {
+  validateName(name);
+  const profilesDir = getProfilesDir();
+  return withProfilesWriteLock(profilesDir, () => {
+    if (existsSync(profilePath(profilesDir, name))) {
+      throw new Error(`Profile "${name}" already exists. Use --force to overwrite.`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let base = {};
+    if (options.fromProfile) {
+      const source = readProfile(options.fromProfile);
+      base = {
+        defaults: source.defaults ? structuredClone(source.defaults) : void 0,
+        telemetry: source.telemetry ? structuredClone(source.telemetry) : void 0
+      };
+    }
+    const profile = {
+      $version: 1,
+      name,
+      createdAt: now,
+      updatedAt: now,
+      description: options.description,
+      ...base
+    };
+    if (options.defaults && Object.keys(options.defaults).length > 0) {
+      profile.defaults = { ...profile.defaults ?? {}, ...options.defaults };
+    }
+    assertNoSecrets(profile.defaults);
+    assertNoSecrets(profile.telemetry);
+    ProfileDataSchema.parse(profile);
+    atomicWriteUnlocked(profilePath(profilesDir, name), JSON.stringify(profile, null, 2));
+    return profile;
+  });
+}
+function deleteProfile(name, force = false) {
+  validateName(name);
+  const profilesDir = getProfilesDir();
+  withProfilesWriteLock(profilesDir, () => {
+    const p = profilePath(profilesDir, name);
+    if (!existsSync(p)) throw new Error(`Profile "${name}" not found`);
+    const active = readActiveProfileName();
+    if (active === name && !force) {
+      throw new Error(
+        `Profile "${name}" is currently active. Use --force to delete it, or switch profiles first.`
+      );
+    }
+    if (active === name) writeActiveProfileName(null);
+    unlinkSync2(p);
+  });
+}
+function setActiveProfile(name) {
+  const profilesDir = getProfilesDir();
+  withProfilesWriteLock(profilesDir, () => {
+    if (!existsSync(profilePath(profilesDir, name))) {
+      throw new Error(`Profile "${name}" does not exist`);
+    }
+    const profile = readProfile(name);
+    if (profile.roles) {
+      const parsed = RolesConfigSchema.safeParse(profile.roles);
+      if (!parsed.success) {
+        const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "roles"}: ${issue.message}`).join("; ");
+        throw new Error(`Profile "${name}" has invalid roles: ${issues}`);
+      }
+      const knownProviders = new Set(ProviderRegistry.getAllProviderIds());
+      const configuredProviders = [
+        parsed.data.orchestrator?.provider,
+        parsed.data.executor?.provider,
+        parsed.data.reviewer?.provider,
+        ...parsed.data.reviewer?.providerPreference ?? []
+      ].filter((provider) => Boolean(provider));
+      const unknownProviders = configuredProviders.filter(
+        (provider) => !knownProviders.has(provider)
+      );
+      if (unknownProviders.length > 0) {
+        throw new Error(
+          `Profile "${name}" has unknown role provider(s): ${[...new Set(unknownProviders)].join(", ")}`
+        );
+      }
+    }
+    writeActiveProfileName(name);
+  });
+}
+function clearActiveProfile() {
+  writeActiveProfileName(null);
+}
+function loadActiveProfileStrict() {
+  const name = readActiveProfileName();
+  if (!name) return null;
+  return readProfile(name);
+}
+function getActiveProfilePath() {
+  const name = readActiveProfileName();
+  if (!name || !PROFILE_NAME_RE.test(name)) return void 0;
+  return profilePath(getProfilesDir(), name);
+}
+
+// src/core/config/config-loader.ts
+var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+function normalizeProviderId(value) {
+  const provider = value?.toLowerCase().trim();
+  return provider && PROVIDER_ID_PATTERN.test(provider) ? provider : null;
+}
+function legacyConfigFileCandidates(path) {
+  const base = path.replace(/\.(jsonc|json|mjs|js)$/i, "");
+  return [`${base}.mjs`, `${base}.js`];
+}
+var warnedLegacyConfigPaths = /* @__PURE__ */ new Set();
+var ProfileConfigLayerSchema = PoeticConfigSchema.extend({
+  telemetry: TelemetryConfigSchema.partial().optional()
+});
+function profileToPoeticConfig(profile) {
+  const candidate = {
+    ...profile.defaults ? { defaults: profile.defaults } : {},
+    ...profile.telemetry?.enabled !== void 0 ? {
+      telemetry: {
+        enabled: profile.telemetry.enabled
+      }
+    } : {},
+    ...profile.execution ? { execution: profile.execution } : {},
+    ...profile.roles ? { roles: profile.roles } : {},
+    ...profile.judge ? { judge: profile.judge } : {}
+  };
+  const validated = ProfileConfigLayerSchema.safeParse(candidate);
+  if (!validated.success) {
+    throw new PoeticConfigReadError(
+      getActiveProfilePath() ?? `profile:${profile.name}`,
+      "schema",
+      validated.error.issues.map((issue) => ({
+        message: `${issue.path.join(".") || "<root>"}: ${issue.message}`,
+        path: issue.path.join(".") || void 0,
+        code: issue.code
+      }))
+    );
+  }
+  return normalizeLegacyIntoCanonical(validated.data);
+}
+function warnIfLegacyConfigExists(path) {
+  for (const legacyPath of legacyConfigFileCandidates(path)) {
+    if (!configExists(legacyPath) || warnedLegacyConfigPaths.has(legacyPath)) continue;
+    warnedLegacyConfigPaths.add(legacyPath);
+    emitWarning(
+      "CFG-009",
+      {
+        taskId: "config-loader",
+        subsystem: "config",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          operation: "loadConfig",
+          configPath: legacyPath,
+          reason: "Legacy JavaScript config files are no longer read"
+        }
+      }
+    );
+  }
+}
+function loadEnvConfig() {
+  const config = {};
+  if (process.env.POETIC_DEFAULT_PROVIDER) {
+    const provider = normalizeProviderId(process.env.POETIC_DEFAULT_PROVIDER);
+    if (provider) {
+      config.defaultProvider = provider;
+    } else {
+      throw new InvalidExplicitConfigError(
+        "Invalid POETIC_DEFAULT_PROVIDER: expected a lowercase-compatible provider id containing only letters, digits, underscores, or hyphens"
+      );
+    }
+  }
+  const providers = {};
+  const parseEnabledFlag = (value, defaultValue) => {
+    if (value === void 0 || value === "") return defaultValue;
+    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(
+      `Invalid provider enabled flag '${value}': expected one of 1, true, yes, on, 0, false, no, off`
+    );
+  };
+  const isExplicitEnvFlag = (value) => value !== void 0 && value !== "";
+  const claudeModel = readProviderModelFromEnv("claude");
+  if (claudeModel || process.env.POETIC_CLAUDE_ENABLED) {
+    providers.claude = {
+      ...isExplicitEnvFlag(process.env.POETIC_CLAUDE_ENABLED) ? { enabled: parseEnabledFlag(process.env.POETIC_CLAUDE_ENABLED, true) } : {},
+      // Omit model when unset so env enable/disable cannot clobber a project model.
+      ...claudeModel ? { model: claudeModel.value } : {}
+    };
+  }
+  const codexModel = readProviderModelFromEnv("codex");
+  if (codexModel || process.env.POETIC_CODEX_ENABLED) {
+    providers.codex = {
+      ...isExplicitEnvFlag(process.env.POETIC_CODEX_ENABLED) ? { enabled: parseEnabledFlag(process.env.POETIC_CODEX_ENABLED, true) } : {},
+      ...codexModel ? { model: codexModel.value } : {}
+    };
+  }
+  const cursorModel = readProviderModelFromEnv("cursor");
+  if (cursorModel || process.env.POETIC_CURSOR_ENABLED) {
+    providers.cursor = {
+      ...isExplicitEnvFlag(process.env.POETIC_CURSOR_ENABLED) ? { enabled: parseEnabledFlag(process.env.POETIC_CURSOR_ENABLED, true) } : {},
+      ...cursorModel ? { model: cursorModel.value } : {}
+    };
+  }
+  if (process.env.POETIC_COPILOT_ENABLED || process.env.POETIC_COPILOT_ORG || process.env.POETIC_COPILOT_PLAN) {
+    const organization = process.env.POETIC_COPILOT_ORG;
+    const seat = process.env.POETIC_COPILOT_PLAN;
+    providers.copilot = {
+      ...process.env.POETIC_COPILOT_ENABLED !== void 0 && process.env.POETIC_COPILOT_ENABLED !== "" ? { enabled: parseEnabledFlag(process.env.POETIC_COPILOT_ENABLED, true) } : process.env.POETIC_COPILOT_ORG || process.env.POETIC_COPILOT_PLAN ? { enabled: true } : {},
+      ...organization ? { organization } : {},
+      ...seat ? { seat } : {}
+    };
+  }
+  if (process.env.POETIC_COVERAGE_THRESHOLD || process.env.POETIC_COVERAGE_ENABLED) {
+    try {
+      const threshold = readEnv(POETIC_COVERAGE_THRESHOLD);
+      const enabled = readEnv(POETIC_COVERAGE_ENABLED);
+      config.quality = {
+        coverage: {
+          ...enabled.source === "env" ? { enabled: enabled.value ?? true } : {},
+          ...threshold.source === "env" && threshold.value !== void 0 ? { threshold: threshold.value } : {}
+        }
+      };
+    } catch (error) {
+      throw new InvalidExplicitConfigError(
+        `Invalid Poetic environment configuration: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+  }
+  if (process.env.POETIC_BIOME_REPAIR_PROVIDER || process.env.POETIC_BIOME_REPAIR_MODEL) {
+    config.execution = {
+      ...config.execution ?? {},
+      biomeRepair: {
+        provider: process.env.POETIC_BIOME_REPAIR_PROVIDER,
+        model: process.env.POETIC_BIOME_REPAIR_MODEL
+      }
+    };
+  }
+  if (process.env.POETIC_TELEMETRY_ENABLED !== void 0 && process.env.POETIC_TELEMETRY_ENABLED !== "") {
+    const database = process.env.POETIC_TELEMETRY_DB;
+    config.telemetry = {
+      enabled: parseEnabledFlag(process.env.POETIC_TELEMETRY_ENABLED, true),
+      // Omit unset database so ENABLED alone cannot clobber a project path.
+      ...database ? { database } : {}
+    };
+  }
+  if (Object.keys(providers).length > 0) {
+    config.providers = providers;
+  }
+  return normalizeLegacyIntoCanonical(config);
+}
+async function loadOneConfig(filePath) {
+  if (!filePath.endsWith(".jsonc") && !filePath.endsWith(".json")) return null;
+  const config = consumePoeticConfigRead(await readJsoncConfig(filePath));
+  if (!config) return null;
+  return normalizeLegacyIntoCanonical(config);
+}
+async function loadUserConfig(userConfigPath, cwd = process.cwd()) {
+  const paths = getConfigPaths(cwd);
+  const candidates = userConfigPath ? poeticConfigCandidates(userConfigPath) : poeticConfigCandidates(paths.userConfigFile);
+  for (const path of candidates) {
+    const config = await loadOneConfig(path);
+    if (config) {
+      return config;
+    }
+  }
+  warnIfLegacyConfigExists(candidates[0] ?? paths.userConfigFile);
+  return null;
+}
+async function loadProjectConfig(projectConfigPath, cwd = process.cwd()) {
+  const paths = getConfigPaths(cwd);
+  const candidates = projectConfigPath ? poeticConfigCandidates(projectConfigPath) : poeticConfigCandidates(paths.projectConfigFile);
+  for (const path of candidates) {
+    const config = await loadOneConfig(path);
+    if (config) {
+      return config;
+    }
+  }
+  warnIfLegacyConfigExists(candidates[0] ?? paths.projectConfigFile);
+  return null;
+}
+async function loadAllConfigSources(cwd = process.cwd(), cliFlags = {}) {
+  const paths = getConfigPaths(cwd);
+  const envData = loadEnvConfig();
+  let activeProfile;
+  try {
+    activeProfile = loadActiveProfileStrict();
+  } catch (error) {
+    const profilePath2 = getActiveProfilePath() ?? "active profile";
+    throw new PoeticConfigReadError(
+      profilePath2,
+      "unreadable",
+      [{ message: error instanceof Error ? error.message : String(error) }],
+      error
+    );
+  }
+  const sources = [
+    // CLI flags (highest priority)
+    {
+      type: "cli",
+      priority: 100,
+      data: cliFlags,
+      exists: Object.keys(cliFlags).length > 0
+    },
+    // Environment variables
+    {
+      type: "env",
+      priority: 90,
+      data: envData,
+      exists: Object.keys(envData).length > 0
+    },
+    // Active user profile (below env, above project config)
+    {
+      type: "profile",
+      priority: 85,
+      data: activeProfile ? profileToPoeticConfig(activeProfile) : void 0,
+      path: activeProfile ? `profile:${activeProfile.name}` : void 0,
+      exists: activeProfile !== null
+    },
+    // Project configuration
+    {
+      type: "project",
+      priority: 80,
+      path: selectedPoeticConfigCandidate(paths.projectConfigFile),
+      exists: poeticConfigCandidates(paths.projectConfigFile).some((path) => configExists(path))
+    },
+    // User configuration (.config/poetic/poetic.config.jsonc)
+    {
+      type: "user",
+      priority: 60,
+      path: selectedPoeticConfigCandidate(paths.userConfigFile),
+      exists: poeticConfigCandidates(paths.userConfigFile).some((path) => configExists(path))
+    },
+    // Template defaults (lowest priority)
+    {
+      type: "default",
+      priority: 20,
+      data: DEFAULT_CONFIG,
+      exists: true
+    }
+  ];
+  for (const source of sources) {
+    if (source.exists && !source.data && source.path) {
+      switch (source.type) {
+        case "project":
+          source.data = await loadProjectConfig(source.path, cwd);
+          break;
+        case "user":
+          source.data = await loadUserConfig(source.path, cwd);
+          break;
+      }
+    }
+  }
+  return sources.filter((source) => source.data !== null && source.exists);
+}
+function validateConfigSource(source) {
+  const errors = [];
+  if (!source.data) {
+    errors.push("No configuration data");
+    return { isValid: false, errors };
+  }
+  try {
+    const result = (source.type === "profile" ? ProfileConfigLayerSchema : PoeticConfigSchema).safeParse(source.data);
+    if (!result.success) {
+      errors.push(
+        ...result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+      );
+    }
+  } catch (error) {
+    errors.push(`Validation error: ${error}`);
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+async function getConfigDiagnostics(cwd = process.cwd()) {
+  const startTime = Date.now();
+  const sources = await loadAllConfigSources(cwd);
+  const loadTime = Date.now() - startTime;
+  const diagnostics = sources.map((source) => {
+    const validation = validateConfigSource(source);
+    return {
+      type: source.type,
+      path: source.path,
+      exists: source.exists || false,
+      loaded: !!source.data,
+      valid: validation.isValid,
+      errors: validation.errors
+    };
+  });
+  const summary = {
+    totalSources: sources.length,
+    loadedSources: diagnostics.filter((d) => d.loaded).length,
+    validSources: diagnostics.filter((d) => d.valid).length,
+    errorsCount: diagnostics.reduce((sum, d) => sum + d.errors.length, 0)
+  };
+  return {
+    sources: diagnostics,
+    loadTime,
+    summary
+  };
+}
+
+export {
+  readUserState,
+  mutateUserState,
+  readActiveProfileName,
+  listProfiles,
+  profileExists,
+  readProfile,
+  writeProfile,
+  createProfile,
+  deleteProfile,
+  setActiveProfile,
+  clearActiveProfile,
+  loadActiveProfileStrict,
+  getActiveProfilePath,
+  normalizeLegacyIntoCanonical,
+  normalizeMergedConfigTree,
+  readProviderModelFromEnv,
+  loadJsoncConfig,
+  profileToPoeticConfig,
+  loadEnvConfig,
+  loadProjectConfig,
+  loadAllConfigSources,
+  validateConfigSource,
+  getConfigDiagnostics
+};
+//# sourceMappingURL=chunk-SZ7DL357.js.map