@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-FPS4R2RN.js

@@ -1,1975 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  warnLegacyNaming
-} from "./chunk-DVNAPPXU.js";
-import {
-  ACTIVE_AGENT_AUTOMATION_ROLES,
-  ACTIVE_ROUTING_POSTURES,
-  ACTIVE_ROUTING_ROLES,
-  COUNCIL_MEMBER_LABEL_PATTERN,
-  DEFAULT_SETTINGS,
-  THEME_NAMED_COLORS,
-  THINKING_LEVELS,
-  normalizeOutputStyle
-} from "./chunk-ZKJU55MX.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  MAX_TIMER_DELAY_MS
-} from "./chunk-6EXUUOSN.js";
-import {
-  withStateFileLockSync
-} from "./chunk-DVJL77SO.js";
-import {
-  clioConfigDir,
-  resolveClioDirs
-} from "./chunk-CTTI7G3T.js";
-import {
-  safeResourceWrite
-} from "./chunk-ZZFWWYLX.js";
-import {
-  __toESM,
-  init_esm_shims
-} from "./chunk-ECBHH7LU.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 validateLiteLLMSettings(issues, path, value) {
-  if (!isPlainObject(value)) {
-    issues.add(path, `expected a map, got ${describe(value)}`);
-    return void 0;
-  }
-  issues.unknownKeys(path, value, ["request"]);
-  const out = {};
-  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, [
-        "tags",
-        "sendSessionId",
-        "timeoutSeconds",
-        "streamTimeoutSeconds",
-        "numRetries"
-      ]);
-      const request = {};
-      if ("tags" in value.request) {
-        const parsed = expectStringArray(issues, `${path}.request.tags`, value.request.tags);
-        if (parsed !== void 0) {
-          const invalidTag = parsed.find((tag) => tag.includes(","));
-          if (invalidTag) issues.add(`${path}.request.tags`, "tags may not contain commas");
-          else if (parsed.length > 0) request.tags = [...new Set(parsed)];
-        }
-      }
-      if ("sendSessionId" in value.request) {
-        const parsed = expectBoolean(issues, `${path}.request.sendSessionId`, value.request.sendSessionId);
-        if (parsed !== void 0) request.sendSessionId = parsed;
-      }
-      for (const key of ["timeoutSeconds", "streamTimeoutSeconds"]) {
-        if (key in value.request) {
-          const parsed = expectNumber(issues, `${path}.request.${key}`, value.request[key], { min: 1e-3, max: 86400 });
-          if (parsed !== void 0) request[key] = parsed;
-        }
-      }
-      if ("numRetries" in value.request) {
-        const parsed = expectInteger(issues, `${path}.request.numRetries`, value.request.numRetries, { min: 0, max: 100 });
-        if (parsed !== void 0) request.numRetries = 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",
-    "cache",
-    "lmstudio",
-    "litellm",
-    "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 ("cache" in value) {
-    if (!isPlainObject(value.cache)) issues.add(`${path}.cache`, "expected a map");
-    else {
-      issues.unknownKeys(`${path}.cache`, value.cache, ["retention", "deployment", "warm"]);
-      target.cache = {};
-      if ("retention" in value.cache) {
-        const retention = expectEnum(issues, `${path}.cache.retention`, value.cache.retention, [
-          "none",
-          "short",
-          "long"
-        ]);
-        if (retention !== void 0) target.cache.retention = retention;
-      }
-      if ("deployment" in value.cache) {
-        const binding = value.cache.deployment;
-        const bindingPath = `${path}.cache.deployment`;
-        if (!isPlainObject(binding)) issues.add(bindingPath, "expected a map");
-        else {
-          issues.unknownKeys(bindingPath, binding, ["backend", "controlUrl", "model", "build", "gatewayDeploymentId"]);
-          const backend = expectEnum(issues, `${bindingPath}.backend`, binding.backend, ["llamacpp", "vllm"]);
-          for (const key of ["controlUrl", "model", "build"]) {
-            if (typeof binding[key] !== "string" || !binding[key].trim())
-              issues.add(`${bindingPath}.${key}`, "expected a nonempty string");
-          }
-          if (typeof binding.controlUrl === "string") {
-            try {
-              const url = new URL(binding.controlUrl);
-              if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
-                throw new Error("invalid URL");
-            } catch {
-              issues.add(`${bindingPath}.controlUrl`, "expected an HTTP(S) URL without credentials, query, or fragment");
-            }
-          }
-          if (binding.gatewayDeploymentId !== void 0 && (typeof binding.gatewayDeploymentId !== "string" || !binding.gatewayDeploymentId.trim()))
-            issues.add(`${bindingPath}.gatewayDeploymentId`, "expected a nonempty string");
-          if (backend && typeof binding.controlUrl === "string" && typeof binding.model === "string" && typeof binding.build === "string") {
-            target.cache.deployment = {
-              backend,
-              controlUrl: binding.controlUrl,
-              model: binding.model,
-              build: binding.build,
-              ...typeof binding.gatewayDeploymentId === "string" ? { gatewayDeploymentId: binding.gatewayDeploymentId } : {}
-            };
-          }
-        }
-      }
-      if ("warm" in value.cache) {
-        if (!isPlainObject(value.cache.warm)) issues.add(`${path}.cache.warm`, "expected a map");
-        else {
-          issues.unknownKeys(`${path}.cache.warm`, value.cache.warm, ["maxInputTokens", "maxDurationMs", "cooldownMs"]);
-          target.cache.warm = {};
-          for (const key of ["maxInputTokens", "maxDurationMs", "cooldownMs"]) {
-            const bound = value.cache.warm[key];
-            if (bound === void 0) continue;
-            if (typeof bound !== "number" || !Number.isSafeInteger(bound) || bound < 1)
-              issues.add(`${path}.cache.warm.${key}`, "expected a positive safe integer");
-            else target.cache.warm[key] = bound;
-          }
-        }
-      }
-    }
-  }
-  if ("lmstudio" in value) {
-    const v = validateLmStudioSettings(issues, `${path}.lmstudio`, value.lmstudio);
-    if (v !== void 0) target.lmstudio = v;
-  }
-  if ("litellm" in value) {
-    const v = validateLiteLLMSettings(issues, `${path}.litellm`, value.litellm);
-    if (v !== void 0) target.litellm = 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: key === "turnTimeoutMs" ? 0 : 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",
-            "firstTokenStallMs"
-          ]);
-          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", "firstTokenStallMs"]) {
-            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;
-      }
-      if ("outputDetail" in ui) {
-        const style = normalizeOutputStyle(ui.outputDetail);
-        if (style) settings.interface.outputDetail = style;
-        else issues.add("interface.outputDetail", "expected compact, standard, or detailed");
-      }
-      for (const [key, allowed] of [
-        ["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: key === "turnTimeoutMs" ? 0 : 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 scoped = options.orchestratorModel !== void 0 || options.workerModel !== void 0 || options.workerTargetId !== void 0 || options.backgroundModel !== void 0;
-  const roles = [];
-  if (!scoped || options.orchestratorModel !== void 0) roles.push("chat");
-  if (!scoped || options.workerModel !== void 0 || options.workerTargetId !== void 0) roles.push("fleet");
-  if (options.backgroundModel !== void 0) roles.push("memory");
-  const changedRoles = [];
-  const sharedModel = options.model ?? target.defaultModel ?? null;
-  for (const role of roles) {
-    const current = role === "chat" ? settings.chat : role === "fleet" ? settings.fleet.default : settings.context.memory;
-    const nextTarget = role === "fleet" ? workerTarget.id : target.id;
-    const nextModel = role === "chat" ? options.orchestratorModel ?? sharedModel : role === "fleet" ? options.workerModel ?? (workerTarget === target ? sharedModel : workerTarget.defaultModel ?? null) : options.backgroundModel ?? null;
-    if (current.target !== nextTarget || current.model !== nextModel) changedRoles.push(role);
-    current.target = nextTarget;
-    current.model = nextModel;
-  }
-  return { workerTargetId: workerTarget.id, roles, changedRoles };
-}
-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-FPS4R2RN.js.map