@iowarp/clio-coder 0.4.0 → 0.4.2

package/dist/chunk-34BHNEE3.js

@@ -0,0 +1,1846 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  warnLegacyNaming
+} from "./chunk-D7E7WCDF.js";
+import {
+  MAX_TIMER_DELAY_MS
+} from "./chunk-EBY63B7G.js";
+import {
+  ACTIVE_AGENT_AUTOMATION_ROLES,
+  ACTIVE_ROUTING_POSTURES,
+  ACTIVE_ROUTING_ROLES,
+  COUNCIL_MEMBER_LABEL_PATTERN,
+  DEFAULT_SETTINGS,
+  THEME_NAMED_COLORS,
+  THINKING_LEVELS
+} from "./chunk-UXCU4E3T.js";
+import {
+  withStateFileLockSync
+} from "./chunk-IKCO5N3L.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  clioConfigDir,
+  resolveClioDirs
+} from "./chunk-BYP5D4HI.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/config.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function settingsPath() {
+  return join(clioConfigDir(), "settings.yaml");
+}
+function issuesKind(issues) {
+  return issues[0]?.kind ?? "schema";
+}
+function settingsRemedy(kind, path) {
+  if (kind === "unreadable") return `Restore read access to ${path}, then run \`clio-coder doctor\` to re-check.`;
+  if (kind === "syntax") return `Fix the YAML in ${path}, then run \`clio-coder doctor\` to re-check.`;
+  return `Fix the keys above in ${path}, then run \`clio-coder doctor\` to re-check.`;
+}
+function settingsRemedyInline(kind, path) {
+  if (kind === "unreadable") return `restore read access to ${path}`;
+  if (kind === "syntax") return `fix the YAML in ${path}`;
+  return `edit the named keys in ${path}`;
+}
+var SettingsValidationError = class extends Error {
+  issues;
+  /**
+   * The headline and the remedy both follow the failure kind. A file that
+   * cannot be read has no key at fault, so telling its reader to "fix the keys
+   * above" named a repair that does not exist for the problem they have.
+   */
+  constructor(issues) {
+    const path = join(resolveClioDirs().config, "settings.yaml");
+    const kind = issuesKind(issues);
+    const lines = kind === "schema" ? issues.map((issue) => `  ${issue.path}: ${issue.message}`) : issues.map((issue) => `  ${issue.message}`);
+    const headline = kind === "schema" ? "settings.yaml failed validation:" : "settings.yaml cannot be loaded:";
+    super(
+      `${headline}
+${lines.join("\n")}
+
+${settingsRemedy(kind, path)}
+\`clio-coder doctor --fix\` repairs directories and credential permissions; it never rewrites settings.
+To discard these settings and start from defaults instead, run \`clio-coder reset --config --force\`.`
+    );
+    this.name = "SettingsValidationError";
+    this.issues = issues;
+  }
+};
+function foldToOneLine(text) {
+  return text.replace(/\s*\n\s*/g, " ").trim();
+}
+function yamlErrorSummary(error) {
+  const raw = error instanceof Error ? error.message : String(error);
+  return (raw.split("\n")[0] ?? raw).trim().replace(/:$/u, "");
+}
+function settingsFailureHeadline(kind) {
+  if (kind === "unreadable") return "settings.yaml cannot be read";
+  if (kind === "syntax") return "settings.yaml is not valid YAML";
+  return "settings.yaml failed validation";
+}
+function formatSettingsIssues(issues) {
+  if (issues.length === 0) return "";
+  const path = join(resolveClioDirs().config, "settings.yaml");
+  const kind = issuesKind(issues);
+  const detail = kind === "schema" ? issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ") : issues.map((issue) => issue.message.replace(/^(?:invalid YAML|unreadable): /u, "")).join("; ");
+  const discard = "`clio-coder reset --config --force` to start from defaults";
+  return foldToOneLine(
+    `${settingsFailureHeadline(kind)}: ${settingsRemedyInline(kind, path)}, or ${discard}. ${detail}`
+  );
+}
+function formatSettingsFailure(error) {
+  if (error instanceof SettingsValidationError && error.issues.length > 0) return formatSettingsIssues(error.issues);
+  return foldToOneLine(error instanceof Error ? error.message : String(error));
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneValue(value) {
+  return structuredClone(value);
+}
+var Issues = class {
+  list = [];
+  add(path, message) {
+    this.list.push({ path, message });
+  }
+  unknownKeys(path, raw, known) {
+    const knownSet = new Set(known);
+    for (const key of Object.keys(raw)) {
+      if (!knownSet.has(key)) this.add(path ? `${path}.${key}` : key, "unknown key");
+    }
+  }
+  /**
+   * A key that used to be honored and is not any more. `unknown key` is the
+   * true answer for a typo and the wrong one here: the operator wrote a real
+   * key that a real release read, and the useful thing to tell them is what
+   * replaced it, not that the schema has never heard of it. The keys stay
+   * listed as known at their {@link unknownKeys} call so this message is the
+   * one that lands.
+   */
+  retiredKeys(path, raw, retired) {
+    for (const [key, because] of Object.entries(retired)) {
+      if (key in raw) this.add(path ? `${path}.${key}` : key, `retired: ${because}. Remove this key.`);
+    }
+  }
+};
+function expectString(issues, path, value) {
+  if (typeof value !== "string") {
+    issues.add(path, `expected a string, got ${describe(value)}`);
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    issues.add(path, "expected a non-empty string");
+    return void 0;
+  }
+  return trimmed;
+}
+function expectBoolean(issues, path, value) {
+  if (typeof value !== "boolean") {
+    issues.add(path, `expected a boolean, got ${describe(value)}`);
+    return void 0;
+  }
+  return value;
+}
+function expectNumber(issues, path, value, opts) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    issues.add(path, `expected a number, got ${describe(value)}`);
+    return void 0;
+  }
+  if (opts?.min !== void 0 && value < opts.min) {
+    issues.add(path, `expected a number >= ${opts.min}, got ${value}`);
+    return void 0;
+  }
+  if (opts?.max !== void 0 && value > opts.max) {
+    issues.add(path, `expected a number <= ${opts.max}, got ${value}`);
+    return void 0;
+  }
+  return value;
+}
+function expectInteger(issues, path, value, opts) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    issues.add(path, `expected an integer, got ${describe(value)}`);
+    return void 0;
+  }
+  if (opts?.min !== void 0 && value < opts.min) {
+    issues.add(path, `expected an integer >= ${opts.min}, got ${value}`);
+    return void 0;
+  }
+  if (opts?.max !== void 0 && value > opts.max) {
+    issues.add(path, `expected an integer <= ${opts.max}, got ${value}`);
+    return void 0;
+  }
+  return value;
+}
+function expectEnum(issues, path, value, allowed) {
+  if (typeof value === "string" && allowed.includes(value)) return value;
+  issues.add(path, `expected one of ${allowed.join(" | ")}, got ${describe(value)}`);
+  return void 0;
+}
+function expectStringArray(issues, path, value) {
+  if (!Array.isArray(value)) {
+    issues.add(path, `expected a list of strings, got ${describe(value)}`);
+    return void 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 0; i < value.length; i += 1) {
+    const entry = expectString(issues, `${path}[${i}]`, value[i]);
+    if (entry === void 0) continue;
+    if (seen.has(entry)) continue;
+    seen.add(entry);
+    out.push(entry);
+  }
+  return out;
+}
+function expectStringRecord(issues, path, value) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a string map, got ${describe(value)}`);
+    return void 0;
+  }
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    const entry = expectString(issues, `${path}.${key}`, raw);
+    if (entry !== void 0) out[key] = entry;
+  }
+  return out;
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "a list";
+  if (typeof value === "object") return "a map";
+  if (typeof value === "string") return value.trim().length === 0 ? "an empty string" : JSON.stringify(value);
+  return String(value);
+}
+var TOOL_CALL_FORMATS = ["openai", "anthropic", "hermes", "llama3-json", "mistral", "qwen", "xml"];
+var THINKING_FORMATS = [
+  "qwen-chat-template",
+  "openrouter",
+  "zai",
+  "anthropic-extended",
+  "deepseek-r1",
+  "openai-codex",
+  "harmony"
+];
+var STRUCTURED_OUTPUTS = ["json-schema", "gbnf", "xgrammar", "none"];
+var AUTONOMY_LEVELS = ["read-only", "suggest", "auto-edit", "full-auto"];
+var TOOL_GOVERNANCE = ["clio-coder-policy", "agent-managed", "deny-all"];
+function normalizeLegacyNamingValue(value, legacy, canonical) {
+  if (value !== legacy) return value;
+  warnLegacyNaming(legacy, canonical);
+  return canonical;
+}
+function validateCapabilities(issues, path, value) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return void 0;
+  }
+  issues.unknownKeys(path, value, [
+    "chat",
+    "tools",
+    "toolCallFormat",
+    "reasoning",
+    "thinkingFormat",
+    "structuredOutputs",
+    "vision",
+    "audio",
+    "embeddings",
+    "rerank",
+    "fim",
+    "contextWindow",
+    "maxTokens"
+  ]);
+  const out = {};
+  for (const key of ["chat", "tools", "reasoning", "vision", "audio", "embeddings", "rerank", "fim"]) {
+    if (key in value) {
+      const v = expectBoolean(issues, `${path}.${key}`, value[key]);
+      if (v !== void 0) out[key] = v;
+    }
+  }
+  if ("toolCallFormat" in value) {
+    const v = expectEnum(issues, `${path}.toolCallFormat`, value.toolCallFormat, TOOL_CALL_FORMATS);
+    if (v !== void 0) out.toolCallFormat = v;
+  }
+  if ("thinkingFormat" in value) {
+    const v = expectEnum(issues, `${path}.thinkingFormat`, value.thinkingFormat, THINKING_FORMATS);
+    if (v !== void 0) out.thinkingFormat = v;
+  }
+  if ("structuredOutputs" in value) {
+    const v = expectEnum(issues, `${path}.structuredOutputs`, value.structuredOutputs, STRUCTURED_OUTPUTS);
+    if (v !== void 0) out.structuredOutputs = v;
+  }
+  if ("contextWindow" in value) {
+    const v = expectInteger(issues, `${path}.contextWindow`, value.contextWindow, { min: 0 });
+    if (v !== void 0) out.contextWindow = v;
+  }
+  if ("maxTokens" in value) {
+    const v = expectInteger(issues, `${path}.maxTokens`, value.maxTokens, { min: 0 });
+    if (v !== void 0) out.maxTokens = v;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function validateAuth(issues, path, value) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return void 0;
+  }
+  issues.unknownKeys(path, value, ["apiKeyEnvVar", "apiKeyRef", "oauthProfile", "headers"]);
+  const out = {};
+  for (const key of ["apiKeyEnvVar", "apiKeyRef", "oauthProfile"]) {
+    if (key in value) {
+      const v = expectString(issues, `${path}.${key}`, value[key]);
+      if (v !== void 0) out[key] = v;
+    }
+  }
+  if ("headers" in value) {
+    const v = expectStringRecord(issues, `${path}.headers`, value.headers);
+    if (v !== void 0 && Object.keys(v).length > 0) out.headers = v;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function validatePricing(issues, path, value) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return void 0;
+  }
+  issues.unknownKeys(path, value, ["input", "output", "cacheRead", "cacheWrite"]);
+  const input = expectNumber(issues, `${path}.input`, value.input, { min: 0 });
+  const output = expectNumber(issues, `${path}.output`, value.output, { min: 0 });
+  if (input === void 0 || output === void 0) return void 0;
+  const out = { input, output };
+  if ("cacheRead" in value) {
+    const v = expectNumber(issues, `${path}.cacheRead`, value.cacheRead, { min: 0 });
+    if (v !== void 0) out.cacheRead = v;
+  }
+  if ("cacheWrite" in value) {
+    const v = expectNumber(issues, `${path}.cacheWrite`, value.cacheWrite, { min: 0 });
+    if (v !== void 0) out.cacheWrite = v;
+  }
+  return out;
+}
+function validateLmStudioSettings(issues, path, value) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return void 0;
+  }
+  issues.unknownKeys(path, value, ["load", "request"]);
+  const out = {};
+  if ("load" in value) {
+    if (!isPlainObject(value.load)) {
+      issues.add(`${path}.load`, `expected a map, got ${describe(value.load)}`);
+    } else {
+      issues.unknownKeys(`${path}.load`, value.load, [
+        "contextLength",
+        "flashAttention",
+        "evalBatchSize",
+        "numExperts",
+        "offloadKvCacheToGpu"
+      ]);
+      const load = {};
+      for (const key of ["contextLength", "evalBatchSize", "numExperts"]) {
+        if (key in value.load) {
+          const parsed = expectInteger(issues, `${path}.load.${key}`, value.load[key], { min: 1 });
+          if (parsed !== void 0) load[key] = parsed;
+        }
+      }
+      for (const key of ["flashAttention", "offloadKvCacheToGpu"]) {
+        if (key in value.load) {
+          const parsed = expectBoolean(issues, `${path}.load.${key}`, value.load[key]);
+          if (parsed !== void 0) load[key] = parsed;
+        }
+      }
+      if (Object.keys(load).length > 0) out.load = load;
+    }
+  }
+  if ("request" in value) {
+    if (!isPlainObject(value.request)) {
+      issues.add(`${path}.request`, `expected a map, got ${describe(value.request)}`);
+    } else {
+      issues.unknownKeys(`${path}.request`, value.request, ["ttlSeconds", "draftModel", "reasoning"]);
+      const request = {};
+      if ("ttlSeconds" in value.request) {
+        const parsed = expectInteger(issues, `${path}.request.ttlSeconds`, value.request.ttlSeconds, { min: 1 });
+        if (parsed !== void 0) request.ttlSeconds = parsed;
+      }
+      if ("draftModel" in value.request) {
+        const parsed = expectString(issues, `${path}.request.draftModel`, value.request.draftModel);
+        if (parsed !== void 0) request.draftModel = parsed;
+      }
+      if ("reasoning" in value.request) {
+        const parsed = expectEnum(issues, `${path}.request.reasoning`, value.request.reasoning, [
+          "auto",
+          "off",
+          "on",
+          "low",
+          "medium",
+          "high"
+        ]);
+        if (parsed !== void 0) request.reasoning = parsed;
+      }
+      if (Object.keys(request).length > 0) out.request = request;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function validateTarget(issues, path, value) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return null;
+  }
+  issues.unknownKeys(path, value, [
+    "id",
+    "runtime",
+    "url",
+    "auth",
+    "defaultModel",
+    "wireModels",
+    "capabilities",
+    "lifecycle",
+    "gateway",
+    "pricing",
+    "lmstudio",
+    "maxConcurrentRequests"
+  ]);
+  const id = "id" in value ? expectString(issues, `${path}.id`, value.id) : void 0;
+  const runtime = "runtime" in value ? expectString(issues, `${path}.runtime`, value.runtime) : void 0;
+  if (!("id" in value)) issues.add(`${path}.id`, "required");
+  if (!("runtime" in value)) issues.add(`${path}.runtime`, "required");
+  if (id === void 0 || runtime === void 0) return null;
+  const target = { id, runtime };
+  if ("url" in value) {
+    const v = expectString(issues, `${path}.url`, value.url);
+    if (v !== void 0) target.url = v;
+  }
+  if ("auth" in value) {
+    const v = validateAuth(issues, `${path}.auth`, value.auth);
+    if (v !== void 0) target.auth = v;
+  }
+  if ("wireModels" in value) {
+    const v = expectStringArray(issues, `${path}.wireModels`, value.wireModels);
+    if (v !== void 0 && v.length > 0) target.wireModels = v;
+  }
+  if ("defaultModel" in value) {
+    const v = expectString(issues, `${path}.defaultModel`, value.defaultModel);
+    if (v !== void 0) target.defaultModel = v;
+  } else if (target.wireModels?.[0]) {
+    target.defaultModel = target.wireModels[0];
+  }
+  if ("capabilities" in value) {
+    const v = validateCapabilities(issues, `${path}.capabilities`, value.capabilities);
+    if (v !== void 0) target.capabilities = v;
+  }
+  if ("lifecycle" in value) {
+    const v = expectEnum(
+      issues,
+      `${path}.lifecycle`,
+      normalizeLegacyNamingValue(value.lifecycle, "clio-managed", "clio-coder-managed"),
+      ["user-managed", "clio-coder-managed"]
+    );
+    if (v !== void 0) target.lifecycle = v;
+  }
+  if ("gateway" in value) {
+    const v = expectBoolean(issues, `${path}.gateway`, value.gateway);
+    if (v !== void 0) target.gateway = v;
+  }
+  if ("pricing" in value) {
+    const v = validatePricing(issues, `${path}.pricing`, value.pricing);
+    if (v !== void 0) target.pricing = v;
+  }
+  if ("lmstudio" in value) {
+    const v = validateLmStudioSettings(issues, `${path}.lmstudio`, value.lmstudio);
+    if (v !== void 0) target.lmstudio = v;
+  }
+  if ("maxConcurrentRequests" in value) {
+    const v = expectInteger(issues, `${path}.maxConcurrentRequests`, value.maxConcurrentRequests, { min: 1 });
+    if (v !== void 0) target.maxConcurrentRequests = v;
+  }
+  return target;
+}
+var SETTINGS_V1_PATH_MOVES = Object.freeze([
+  ["autonomy", "safety.autonomy"],
+  ["orchestrator.target", "chat.target"],
+  ["orchestrator.model", "chat.model"],
+  ["orchestrator.thinkingLevel", "chat.thinkingLevel"],
+  ["scope[]", "chat.modelPicker.cycleSet[]"],
+  ["modelSelector.favorites[]", "chat.modelPicker.favorites[]"],
+  ["modelSelector.recentLimit", "chat.modelPicker.recentLimit"],
+  ["defaults.maxTokens", "chat.maxOutputTokens"],
+  ["prewarm.enabled", "chat.prewarm"],
+  ["retry.enabled", "chat.retry.enabled"],
+  ["retry.maxRetries", "chat.retry.maxRetries"],
+  ["retry.baseDelayMs", "chat.retry.baseDelayMs"],
+  ["retry.maxDelayMs", "chat.retry.maxDelayMs"],
+  ["retry.streamStallMs", "chat.retry.streamStallMs"],
+  ["workers.default.target", "fleet.default.target"],
+  ["workers.default.model", "fleet.default.model"],
+  ["workers.default.thinkingLevel", "fleet.default.thinkingLevel"],
+  ["workers.default.node", "fleet.default.node"],
+  ["workers.profiles.*.target", "fleet.profiles.*.target"],
+  ["workers.profiles.*.model", "fleet.profiles.*.model"],
+  ["workers.profiles.*.thinkingLevel", "fleet.profiles.*.thinkingLevel"],
+  ["workers.profiles.*.node", "fleet.profiles.*.node"],
+  ["workers.rosters.*.members[].label", "fleet.rosters.*.members[].label"],
+  ["workers.rosters.*.members[].target", "fleet.rosters.*.members[].target"],
+  ["workers.rosters.*.members[].model", "fleet.rosters.*.members[].model"],
+  ["workers.rosters.*.members[].thinking", "fleet.rosters.*.members[].thinkingLevel"],
+  ["workers.rosters.*.members[].color", "fleet.rosters.*.members[].color"],
+  ["workers.agentBindings.*", "fleet.agentProfiles.*"],
+  ["routing.activeRoles[]", "fleet.adaptiveRouting.roles[]"],
+  ["routing.activePostures[]", "fleet.adaptiveRouting.postures[]"],
+  ["routing.agentAutomation.activeAgentRoles[].agentId", "fleet.adaptiveRouting.agentRoles[].agentId"],
+  ["routing.agentAutomation.activeAgentRoles[].executionRole", "fleet.adaptiveRouting.agentRoles[].executionRole"],
+  ["budget.concurrency", "fleet.concurrency"],
+  ["workers.maxRetries", "fleet.retry.maxRetries"],
+  ["workers.resilienceCooldownMs", "fleet.retry.routeCooldownMs"],
+  ["workers.onPermission", "fleet.permissions.mode"],
+  ["workers.escalation.timeoutMs", "fleet.permissions.escalation.timeoutMs"],
+  ["workers.escalation.fallback", "fleet.permissions.escalation.fallback"],
+  ["guardrails.workerToolCallCap", "fleet.limits.toolCallsPerRun"],
+  ["guardrails.internalDispatchTimeoutMs", "fleet.limits.internalRunTimeoutMs"],
+  ["guardrails.maxDispatchRuns", "fleet.history.maxRuns"],
+  ["compaction.auto", "context.compaction.auto"],
+  ["compaction.threshold", "context.compaction.threshold"],
+  ["compaction.model", "context.compaction.model"],
+  ["compaction.systemPrompt", "context.compaction.systemPrompt"],
+  ["background.target", "context.memory.target"],
+  ["background.model", "context.memory.model"],
+  ["memory.intervention.enabled", "context.memory.enabled"],
+  ["memory.intervention.everyNTools", "context.memory.cadenceToolCalls"],
+  ["memory.intervention.windowSteps", "context.memory.trajectorySteps"],
+  ["memory.intervention.maxTokens", "context.memory.maxOutputTokens"],
+  ["memory.intervention.timeoutMs", "context.memory.timeoutMs"],
+  ["budget.sessionCeilingUsd", "safety.limits.sessionCostUsd"],
+  ["guardrails.turnToolCallBudget", "safety.limits.chatToolCallsPerTurn"],
+  ["guardrails.readMaxBytes", "safety.limits.readBytesPerCall"],
+  ["guardrails.observationTurnBudgetBytes", "safety.limits.observationBytesPerTurn"],
+  ["watchdog.enabled", "safety.review.enabled"],
+  ["watchdog.target", "safety.review.target"],
+  ["watchdog.cadenceToolCalls", "safety.review.cadenceToolCalls"],
+  ["terminal.outputVerbosity", "interface.outputDetail"],
+  ["terminal.smoothStreaming", "interface.smoothStreaming"],
+  ["terminal.tuiMode", "interface.mode"],
+  ["terminal.fullscreenScrollbar", "interface.fullscreenScrollbar"],
+  ["terminal.showTerminalProgress", "interface.terminalProgress"],
+  ["terminal.notify", "interface.desktopNotifications"],
+  // The panes keys shipped for exactly one release (v0.4.0, the day before
+  // this rework) but they did ship, and each has a direct v2 successor with
+  // an identical value domain, so they move like everything else. The
+  // retired agents/keepFailed pair and the `panes` root itself stay in
+  // SETTINGS_V1_RETIRED-adjacent handling via V1_ONLY_ROOTS.
+  ["panes.enabled", "interface.panes.enabled"],
+  ["panes.notifications", "interface.panes.notifications"],
+  ["panes.journal", "fleet.history.journal"],
+  ["panes.yazi.enabled", "interface.panes.files.enabled"],
+  ["panes.yazi.mode", "interface.panes.files.mode"],
+  ["panes.yazi.profile", "interface.panes.files.profile"],
+  ["panes.yazi.followCwd", "interface.panes.files.followCwd"],
+  ["keybindings.*", "interface.keybindings.*"],
+  ["skills.trustProjectCompatRoots", "integrations.projectResources.trustProjectImports"],
+  ["delegation.defaults.connectTimeoutMs", "integrations.externalAgents.defaults.connectTimeoutMs"],
+  ["delegation.defaults.turnTimeoutMs", "integrations.externalAgents.defaults.turnTimeoutMs"],
+  ["delegation.defaults.permissionTimeoutMs", "integrations.externalAgents.defaults.permissionTimeoutMs"],
+  ["delegation.defaults.toolGovernance", "integrations.externalAgents.defaults.toolGovernance"],
+  ["delegation.agents[].id", "integrations.externalAgents.entries[].id"],
+  ["delegation.agents[].command", "integrations.externalAgents.entries[].command"],
+  ["delegation.agents[].args[]", "integrations.externalAgents.entries[].args[]"],
+  ["delegation.agents[].cwd", "integrations.externalAgents.entries[].cwd"],
+  ["delegation.agents[].env.*", "integrations.externalAgents.entries[].env.*"],
+  ["delegation.agents[].connectTimeoutMs", "integrations.externalAgents.entries[].connectTimeoutMs"],
+  ["delegation.agents[].turnTimeoutMs", "integrations.externalAgents.entries[].turnTimeoutMs"],
+  ["delegation.agents[].permissionTimeoutMs", "integrations.externalAgents.entries[].permissionTimeoutMs"],
+  ["delegation.agents[].stallTimeoutMs", "integrations.externalAgents.entries[].stallTimeoutMs"],
+  ["delegation.agents[].toolGovernance", "integrations.externalAgents.entries[].toolGovernance"],
+  ["delegation.agents[].projectContext", "integrations.externalAgents.entries[].projectContext"],
+  ["delegation.agents[].labels.*", "integrations.externalAgents.entries[].labels.*"],
+  ["runtimePlugins[]", "integrations.runtimePlugins[]"],
+  ["library.catalog", "integrations.library.catalog"],
+  ["library.remote", "integrations.library.remote"],
+  ["library.confirmedRemote", "integrations.library.confirmedRemote"],
+  ["library.sync", "integrations.library.sync"],
+  ["attribution.gitCommits", "integrations.git.commitAttribution"],
+  ["fleet.nodes[].clioEntry", "fleet.nodes[].clioCoderEntry"]
+]);
+var SETTINGS_V1_RETIRED_PATHS = Object.freeze({
+  identity: "it was accepted and ignored; no behavior is lost",
+  "background.thinkingLevel": "proactive memory always resolves thinking off",
+  theme: "the only registered theme was not read by runtime rendering",
+  "compaction.excludeLastTurns": "only the temporary legacy mask used it; context.workingSet.protectLastTurns remains"
+});
+var V1_ONLY_ROOTS = /* @__PURE__ */ new Set([
+  "identity",
+  "autonomy",
+  "runtimePlugins",
+  "orchestrator",
+  "background",
+  "memory",
+  "watchdog",
+  "workers",
+  "routing",
+  "scope",
+  "modelSelector",
+  "budget",
+  "defaults",
+  "theme",
+  "terminal",
+  "skills",
+  "library",
+  "attribution",
+  "delegation",
+  "keybindings",
+  "compaction",
+  "prewarm",
+  "panes",
+  "retry",
+  "guardrails"
+]);
+function pathPatternSegments(pattern) {
+  return pattern.split(".");
+}
+function patternMatches(value, pattern) {
+  const out = [];
+  const visit = (current, segments, path) => {
+    const segment = segments[0];
+    if (segment === void 0) {
+      out.push({ path });
+      return;
+    }
+    const rest = segments.slice(1);
+    if (segment === "*") {
+      if (!isPlainObject(current)) return;
+      for (const [key2, child2] of Object.entries(current)) visit(child2, rest, path ? `${path}.${key2}` : key2);
+      return;
+    }
+    const list = segment.endsWith("[]");
+    const key = list ? segment.slice(0, -2) : segment;
+    if (!isPlainObject(current) || !(key in current)) return;
+    const child = current[key];
+    const nextPath = path ? `${path}.${key}` : key;
+    if (!list) {
+      visit(child, rest, nextPath);
+      return;
+    }
+    if (!Array.isArray(child)) return;
+    for (let index = 0; index < child.length; index += 1) visit(child[index], rest, `${nextPath}[${index}]`);
+  };
+  visit(value, pathPatternSegments(pattern), "");
+  return out;
+}
+function reportV1Tombstones(issues, raw) {
+  const reportedRoots = /* @__PURE__ */ new Set();
+  for (const [from, to] of SETTINGS_V1_PATH_MOVES) {
+    for (const match of patternMatches(raw, from)) {
+      issues.add(match.path, `retired settings-v1 path; use ${to} in version 2`);
+      reportedRoots.add(match.path.split(/[.[]/u)[0] ?? match.path);
+    }
+  }
+  for (const [path, reason] of Object.entries(SETTINGS_V1_RETIRED_PATHS)) {
+    for (const match of patternMatches(raw, path)) {
+      issues.add(match.path, `retired without replacement: ${reason}. Remove this key`);
+      reportedRoots.add(match.path.split(/[.[]/u)[0] ?? match.path);
+    }
+  }
+  for (const root of V1_ONLY_ROOTS) {
+    if (root in raw && !reportedRoots.has(root)) {
+      const replacements = new Set(
+        SETTINGS_V1_PATH_MOVES.filter(([from]) => from.split(/[.[]/u)[0] === root).map(
+          ([, to]) => to.split(/[.[]/u)[0] ?? to
+        )
+      );
+      const hint = replacements.size > 0 ? `; use ${[...replacements].join(" or ")} in version 2` : "";
+      issues.add(root, `retired settings-v1 namespace${hint}; migrate this document with \`clio-coder upgrade\``);
+    }
+  }
+}
+function validateRoute(issues, path, value, defaults, targets, options) {
+  const out = cloneValue(defaults);
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return out;
+  }
+  const allowNode = options?.nodeIds !== void 0;
+  issues.unknownKeys(
+    path,
+    value,
+    allowNode ? ["target", "model", "thinkingLevel", "node"] : ["target", "model", "thinkingLevel"]
+  );
+  if ("target" in value) {
+    if (value.target === null) out.target = null;
+    else {
+      const parsed = expectString(issues, `${path}.target`, value.target);
+      if (parsed !== void 0) out.target = targets.some((entry) => entry.id === parsed) ? parsed : null;
+    }
+  }
+  if ("model" in value) {
+    if (value.model === null) out.model = null;
+    else {
+      const parsed = expectString(issues, `${path}.model`, value.model);
+      if (parsed !== void 0) out.model = parsed;
+    }
+  }
+  if ("thinkingLevel" in value) {
+    const parsed = expectEnum(issues, `${path}.thinkingLevel`, value.thinkingLevel, THINKING_LEVELS);
+    if (parsed !== void 0) out.thinkingLevel = parsed;
+  }
+  if (allowNode && "node" in value) {
+    if (value.node === null) delete out.node;
+    else {
+      const parsed = expectString(issues, `${path}.node`, value.node);
+      if (parsed !== void 0 && (parsed === "local" || options.nodeIds?.has(parsed) === true)) out.node = parsed;
+    }
+  }
+  if (!out.target) out.model = null;
+  else if (out.model === null) out.model = targets.find((entry) => entry.id === out.target)?.defaultModel ?? null;
+  return out;
+}
+function normalizeModelRefs(refs, targets) {
+  const targetIds = new Set(targets.map((target) => target.id));
+  return refs.filter((ref) => {
+    const [targetId, ...model] = ref.split("/");
+    return Boolean(targetId && targetIds.has(targetId) && model.join("/").trim());
+  });
+}
+function normalizeCycleSet(refs) {
+  return refs.filter((ref) => Boolean(ref.trim().split("/")[0]));
+}
+function validateExternalAgent(issues, path, value, defaults, seen) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return null;
+  }
+  issues.unknownKeys(path, value, [
+    "id",
+    "command",
+    "args",
+    "cwd",
+    "env",
+    "connectTimeoutMs",
+    "turnTimeoutMs",
+    "permissionTimeoutMs",
+    "stallTimeoutMs",
+    "toolGovernance",
+    "projectContext",
+    "labels"
+  ]);
+  const id = "id" in value ? expectString(issues, `${path}.id`, value.id) : void 0;
+  const command = "command" in value ? expectString(issues, `${path}.command`, value.command) : void 0;
+  if (!("id" in value)) issues.add(`${path}.id`, "required");
+  if (!("command" in value)) issues.add(`${path}.command`, "required");
+  if (id === void 0 || command === void 0) return null;
+  if (id === "auto") {
+    issues.add(`${path}.id`, "'auto' is reserved for coordinator-owned agent selection");
+    return null;
+  }
+  if (seen.has(id)) {
+    issues.add(`${path}.id`, `duplicate external agent id '${id}'`);
+    return null;
+  }
+  seen.add(id);
+  const agent = {
+    id,
+    command,
+    args: [],
+    connectTimeoutMs: defaults.connectTimeoutMs,
+    turnTimeoutMs: defaults.turnTimeoutMs,
+    permissionTimeoutMs: defaults.permissionTimeoutMs,
+    toolGovernance: defaults.toolGovernance
+  };
+  if ("args" in value) {
+    const parsed = expectStringArray(issues, `${path}.args`, value.args);
+    if (parsed !== void 0) agent.args = parsed;
+  }
+  for (const key of ["connectTimeoutMs", "turnTimeoutMs", "permissionTimeoutMs"]) {
+    if (!(key in value)) continue;
+    const parsed = expectInteger(issues, `${path}.${key}`, value[key], { min: 1, max: MAX_TIMER_DELAY_MS });
+    if (parsed !== void 0) agent[key] = parsed;
+  }
+  if ("stallTimeoutMs" in value) {
+    const parsed = expectInteger(issues, `${path}.stallTimeoutMs`, value.stallTimeoutMs);
+    if (parsed !== void 0) agent.stallTimeoutMs = parsed;
+  }
+  if ("toolGovernance" in value) {
+    const parsed = expectEnum(
+      issues,
+      `${path}.toolGovernance`,
+      normalizeLegacyNamingValue(value.toolGovernance, "clio-policy", "clio-coder-policy"),
+      TOOL_GOVERNANCE
+    );
+    if (parsed !== void 0) agent.toolGovernance = parsed;
+  }
+  if ("projectContext" in value) {
+    const parsed = expectEnum(issues, `${path}.projectContext`, value.projectContext, ["none", "bounded"]);
+    if (parsed !== void 0) agent.projectContext = parsed;
+  }
+  for (const key of ["cwd"]) {
+    if (!(key in value)) continue;
+    const parsed = expectString(issues, `${path}.${key}`, value[key]);
+    if (parsed !== void 0) agent[key] = parsed;
+  }
+  for (const key of ["env", "labels"]) {
+    if (!(key in value)) continue;
+    const parsed = expectStringRecord(issues, `${path}.${key}`, value[key]);
+    if (parsed !== void 0 && Object.keys(parsed).length > 0) agent[key] = parsed;
+  }
+  return agent;
+}
+function validateFleetNode(issues, path, value, seen) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return null;
+  }
+  issues.unknownKeys(path, value, [
+    "id",
+    "host",
+    "user",
+    "port",
+    "identityFile",
+    "clioCoderEntry",
+    "clioEntry",
+    "labels",
+    "maxWorkers",
+    "residency"
+  ]);
+  const id = "id" in value ? expectString(issues, `${path}.id`, value.id) : void 0;
+  const host = "host" in value ? expectString(issues, `${path}.host`, value.host) : void 0;
+  if (!("id" in value)) issues.add(`${path}.id`, "required");
+  if (!("host" in value)) issues.add(`${path}.host`, "required");
+  if (id === void 0 || host === void 0) return null;
+  if (id === "local") {
+    issues.add(`${path}.id`, "'local' is reserved for the implicit local node");
+    return null;
+  }
+  if (seen.has(id)) {
+    issues.add(`${path}.id`, `duplicate fleet node id '${id}'`);
+    return null;
+  }
+  seen.add(id);
+  const node = { id, host, maxWorkers: 2 };
+  for (const key of ["user", "identityFile", "clioCoderEntry"]) {
+    if (!(key in value)) continue;
+    const parsed = expectString(issues, `${path}.${key}`, value[key]);
+    if (parsed !== void 0) node[key] = parsed;
+  }
+  if ("port" in value) {
+    const parsed = expectInteger(issues, `${path}.port`, value.port, { min: 1 });
+    if (parsed !== void 0) node.port = parsed;
+  }
+  if ("labels" in value) {
+    const parsed = expectStringArray(issues, `${path}.labels`, value.labels);
+    if (parsed !== void 0) node.labels = parsed;
+  }
+  if ("maxWorkers" in value) {
+    const parsed = expectInteger(issues, `${path}.maxWorkers`, value.maxWorkers, { min: 1 });
+    if (parsed !== void 0) node.maxWorkers = parsed;
+  }
+  if ("residency" in value) {
+    const parsed = expectEnum(issues, `${path}.residency`, value.residency, ["observe", "manage"]);
+    if (parsed !== void 0) node.residency = parsed;
+  }
+  return node;
+}
+function validateKeybindings(issues, path, value) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return {};
+  }
+  const next = {};
+  for (const [rawKey, rawValue] of Object.entries(value)) {
+    const legacyId = rawKey.trim();
+    const id = legacyId.startsWith("clio.") ? `clio-coder.${legacyId.slice("clio.".length)}` : legacyId;
+    if (!id) {
+      issues.add(path, "empty keybinding id");
+      continue;
+    }
+    if (id !== legacyId) {
+      warnLegacyNaming(legacyId, id);
+      if (Object.hasOwn(value, id)) continue;
+    }
+    if (typeof rawValue === "string") {
+      const parsed = expectString(issues, `${path}.${legacyId}`, rawValue);
+      if (parsed !== void 0) next[id] = parsed;
+    } else if (Array.isArray(rawValue)) {
+      const parsed = expectStringArray(issues, `${path}.${legacyId}`, rawValue);
+      if (parsed !== void 0 && parsed.length > 0) next[id] = parsed;
+    } else issues.add(`${path}.${legacyId}`, `expected a string or list of strings, got ${describe(rawValue)}`);
+  }
+  return next;
+}
+var TOP_LEVEL_KEYS = [
+  "version",
+  "targets",
+  "chat",
+  "fleet",
+  "context",
+  "safety",
+  "interface",
+  "integrations",
+  ...V1_ONLY_ROOTS
+];
+function validateSettings(raw) {
+  const issues = new Issues();
+  const settings = cloneValue(DEFAULT_SETTINGS);
+  if (!isPlainObject(raw)) {
+    issues.add("(root)", `expected a map, got ${describe(raw)}`);
+    return { settings, issues: issues.list };
+  }
+  reportV1Tombstones(issues, raw);
+  issues.unknownKeys("", raw, TOP_LEVEL_KEYS);
+  if ("version" in raw && raw.version !== 2) {
+    issues.add("version", `expected 2, got ${describe(raw.version)}; run \`clio-coder upgrade\` for version 1`);
+  }
+  if ("targets" in raw) {
+    if (!Array.isArray(raw.targets)) issues.add("targets", `expected a list, got ${describe(raw.targets)}`);
+    else {
+      const seen = /* @__PURE__ */ new Set();
+      const targets = [];
+      for (let index = 0; index < raw.targets.length; index += 1) {
+        const target = validateTarget(issues, `targets[${index}]`, raw.targets[index]);
+        if (!target) continue;
+        if (seen.has(target.id)) {
+          issues.add(`targets[${index}].id`, `duplicate target id '${target.id}'`);
+          continue;
+        }
+        seen.add(target.id);
+        targets.push(target);
+      }
+      settings.targets = targets;
+    }
+  }
+  if ("chat" in raw) {
+    if (!isPlainObject(raw.chat)) issues.add("chat", `expected a map, got ${describe(raw.chat)}`);
+    else {
+      const chat = raw.chat;
+      issues.unknownKeys("chat", chat, [
+        "target",
+        "model",
+        "thinkingLevel",
+        "modelPicker",
+        "maxOutputTokens",
+        "prewarm",
+        "retry"
+      ]);
+      const routeInput = {};
+      for (const key of ["target", "model", "thinkingLevel"]) {
+        if (key in chat) routeInput[key] = chat[key];
+      }
+      const route = validateRoute(
+        issues,
+        "chat",
+        routeInput,
+        { target: settings.chat.target, model: settings.chat.model, thinkingLevel: settings.chat.thinkingLevel },
+        settings.targets
+      );
+      settings.chat.target = route.target;
+      settings.chat.model = route.model;
+      settings.chat.thinkingLevel = route.thinkingLevel;
+      if ("modelPicker" in chat) {
+        if (!isPlainObject(chat.modelPicker))
+          issues.add("chat.modelPicker", `expected a map, got ${describe(chat.modelPicker)}`);
+        else {
+          issues.unknownKeys("chat.modelPicker", chat.modelPicker, ["cycleSet", "favorites", "recentLimit"]);
+          if ("cycleSet" in chat.modelPicker) {
+            const parsed = expectStringArray(issues, "chat.modelPicker.cycleSet", chat.modelPicker.cycleSet);
+            if (parsed !== void 0) settings.chat.modelPicker.cycleSet = normalizeCycleSet(parsed);
+          }
+          if ("favorites" in chat.modelPicker) {
+            const parsed = expectStringArray(issues, "chat.modelPicker.favorites", chat.modelPicker.favorites);
+            if (parsed !== void 0) settings.chat.modelPicker.favorites = normalizeModelRefs(parsed, settings.targets);
+          }
+          if ("recentLimit" in chat.modelPicker) {
+            const parsed = expectInteger(issues, "chat.modelPicker.recentLimit", chat.modelPicker.recentLimit, { min: 1 });
+            if (parsed !== void 0) settings.chat.modelPicker.recentLimit = parsed;
+          }
+        }
+      }
+      if ("maxOutputTokens" in chat) {
+        const parsed = expectInteger(issues, "chat.maxOutputTokens", chat.maxOutputTokens, { min: 0 });
+        if (parsed !== void 0) settings.chat.maxOutputTokens = parsed;
+      }
+      if ("prewarm" in chat) {
+        const parsed = expectBoolean(issues, "chat.prewarm", chat.prewarm);
+        if (parsed !== void 0) settings.chat.prewarm = parsed;
+      }
+      if ("retry" in chat) {
+        if (!isPlainObject(chat.retry)) issues.add("chat.retry", `expected a map, got ${describe(chat.retry)}`);
+        else {
+          issues.unknownKeys("chat.retry", chat.retry, [
+            "enabled",
+            "maxRetries",
+            "baseDelayMs",
+            "maxDelayMs",
+            "streamStallMs"
+          ]);
+          if ("enabled" in chat.retry) {
+            const parsed = expectBoolean(issues, "chat.retry.enabled", chat.retry.enabled);
+            if (parsed !== void 0) settings.chat.retry.enabled = parsed;
+          }
+          for (const key of ["maxRetries", "baseDelayMs", "maxDelayMs", "streamStallMs"]) {
+            if (!(key in chat.retry)) continue;
+            const parsed = expectInteger(issues, `chat.retry.${key}`, chat.retry[key], { min: 0 });
+            if (parsed !== void 0) settings.chat.retry[key] = parsed;
+          }
+        }
+      }
+    }
+  }
+  let rawFleet = null;
+  if ("fleet" in raw) {
+    if (!isPlainObject(raw.fleet)) issues.add("fleet", `expected a map, got ${describe(raw.fleet)}`);
+    else {
+      rawFleet = raw.fleet;
+      issues.unknownKeys("fleet", rawFleet, [
+        "default",
+        "profiles",
+        "rosters",
+        "agentProfiles",
+        "adaptiveRouting",
+        "nodes",
+        "permissions",
+        "concurrency",
+        "retry",
+        "limits",
+        "history"
+      ]);
+    }
+  }
+  if (rawFleet && "nodes" in rawFleet) {
+    if (!Array.isArray(rawFleet.nodes)) issues.add("fleet.nodes", `expected a list, got ${describe(rawFleet.nodes)}`);
+    else {
+      const seen = /* @__PURE__ */ new Set();
+      settings.fleet.nodes = rawFleet.nodes.map((entry, index) => validateFleetNode(issues, `fleet.nodes[${index}]`, entry, seen)).filter((entry) => entry !== null);
+    }
+  }
+  const fleetNodeIds = new Set(settings.fleet.nodes.map((node) => node.id));
+  if (rawFleet) {
+    if ("default" in rawFleet) {
+      settings.fleet.default = validateRoute(
+        issues,
+        "fleet.default",
+        rawFleet.default,
+        settings.fleet.default,
+        settings.targets,
+        {
+          nodeIds: fleetNodeIds
+        }
+      );
+    }
+    if ("profiles" in rawFleet) {
+      if (!isPlainObject(rawFleet.profiles))
+        issues.add("fleet.profiles", `expected a map, got ${describe(rawFleet.profiles)}`);
+      else {
+        const profiles = {};
+        for (const [rawName, rawProfile] of Object.entries(rawFleet.profiles)) {
+          const name = rawName.trim();
+          if (!name) {
+            issues.add("fleet.profiles", "empty profile name");
+            continue;
+          }
+          const profile = validateRoute(
+            issues,
+            `fleet.profiles.${name}`,
+            rawProfile,
+            DEFAULT_SETTINGS.fleet.default,
+            settings.targets,
+            {
+              nodeIds: fleetNodeIds
+            }
+          );
+          if (profile.target) profiles[name] = profile;
+        }
+        settings.fleet.profiles = profiles;
+      }
+    }
+    if ("rosters" in rawFleet) {
+      if (!isPlainObject(rawFleet.rosters))
+        issues.add("fleet.rosters", `expected a map, got ${describe(rawFleet.rosters)}`);
+      else {
+        const rosters = {};
+        for (const [rawName, rawRoster] of Object.entries(rawFleet.rosters)) {
+          const name = rawName.trim();
+          const path = `fleet.rosters.${name}`;
+          if (!name) {
+            issues.add("fleet.rosters", "empty roster name");
+            continue;
+          }
+          if (!isPlainObject(rawRoster)) {
+            issues.add(path, `expected a map, got ${describe(rawRoster)}`);
+            continue;
+          }
+          issues.unknownKeys(path, rawRoster, ["members"]);
+          if (!Array.isArray(rawRoster.members)) {
+            issues.add(`${path}.members`, "expected a list");
+            continue;
+          }
+          if (rawRoster.members.length < 2 || rawRoster.members.length > 5)
+            issues.add(`${path}.members`, "expected 2 to 5 members");
+          const members = [];
+          const labels = /* @__PURE__ */ new Set();
+          for (const [index, rawMember] of rawRoster.members.entries()) {
+            const memberPath = `${path}.members[${index}]`;
+            if (!isPlainObject(rawMember)) {
+              issues.add(memberPath, `expected a map, got ${describe(rawMember)}`);
+              continue;
+            }
+            issues.unknownKeys(memberPath, rawMember, ["label", "target", "model", "thinkingLevel", "color"]);
+            const label = expectString(issues, `${memberPath}.label`, rawMember.label);
+            const target = expectString(issues, `${memberPath}.target`, rawMember.target);
+            if (label !== void 0 && !COUNCIL_MEMBER_LABEL_PATTERN.test(label))
+              issues.add(`${memberPath}.label`, "expected [a-z][a-z0-9_-]{0,31}");
+            if (label !== void 0 && labels.has(label)) issues.add(`${memberPath}.label`, "duplicate label");
+            if (label !== void 0) labels.add(label);
+            if (target !== void 0 && !settings.targets.some((entry) => entry.id === target))
+              issues.add(`${memberPath}.target`, `unknown target '${target}'`);
+            const model = rawMember.model === void 0 ? void 0 : expectString(issues, `${memberPath}.model`, rawMember.model);
+            const thinkingLevel = rawMember.thinkingLevel === void 0 ? void 0 : expectEnum(issues, `${memberPath}.thinkingLevel`, rawMember.thinkingLevel, THINKING_LEVELS);
+            const color = rawMember.color === void 0 ? void 0 : expectString(issues, `${memberPath}.color`, rawMember.color);
+            if (color !== void 0 && !THEME_NAMED_COLORS.includes(color) && !/^#[0-9a-fA-F]{6}$/u.test(color)) {
+              issues.add(`${memberPath}.color`, "expected a theme named color or 6-digit hex color");
+            }
+            if (label === void 0 || target === void 0) continue;
+            members.push({
+              label,
+              target,
+              ...model ? { model } : {},
+              ...thinkingLevel ? { thinkingLevel } : {},
+              ...color ? { color } : {}
+            });
+          }
+          if (rawRoster.members.length >= 2 && rawRoster.members.length <= 5 && members.length === rawRoster.members.length)
+            rosters[name] = { members };
+        }
+        settings.fleet.rosters = rosters;
+      }
+    }
+    if ("agentProfiles" in rawFleet) {
+      if (!isPlainObject(rawFleet.agentProfiles))
+        issues.add("fleet.agentProfiles", `expected a map, got ${describe(rawFleet.agentProfiles)}`);
+      else {
+        const bindings = {};
+        for (const [rawAgentId, rawProfileName] of Object.entries(rawFleet.agentProfiles)) {
+          const agentId = rawAgentId.trim();
+          if (!agentId) {
+            issues.add("fleet.agentProfiles", "empty agent id");
+            continue;
+          }
+          if (agentId === "auto") {
+            issues.add("fleet.agentProfiles", "'auto' is reserved for coordinator-owned agent selection");
+            continue;
+          }
+          const profile = expectString(issues, `fleet.agentProfiles.${agentId}`, rawProfileName);
+          if (profile !== void 0) bindings[agentId] = profile;
+        }
+        settings.fleet.agentProfiles = bindings;
+      }
+    }
+    if ("adaptiveRouting" in rawFleet) {
+      if (!isPlainObject(rawFleet.adaptiveRouting))
+        issues.add("fleet.adaptiveRouting", `expected a map, got ${describe(rawFleet.adaptiveRouting)}`);
+      else {
+        const adaptive = rawFleet.adaptiveRouting;
+        issues.unknownKeys("fleet.adaptiveRouting", adaptive, ["roles", "postures", "agentRoles"]);
+        for (const [key, allowed] of [
+          ["roles", ACTIVE_ROUTING_ROLES],
+          ["postures", ACTIVE_ROUTING_POSTURES]
+        ]) {
+          if (!(key in adaptive)) continue;
+          const parsed = expectStringArray(issues, `fleet.adaptiveRouting.${key}`, adaptive[key]);
+          if (parsed === void 0) continue;
+          const allowedSet = new Set(allowed);
+          for (const value of parsed)
+            if (!allowedSet.has(value))
+              issues.add(`fleet.adaptiveRouting.${key}`, `unsupported ${key === "roles" ? "role" : "posture"} '${value}'`);
+          if (parsed.every((value) => allowedSet.has(value))) settings.fleet.adaptiveRouting[key] = parsed;
+        }
+        if ("agentRoles" in adaptive) {
+          if (!Array.isArray(adaptive.agentRoles)) issues.add("fleet.adaptiveRouting.agentRoles", "expected a list");
+          else {
+            const pairs = [];
+            const seen = /* @__PURE__ */ new Set();
+            for (const [index, value] of adaptive.agentRoles.entries()) {
+              const path = `fleet.adaptiveRouting.agentRoles[${index}]`;
+              if (!isPlainObject(value)) {
+                issues.add(path, "expected a map");
+                continue;
+              }
+              issues.unknownKeys(path, value, ["agentId", "executionRole"]);
+              const agentId = expectString(issues, `${path}.agentId`, value.agentId);
+              const executionRole = expectEnum(
+                issues,
+                `${path}.executionRole`,
+                value.executionRole,
+                ACTIVE_AGENT_AUTOMATION_ROLES
+              );
+              if (agentId === "auto")
+                issues.add(`${path}.agentId`, "'auto' is reserved for coordinator-owned agent selection");
+              if (agentId === void 0 || agentId === "auto" || executionRole === void 0) continue;
+              const pairKey = `${agentId}\0${executionRole}`;
+              if (seen.has(pairKey)) {
+                issues.add(path, "duplicate agent and execution-role pair");
+                continue;
+              }
+              seen.add(pairKey);
+              pairs.push({ agentId, executionRole });
+            }
+            if (pairs.length === adaptive.agentRoles.length) settings.fleet.adaptiveRouting.agentRoles = pairs;
+          }
+        }
+      }
+    }
+    if ("permissions" in rawFleet) {
+      if (!isPlainObject(rawFleet.permissions))
+        issues.add("fleet.permissions", `expected a map, got ${describe(rawFleet.permissions)}`);
+      else {
+        issues.unknownKeys("fleet.permissions", rawFleet.permissions, ["mode", "escalation"]);
+        if ("mode" in rawFleet.permissions) {
+          const parsed = expectEnum(issues, "fleet.permissions.mode", rawFleet.permissions.mode, [
+            "deny",
+            "fail",
+            "escalate"
+          ]);
+          if (parsed !== void 0) settings.fleet.permissions.mode = parsed;
+        }
+        if ("escalation" in rawFleet.permissions) {
+          if (!isPlainObject(rawFleet.permissions.escalation))
+            issues.add("fleet.permissions.escalation", `expected a map, got ${describe(rawFleet.permissions.escalation)}`);
+          else {
+            const escalation = rawFleet.permissions.escalation;
+            issues.unknownKeys("fleet.permissions.escalation", escalation, ["timeoutMs", "fallback"]);
+            if ("timeoutMs" in escalation) {
+              const parsed = expectInteger(issues, "fleet.permissions.escalation.timeoutMs", escalation.timeoutMs, { min: 1 });
+              if (parsed !== void 0) settings.fleet.permissions.escalation.timeoutMs = parsed;
+            }
+            if ("fallback" in escalation) {
+              const parsed = expectEnum(issues, "fleet.permissions.escalation.fallback", escalation.fallback, [
+                "deny",
+                "fail"
+              ]);
+              if (parsed !== void 0) settings.fleet.permissions.escalation.fallback = parsed;
+            }
+          }
+        }
+      }
+    }
+    if ("concurrency" in rawFleet) {
+      if (rawFleet.concurrency === "auto") settings.fleet.concurrency = "auto";
+      else {
+        const parsed = expectInteger(issues, "fleet.concurrency", rawFleet.concurrency, { min: 1 });
+        if (parsed !== void 0) settings.fleet.concurrency = parsed;
+      }
+    }
+    for (const [blockName, fields] of [
+      [
+        "retry",
+        [
+          ["maxRetries", 0],
+          ["routeCooldownMs", 0]
+        ]
+      ],
+      [
+        "limits",
+        [
+          ["toolCallsPerRun", 1],
+          ["internalRunTimeoutMs", 1]
+        ]
+      ],
+      ["history", [["maxRuns", 1]]]
+    ]) {
+      if (!(blockName in rawFleet)) continue;
+      const block = rawFleet[blockName];
+      if (!isPlainObject(block)) {
+        issues.add(`fleet.${blockName}`, `expected a map, got ${describe(block)}`);
+        continue;
+      }
+      const known = fields.map(([key]) => key);
+      if (blockName === "history") known.push("journal");
+      issues.unknownKeys(`fleet.${blockName}`, block, known);
+      for (const [key, min] of fields) {
+        if (!(key in block)) continue;
+        const parsed = expectInteger(issues, `fleet.${blockName}.${key}`, block[key], { min });
+        if (parsed !== void 0) settings.fleet[blockName][key] = parsed;
+      }
+      if (blockName === "history" && "journal" in block) {
+        const parsed = expectBoolean(issues, "fleet.history.journal", block.journal);
+        if (parsed !== void 0) settings.fleet.history.journal = parsed;
+      }
+    }
+  }
+  if ("context" in raw) {
+    if (!isPlainObject(raw.context)) issues.add("context", `expected a map, got ${describe(raw.context)}`);
+    else {
+      const context = raw.context;
+      issues.unknownKeys("context", context, ["toolResultMaxBytes", "workingSet", "compaction", "memory"]);
+      if ("toolResultMaxBytes" in context) {
+        const parsed = expectInteger(issues, "context.toolResultMaxBytes", context.toolResultMaxBytes, { min: 4096 });
+        if (parsed !== void 0) settings.context.toolResultMaxBytes = parsed;
+      }
+      if ("workingSet" in context) {
+        if (!isPlainObject(context.workingSet))
+          issues.add("context.workingSet", `expected a map, got ${describe(context.workingSet)}`);
+        else {
+          const workingSet = context.workingSet;
+          issues.unknownKeys("context.workingSet", workingSet, [
+            "enabled",
+            "policy",
+            "target",
+            "protectLastTurns",
+            "minEvictableTokens"
+          ]);
+          if ("enabled" in workingSet) {
+            const parsed = expectBoolean(issues, "context.workingSet.enabled", workingSet.enabled);
+            if (parsed !== void 0) settings.context.workingSet.enabled = parsed;
+          }
+          if ("policy" in workingSet) {
+            const parsed = expectEnum(issues, "context.workingSet.policy", workingSet.policy, [
+              "age-horizon",
+              "structural-v1"
+            ]);
+            if (parsed !== void 0) settings.context.workingSet.policy = parsed;
+          }
+          if ("target" in workingSet) {
+            const parsed = expectNumber(issues, "context.workingSet.target", workingSet.target);
+            if (parsed !== void 0 && (parsed <= 0 || parsed >= 1))
+              issues.add("context.workingSet.target", `expected a number > 0 and < 1, got ${parsed}`);
+            else if (parsed !== void 0) settings.context.workingSet.target = parsed;
+          }
+          for (const [key, min] of [
+            ["protectLastTurns", 1],
+            ["minEvictableTokens", 0]
+          ]) {
+            if (!(key in workingSet)) continue;
+            const parsed = expectInteger(issues, `context.workingSet.${key}`, workingSet[key], { min });
+            if (parsed !== void 0) settings.context.workingSet[key] = parsed;
+          }
+        }
+      }
+      if ("compaction" in context) {
+        if (!isPlainObject(context.compaction))
+          issues.add("context.compaction", `expected a map, got ${describe(context.compaction)}`);
+        else {
+          const compaction = context.compaction;
+          issues.unknownKeys("context.compaction", compaction, [
+            "auto",
+            "threshold",
+            "model",
+            "systemPrompt",
+            "excludeLastTurns"
+          ]);
+          if ("excludeLastTurns" in compaction)
+            issues.add(
+              "context.compaction.excludeLastTurns",
+              "retired without replacement; use context.workingSet.protectLastTurns"
+            );
+          if ("auto" in compaction) {
+            const parsed = expectBoolean(issues, "context.compaction.auto", compaction.auto);
+            if (parsed !== void 0) settings.context.compaction.auto = parsed;
+          }
+          if ("threshold" in compaction) {
+            const parsed = expectNumber(issues, "context.compaction.threshold", compaction.threshold, { min: 0, max: 1 });
+            if (parsed !== void 0) settings.context.compaction.threshold = parsed;
+          }
+          for (const key of ["model", "systemPrompt"]) {
+            if (!(key in compaction)) continue;
+            const parsed = expectString(issues, `context.compaction.${key}`, compaction[key]);
+            if (parsed !== void 0) settings.context.compaction[key] = parsed;
+          }
+        }
+      }
+      if ("memory" in context) {
+        if (!isPlainObject(context.memory)) issues.add("context.memory", `expected a map, got ${describe(context.memory)}`);
+        else {
+          const memory = context.memory;
+          issues.unknownKeys("context.memory", memory, [
+            "enabled",
+            "target",
+            "model",
+            "cadenceToolCalls",
+            "trajectorySteps",
+            "maxOutputTokens",
+            "timeoutMs"
+          ]);
+          if ("enabled" in memory) {
+            const parsed = expectBoolean(issues, "context.memory.enabled", memory.enabled);
+            if (parsed !== void 0) settings.context.memory.enabled = parsed;
+          }
+          if ("target" in memory) {
+            if (memory.target === null) settings.context.memory.target = null;
+            else {
+              const parsed = expectString(issues, "context.memory.target", memory.target);
+              if (parsed !== void 0)
+                settings.context.memory.target = settings.targets.some((target) => target.id === parsed) ? parsed : null;
+            }
+          }
+          if ("model" in memory) {
+            if (memory.model === null) settings.context.memory.model = null;
+            else {
+              const parsed = expectString(issues, "context.memory.model", memory.model);
+              if (parsed !== void 0) settings.context.memory.model = parsed;
+            }
+          }
+          if (!settings.context.memory.target) settings.context.memory.model = null;
+          else if (settings.context.memory.model === null)
+            settings.context.memory.model = settings.targets.find((target) => target.id === settings.context.memory.target)?.defaultModel ?? null;
+          for (const [key, min] of [
+            ["cadenceToolCalls", 2],
+            ["trajectorySteps", 1],
+            ["maxOutputTokens", 1],
+            ["timeoutMs", 1]
+          ]) {
+            if (!(key in memory)) continue;
+            const parsed = expectInteger(issues, `context.memory.${key}`, memory[key], { min });
+            if (parsed !== void 0) settings.context.memory[key] = parsed;
+          }
+        }
+      }
+    }
+  }
+  if ("safety" in raw) {
+    if (!isPlainObject(raw.safety)) issues.add("safety", `expected a map, got ${describe(raw.safety)}`);
+    else {
+      const safety = raw.safety;
+      issues.unknownKeys("safety", safety, ["autonomy", "limits", "review"]);
+      if ("autonomy" in safety) {
+        const parsed = expectEnum(issues, "safety.autonomy", safety.autonomy, AUTONOMY_LEVELS);
+        if (parsed !== void 0) settings.safety.autonomy = parsed;
+      }
+      if ("limits" in safety) {
+        if (!isPlainObject(safety.limits)) issues.add("safety.limits", `expected a map, got ${describe(safety.limits)}`);
+        else {
+          const limits = safety.limits;
+          issues.unknownKeys("safety.limits", limits, [
+            "sessionCostUsd",
+            "chatToolCallsPerTurn",
+            "readBytesPerCall",
+            "observationBytesPerTurn"
+          ]);
+          if ("sessionCostUsd" in limits) {
+            const parsed = expectNumber(issues, "safety.limits.sessionCostUsd", limits.sessionCostUsd, { min: 0 });
+            if (parsed !== void 0) settings.safety.limits.sessionCostUsd = parsed;
+          }
+          for (const key of ["chatToolCallsPerTurn", "readBytesPerCall", "observationBytesPerTurn"]) {
+            if (!(key in limits)) continue;
+            const parsed = expectInteger(issues, `safety.limits.${key}`, limits[key], { min: 1 });
+            if (parsed !== void 0) settings.safety.limits[key] = parsed;
+          }
+        }
+      }
+      if ("review" in safety) {
+        if (!isPlainObject(safety.review)) issues.add("safety.review", `expected a map, got ${describe(safety.review)}`);
+        else {
+          const review = safety.review;
+          issues.unknownKeys("safety.review", review, ["enabled", "target", "cadenceToolCalls"]);
+          if ("enabled" in review) {
+            const parsed = expectBoolean(issues, "safety.review.enabled", review.enabled);
+            if (parsed !== void 0) settings.safety.review.enabled = parsed;
+          }
+          if ("target" in review && review.target !== null) {
+            const parsed = expectString(issues, "safety.review.target", review.target);
+            if (parsed !== void 0 && settings.targets.some((target) => target.id === parsed))
+              settings.safety.review.target = parsed;
+            else if (parsed !== void 0) issues.add("safety.review.target", `unknown target '${parsed}'`);
+          }
+          if ("cadenceToolCalls" in review && review.cadenceToolCalls !== null) {
+            const parsed = expectInteger(issues, "safety.review.cadenceToolCalls", review.cadenceToolCalls, { min: 1 });
+            if (parsed !== void 0) settings.safety.review.cadenceToolCalls = parsed;
+          }
+        }
+      }
+    }
+  }
+  if ("interface" in raw) {
+    if (!isPlainObject(raw.interface)) issues.add("interface", `expected a map, got ${describe(raw.interface)}`);
+    else {
+      const ui = raw.interface;
+      issues.unknownKeys("interface", ui, [
+        "outputDetail",
+        "smoothStreaming",
+        "mode",
+        "fullscreenScrollbar",
+        "terminalProgress",
+        "desktopNotifications",
+        "panes",
+        "keybindings"
+      ]);
+      for (const key of ["terminalProgress", "desktopNotifications"]) {
+        if (!(key in ui)) continue;
+        const parsed = expectBoolean(issues, `interface.${key}`, ui[key]);
+        if (parsed !== void 0) settings.interface[key] = parsed;
+      }
+      for (const [key, allowed] of [
+        ["outputDetail", ["minimal", "default", "verbose"]],
+        ["smoothStreaming", ["off", "auto", "on"]],
+        ["mode", ["regular", "fullscreen"]],
+        ["fullscreenScrollbar", ["hidden", "auto", "always"]]
+      ]) {
+        if (!(key in ui)) continue;
+        const parsed = expectEnum(issues, `interface.${key}`, ui[key], allowed);
+        if (parsed !== void 0) settings.interface[key] = parsed;
+      }
+      if ("panes" in ui) {
+        if (!isPlainObject(ui.panes)) issues.add("interface.panes", `expected a map, got ${describe(ui.panes)}`);
+        else {
+          const panes = ui.panes;
+          issues.unknownKeys("interface.panes", panes, ["enabled", "notifications", "layout", "workers", "files"]);
+          if ("enabled" in panes) {
+            const parsed = expectEnum(issues, "interface.panes.enabled", panes.enabled, ["auto", "embedded", "off"]);
+            if (parsed !== void 0) settings.interface.panes.enabled = parsed;
+          }
+          if ("notifications" in panes) {
+            const parsed = expectEnum(issues, "interface.panes.notifications", panes.notifications, [
+              "failures",
+              "all",
+              "off"
+            ]);
+            if (parsed !== void 0) settings.interface.panes.notifications = parsed;
+          }
+          if ("layout" in panes) {
+            const parsed = expectEnum(issues, "interface.panes.layout", panes.layout, ["off", "workers", "cockpit"]);
+            if (parsed !== void 0) settings.interface.panes.layout = parsed;
+          }
+          if ("workers" in panes) {
+            if (!isPlainObject(panes.workers))
+              issues.add("interface.panes.workers", `expected a map, got ${describe(panes.workers)}`);
+            else {
+              const workers = panes.workers;
+              issues.unknownKeys("interface.panes.workers", workers, ["ratio"]);
+              if ("ratio" in workers) {
+                const parsed = expectNumber(issues, "interface.panes.workers.ratio", workers.ratio, {
+                  min: 0.05,
+                  max: 0.5
+                });
+                if (parsed !== void 0) settings.interface.panes.workers.ratio = parsed;
+              }
+            }
+          }
+          if ("files" in panes) {
+            if (!isPlainObject(panes.files))
+              issues.add("interface.panes.files", `expected a map, got ${describe(panes.files)}`);
+            else {
+              const files = panes.files;
+              issues.unknownKeys("interface.panes.files", files, ["enabled", "mode", "profile", "followCwd", "ratio"]);
+              for (const key of ["enabled", "followCwd"]) {
+                if (!(key in files)) continue;
+                const parsed = expectBoolean(issues, `interface.panes.files.${key}`, files[key]);
+                if (parsed !== void 0) settings.interface.panes.files[key] = parsed;
+              }
+              if ("mode" in files) {
+                const parsed = expectEnum(issues, "interface.panes.files.mode", files.mode, ["companion", "chooser"]);
+                if (parsed !== void 0) settings.interface.panes.files.mode = parsed;
+              }
+              if ("profile" in files) {
+                const parsed = expectEnum(issues, "interface.panes.files.profile", files.profile, ["managed", "user"]);
+                if (parsed !== void 0) settings.interface.panes.files.profile = parsed;
+              }
+              if ("ratio" in files) {
+                const parsed = expectNumber(issues, "interface.panes.files.ratio", files.ratio, { min: 0.05, max: 0.5 });
+                if (parsed !== void 0) settings.interface.panes.files.ratio = parsed;
+              }
+            }
+          }
+        }
+      }
+      if ("keybindings" in ui)
+        settings.interface.keybindings = validateKeybindings(issues, "interface.keybindings", ui.keybindings);
+    }
+  }
+  if ("integrations" in raw) {
+    if (!isPlainObject(raw.integrations)) issues.add("integrations", `expected a map, got ${describe(raw.integrations)}`);
+    else {
+      const integrations = raw.integrations;
+      issues.unknownKeys("integrations", integrations, [
+        "projectResources",
+        "externalAgents",
+        "runtimePlugins",
+        "library",
+        "git"
+      ]);
+      if ("projectResources" in integrations) {
+        if (!isPlainObject(integrations.projectResources))
+          issues.add("integrations.projectResources", `expected a map, got ${describe(integrations.projectResources)}`);
+        else {
+          issues.unknownKeys("integrations.projectResources", integrations.projectResources, ["trustProjectImports"]);
+          if ("trustProjectImports" in integrations.projectResources) {
+            const parsed = expectBoolean(
+              issues,
+              "integrations.projectResources.trustProjectImports",
+              integrations.projectResources.trustProjectImports
+            );
+            if (parsed !== void 0) settings.integrations.projectResources.trustProjectImports = parsed;
+          }
+        }
+      }
+      if ("runtimePlugins" in integrations) {
+        const parsed = expectStringArray(issues, "integrations.runtimePlugins", integrations.runtimePlugins);
+        if (parsed !== void 0) settings.integrations.runtimePlugins = parsed;
+      }
+      if ("library" in integrations) {
+        if (!isPlainObject(integrations.library))
+          issues.add("integrations.library", `expected a map, got ${describe(integrations.library)}`);
+        else {
+          const library = integrations.library;
+          issues.unknownKeys("integrations.library", library, ["catalog", "remote", "confirmedRemote", "sync"]);
+          for (const key of ["catalog", "remote", "confirmedRemote"]) {
+            if (!(key in library)) continue;
+            const value = library[key];
+            if (value !== null && typeof value !== "string")
+              issues.add(`integrations.library.${key}`, `expected a string or null, got ${describe(value)}`);
+            else settings.integrations.library[key] = value;
+          }
+          if ("sync" in library) {
+            const parsed = expectBoolean(issues, "integrations.library.sync", library.sync);
+            if (parsed !== void 0) settings.integrations.library.sync = parsed;
+          }
+        }
+      }
+      if ("git" in integrations) {
+        if (!isPlainObject(integrations.git))
+          issues.add("integrations.git", `expected a map, got ${describe(integrations.git)}`);
+        else {
+          issues.unknownKeys("integrations.git", integrations.git, ["commitAttribution"]);
+          if ("commitAttribution" in integrations.git) {
+            const parsed = expectBoolean(issues, "integrations.git.commitAttribution", integrations.git.commitAttribution);
+            if (parsed !== void 0) settings.integrations.git.commitAttribution = parsed;
+          }
+        }
+      }
+      if ("externalAgents" in integrations) {
+        if (!isPlainObject(integrations.externalAgents))
+          issues.add("integrations.externalAgents", `expected a map, got ${describe(integrations.externalAgents)}`);
+        else {
+          const external = integrations.externalAgents;
+          issues.unknownKeys("integrations.externalAgents", external, ["entries", "defaults"]);
+          if ("defaults" in external) {
+            if (!isPlainObject(external.defaults))
+              issues.add("integrations.externalAgents.defaults", `expected a map, got ${describe(external.defaults)}`);
+            else {
+              const defaults = external.defaults;
+              issues.unknownKeys("integrations.externalAgents.defaults", defaults, [
+                "connectTimeoutMs",
+                "turnTimeoutMs",
+                "permissionTimeoutMs",
+                "toolGovernance"
+              ]);
+              for (const key of ["connectTimeoutMs", "turnTimeoutMs", "permissionTimeoutMs"]) {
+                if (!(key in defaults)) continue;
+                const parsed = expectInteger(issues, `integrations.externalAgents.defaults.${key}`, defaults[key], {
+                  min: 1,
+                  max: MAX_TIMER_DELAY_MS
+                });
+                if (parsed !== void 0) settings.integrations.externalAgents.defaults[key] = parsed;
+              }
+              if ("toolGovernance" in defaults) {
+                const parsed = expectEnum(
+                  issues,
+                  "integrations.externalAgents.defaults.toolGovernance",
+                  normalizeLegacyNamingValue(defaults.toolGovernance, "clio-policy", "clio-coder-policy"),
+                  TOOL_GOVERNANCE
+                );
+                if (parsed !== void 0) settings.integrations.externalAgents.defaults.toolGovernance = parsed;
+              }
+            }
+          }
+          if ("entries" in external) {
+            if (!Array.isArray(external.entries))
+              issues.add("integrations.externalAgents.entries", `expected a list, got ${describe(external.entries)}`);
+            else {
+              const seen = /* @__PURE__ */ new Set();
+              settings.integrations.externalAgents.entries = external.entries.map(
+                (entry, index) => validateExternalAgent(
+                  issues,
+                  `integrations.externalAgents.entries[${index}]`,
+                  entry,
+                  settings.integrations.externalAgents.defaults,
+                  seen
+                )
+              ).filter((entry) => entry !== null);
+            }
+          }
+        }
+      }
+    }
+  }
+  return { settings, issues: issues.list };
+}
+function validateSettingsFile() {
+  const path = join(resolveClioDirs().config, "settings.yaml");
+  if (!existsSync(path)) return { settings: cloneValue(DEFAULT_SETTINGS), issues: [] };
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    return {
+      settings: cloneValue(DEFAULT_SETTINGS),
+      issues: [
+        { path: "(root)", message: `unreadable: ${err instanceof Error ? err.message : String(err)}`, kind: "unreadable" }
+      ]
+    };
+  }
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(text);
+  } catch (err) {
+    return {
+      settings: cloneValue(DEFAULT_SETTINGS),
+      issues: [{ path: "(root)", message: `invalid YAML: ${yamlErrorSummary(err)}`, kind: "syntax" }]
+    };
+  }
+  return validateSettings(parsed);
+}
+function readSettings() {
+  const result = validateSettingsFile();
+  if (result.issues.length > 0) throw new SettingsValidationError(result.issues);
+  return result.settings;
+}
+function persistSettings(document) {
+  safeResourceWrite(settingsPath(), (0, import_yaml.stringify)(document), { encoding: "utf8", mode: 420 });
+}
+function readSavedDocument() {
+  const path = settingsPath();
+  if (!existsSync(path)) return {};
+  try {
+    return (0, import_yaml.parse)(readFileSync(path, "utf8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+function applySettingsDelta(saved, before, after) {
+  if (!isPlainObject(before) || !isPlainObject(after)) return cloneValue(after);
+  const out = isPlainObject(saved) ? { ...saved } : {};
+  for (const [key, next] of Object.entries(after)) {
+    if (deepEquals(before[key], next)) continue;
+    out[key] = applySettingsDelta(out[key], before[key], next);
+  }
+  for (const key of Object.keys(out)) {
+    if (!(key in after)) delete out[key];
+  }
+  return out;
+}
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((entry, index) => deepEquals(entry, b[index]));
+  }
+  if (!isPlainObject(a) || !isPlainObject(b)) return false;
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((key) => key in b && deepEquals(a[key], b[key]));
+}
+function updateSavedSettingsDocument(mutate, options = {}) {
+  withSettingsLock(() => {
+    readSettings();
+    const saved = readSavedDocument();
+    persistSettings(mutate(cloneValue(saved)));
+  }, options);
+}
+function withSettingsLock(fn, options = {}) {
+  return withStateFileLockSync(settingsPath(), fn, { timeoutMs: options.timeoutMs ?? 1e4 });
+}
+function updateSettings(mutate, options = {}) {
+  return withSettingsLock(() => {
+    const saved = readSavedDocument();
+    const current = readSettings();
+    const before = cloneValue(current);
+    const next = mutate(current) ?? current;
+    const revalidated = validateSettings(JSON.parse(JSON.stringify(next)));
+    if (revalidated.issues.length > 0) throw new SettingsValidationError(revalidated.issues);
+    persistSettings(applySettingsDelta(saved, before, revalidated.settings));
+    return revalidated.settings;
+  }, options);
+}
+function useTargetInSettings(settings, targetId, options = {}) {
+  const target = settings.targets.find((entry) => entry.id === targetId);
+  if (!target) return null;
+  const workerTarget = options.workerTargetId !== void 0 && options.workerTargetId !== target.id ? settings.targets.find((entry) => entry.id === options.workerTargetId) : target;
+  if (!workerTarget) return null;
+  const sharedModel = options.model ?? target.defaultModel ?? null;
+  settings.chat.target = target.id;
+  settings.chat.model = options.orchestratorModel ?? sharedModel;
+  settings.fleet.default.target = workerTarget.id;
+  settings.fleet.default.model = options.workerModel ?? (workerTarget === target ? sharedModel : workerTarget.defaultModel ?? null);
+  if (options.backgroundModel !== void 0) {
+    settings.context.memory.target = target.id;
+    settings.context.memory.model = options.backgroundModel;
+  }
+  return { workerTargetId: workerTarget.id };
+}
+function removeTargetFromSettings(settings, id) {
+  if (!settings.targets.some((entry) => entry.id === id)) return false;
+  settings.targets = settings.targets.filter((entry) => entry.id !== id);
+  if (settings.chat.target === id) {
+    settings.chat.target = null;
+    settings.chat.model = null;
+  }
+  if (settings.context.memory.target === id) {
+    settings.context.memory.target = null;
+    settings.context.memory.model = null;
+  }
+  if (settings.fleet.default.target === id) {
+    settings.fleet.default.target = null;
+    settings.fleet.default.model = null;
+  }
+  for (const [name, profile] of Object.entries(settings.fleet.profiles)) {
+    if (profile.target === id) delete settings.fleet.profiles[name];
+  }
+  settings.chat.modelPicker.cycleSet = settings.chat.modelPicker.cycleSet.filter((entry) => entry.split("/")[0] !== id);
+  settings.chat.modelPicker.favorites = settings.chat.modelPicker.favorites.filter(
+    (entry) => entry.split("/")[0] !== id
+  );
+  return true;
+}
+function setFleetProfileInSettings(settings, name, targetId, options = {}) {
+  const target = settings.targets.find((entry) => entry.id === targetId);
+  if (!target) return false;
+  const existing = settings.fleet.profiles[name];
+  settings.fleet.profiles[name] = {
+    target: target.id,
+    model: options.model ?? target.defaultModel ?? null,
+    thinkingLevel: options.thinkingLevel ?? existing?.thinkingLevel ?? "off"
+  };
+  return true;
+}
+function removeFleetProfileFromSettings(settings, name) {
+  delete settings.fleet.profiles[name];
+  let removedBindings = 0;
+  for (const [agentId, profileName] of Object.entries(settings.fleet.agentProfiles)) {
+    if (profileName !== name) continue;
+    delete settings.fleet.agentProfiles[agentId];
+    removedBindings += 1;
+  }
+  return removedBindings;
+}
+function bindAgentProfileInSettings(settings, agentId, profileName) {
+  if (settings.integrations.externalAgents.entries.some((agent) => agent.id === agentId)) return false;
+  settings.fleet.agentProfiles[agentId] = profileName;
+  return true;
+}
+
+export {
+  settingsPath,
+  SettingsValidationError,
+  formatSettingsIssues,
+  formatSettingsFailure,
+  SETTINGS_V1_PATH_MOVES,
+  validateSettings,
+  validateSettingsFile,
+  readSettings,
+  applySettingsDelta,
+  updateSavedSettingsDocument,
+  withSettingsLock,
+  updateSettings,
+  useTargetInSettings,
+  removeTargetFromSettings,
+  setFleetProfileInSettings,
+  removeFleetProfileFromSettings,
+  bindAgentProfileInSettings
+};
+//# sourceMappingURL=chunk-34BHNEE3.js.map