@iowarp/clio-coder 0.3.0

package/dist/chunk-JWHCJDCI.js

@@ -0,0 +1,1215 @@
+import {
+  ACTIVE_AGENT_AUTOMATION_ROLES,
+  ACTIVE_ROUTING_POSTURES,
+  ACTIVE_ROUTING_ROLES,
+  DEFAULT_SETTINGS,
+  THINKING_LEVELS
+} from "./chunk-UHTSULZS.js";
+import {
+  safeResourceWrite
+} from "./chunk-VPAWTYLY.js";
+import {
+  clioConfigDir,
+  resolveClioDirs
+} from "./chunk-X3NE4WVW.js";
+
+// src/core/config.ts
+import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+
+// src/core/timers.ts
+var MAX_TIMER_DELAY_MS = 2147483647;
+function clampTimerDelayMs(value) {
+  if (Number.isNaN(value) || value <= 0) return 0;
+  return value >= MAX_TIMER_DELAY_MS ? MAX_TIMER_DELAY_MS : Math.floor(value);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/config.ts
+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");
+    }
+  }
+};
+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-policy", "agent-managed", "deny-all"];
+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 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"
+  ]);
+  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`, value.lifecycle, ["user-managed", "clio-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;
+  }
+  return target;
+}
+function validateWorkerTarget(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 && value.target !== null) {
+    const v = expectString(issues, `${path}.target`, value.target);
+    if (v !== void 0) out.target = targets.some((entry) => entry.id === v) ? v : null;
+  }
+  if ("thinkingLevel" in value) {
+    const v = expectEnum(issues, `${path}.thinkingLevel`, value.thinkingLevel, THINKING_LEVELS);
+    if (v !== void 0) out.thinkingLevel = v;
+  }
+  if ("model" in value && value.model !== null) {
+    const v = expectString(issues, `${path}.model`, value.model);
+    if (v !== void 0) out.model = v;
+  }
+  if (allowNode && "node" in value && value.node !== null) {
+    const v = expectString(issues, `${path}.node`, value.node);
+    if (v !== void 0) {
+      const id = v.trim();
+      if (id.length > 0 && (id === "local" || options?.nodeIds?.has(id) === true)) out.node = id;
+    }
+  }
+  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 byId = new Set(targets.map((target) => target.id));
+  const out = [];
+  for (const ref of refs) {
+    const [targetId, ...modelParts] = ref.split("/");
+    if (!targetId || !byId.has(targetId) || modelParts.length === 0) continue;
+    const model = modelParts.join("/").trim();
+    if (!model) continue;
+    const normalized = `${targetId}/${model}`;
+    if (!out.includes(normalized)) out.push(normalized);
+  }
+  return out;
+}
+function normalizeScope(refs, targets) {
+  const byId = new Set(targets.map((target) => target.id));
+  const out = [];
+  for (const ref of refs) {
+    const [targetId] = ref.split("/");
+    if (!targetId || !byId.has(targetId)) continue;
+    if (!out.includes(ref)) out.push(ref);
+  }
+  return out;
+}
+function validateDelegationAgent(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 delegation 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 v = expectStringArray(issues, `${path}.args`, value.args);
+    if (v !== void 0) agent.args = v;
+  }
+  for (const key of ["connectTimeoutMs", "turnTimeoutMs", "permissionTimeoutMs"]) {
+    if (key in value) {
+      const v = expectInteger(issues, `${path}.${key}`, value[key], { min: 1, max: MAX_TIMER_DELAY_MS });
+      if (v !== void 0) agent[key] = v;
+    }
+  }
+  if ("stallTimeoutMs" in value) {
+    const v = expectInteger(issues, `${path}.stallTimeoutMs`, value.stallTimeoutMs);
+    if (v !== void 0) agent.stallTimeoutMs = v;
+  }
+  if ("toolGovernance" in value) {
+    const v = expectEnum(issues, `${path}.toolGovernance`, value.toolGovernance, TOOL_GOVERNANCE);
+    if (v !== void 0) agent.toolGovernance = v;
+  }
+  if ("projectContext" in value) {
+    const v = expectEnum(issues, `${path}.projectContext`, value.projectContext, ["none", "bounded"]);
+    if (v !== void 0) agent.projectContext = v;
+  }
+  if ("cwd" in value) {
+    const v = expectString(issues, `${path}.cwd`, value.cwd);
+    if (v !== void 0) agent.cwd = v;
+  }
+  if ("env" in value) {
+    const v = expectStringRecord(issues, `${path}.env`, value.env);
+    if (v !== void 0 && Object.keys(v).length > 0) agent.env = v;
+  }
+  if ("labels" in value) {
+    const v = expectStringRecord(issues, `${path}.labels`, value.labels);
+    if (v !== void 0 && Object.keys(v).length > 0) agent.labels = v;
+  }
+  return agent;
+}
+function validateDelegation(issues, value) {
+  const out = cloneValue(DEFAULT_SETTINGS.delegation);
+  if (!isPlainObject(value)) {
+    issues.add("delegation", `expected a map, got ${describe(value)}`);
+    return out;
+  }
+  issues.unknownKeys("delegation", value, ["agents", "defaults"]);
+  if ("defaults" in value) {
+    if (!isPlainObject(value.defaults)) {
+      issues.add("delegation.defaults", `expected a map, got ${describe(value.defaults)}`);
+    } else {
+      issues.unknownKeys("delegation.defaults", value.defaults, [
+        "connectTimeoutMs",
+        "turnTimeoutMs",
+        "permissionTimeoutMs",
+        "toolGovernance"
+      ]);
+      for (const key of ["connectTimeoutMs", "turnTimeoutMs", "permissionTimeoutMs"]) {
+        if (key in value.defaults) {
+          const v = expectInteger(issues, `delegation.defaults.${key}`, value.defaults[key], {
+            min: 1,
+            max: MAX_TIMER_DELAY_MS
+          });
+          if (v !== void 0) out.defaults[key] = v;
+        }
+      }
+      if ("toolGovernance" in value.defaults) {
+        const v = expectEnum(issues, "delegation.defaults.toolGovernance", value.defaults.toolGovernance, TOOL_GOVERNANCE);
+        if (v !== void 0) out.defaults.toolGovernance = v;
+      }
+    }
+  }
+  if ("agents" in value) {
+    if (!Array.isArray(value.agents)) {
+      issues.add("delegation.agents", `expected a list, got ${describe(value.agents)}`);
+    } else {
+      const seen = /* @__PURE__ */ new Set();
+      out.agents = value.agents.map((entry, i) => validateDelegationAgent(issues, `delegation.agents[${i}]`, entry, out.defaults, seen)).filter((entry) => entry !== null);
+    }
+  }
+  return out;
+}
+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",
+    "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;
+  const trimmedId = id.trim();
+  if (trimmedId.length === 0) {
+    issues.add(`${path}.id`, "must not be blank");
+    return null;
+  }
+  if (trimmedId === "local") {
+    issues.add(`${path}.id`, "'local' is reserved for the implicit local node");
+    return null;
+  }
+  if (seen.has(trimmedId)) {
+    issues.add(`${path}.id`, `duplicate fleet node id '${trimmedId}'`);
+    return null;
+  }
+  seen.add(trimmedId);
+  const node = { id: trimmedId, host, maxWorkers: 2 };
+  if ("user" in value) {
+    const v = expectString(issues, `${path}.user`, value.user);
+    if (v !== void 0) node.user = v;
+  }
+  if ("port" in value) {
+    const v = expectInteger(issues, `${path}.port`, value.port, { min: 1 });
+    if (v !== void 0) node.port = v;
+  }
+  if ("identityFile" in value) {
+    const v = expectString(issues, `${path}.identityFile`, value.identityFile);
+    if (v !== void 0) node.identityFile = v;
+  }
+  if ("clioEntry" in value) {
+    const v = expectString(issues, `${path}.clioEntry`, value.clioEntry);
+    if (v !== void 0) node.clioEntry = v;
+  }
+  if ("labels" in value) {
+    const v = expectStringArray(issues, `${path}.labels`, value.labels);
+    if (v !== void 0) node.labels = v;
+  }
+  if ("maxWorkers" in value) {
+    const v = expectInteger(issues, `${path}.maxWorkers`, value.maxWorkers, { min: 1 });
+    if (v !== void 0) node.maxWorkers = v;
+  }
+  if ("residency" in value) {
+    const v = expectEnum(issues, `${path}.residency`, value.residency, ["observe", "manage"]);
+    if (v !== void 0) node.residency = v;
+  }
+  return node;
+}
+function validateFleet(issues, value) {
+  const out = cloneValue(DEFAULT_SETTINGS.fleet);
+  if (!isPlainObject(value)) {
+    issues.add("fleet", `expected a map, got ${describe(value)}`);
+    return out;
+  }
+  issues.unknownKeys("fleet", value, ["nodes"]);
+  if ("nodes" in value) {
+    if (!Array.isArray(value.nodes)) {
+      issues.add("fleet.nodes", `expected a list, got ${describe(value.nodes)}`);
+    } else {
+      const seen = /* @__PURE__ */ new Set();
+      out.nodes = value.nodes.map((entry, i) => validateFleetNode(issues, `fleet.nodes[${i}]`, entry, seen)).filter((entry) => entry !== null);
+    }
+  }
+  return out;
+}
+function validateMemorySettings(issues, value) {
+  const out = cloneValue(DEFAULT_SETTINGS.memory);
+  if (!isPlainObject(value)) {
+    issues.add("memory", `expected a map, got ${describe(value)}`);
+    return out;
+  }
+  issues.unknownKeys("memory", value, ["intervention"]);
+  if (!("intervention" in value)) return out;
+  if (!isPlainObject(value.intervention)) {
+    issues.add("memory.intervention", `expected a map, got ${describe(value.intervention)}`);
+    return out;
+  }
+  const raw = value.intervention;
+  issues.unknownKeys("memory.intervention", raw, ["enabled", "everyNTools", "windowSteps", "maxTokens", "timeoutMs"]);
+  if ("enabled" in raw) {
+    const enabled = expectBoolean(issues, "memory.intervention.enabled", raw.enabled);
+    if (enabled !== void 0) out.intervention.enabled = enabled;
+  }
+  for (const key of ["everyNTools", "windowSteps", "maxTokens", "timeoutMs"]) {
+    if (!(key in raw)) continue;
+    const parsed = expectInteger(issues, `memory.intervention.${key}`, raw[key], {
+      min: key === "everyNTools" ? 2 : 1
+    });
+    if (parsed !== void 0) out.intervention[key] = parsed;
+  }
+  return out;
+}
+function validateKeybindings(issues, value) {
+  if (!isPlainObject(value)) {
+    issues.add("keybindings", `expected a map, got ${describe(value)}`);
+    return {};
+  }
+  const next = {};
+  for (const [rawKey, rawValue] of Object.entries(value)) {
+    const id = rawKey.trim();
+    if (!id) {
+      issues.add("keybindings", "empty keybinding id");
+      continue;
+    }
+    if (typeof rawValue === "string") {
+      const v = expectString(issues, `keybindings.${id}`, rawValue);
+      if (v !== void 0) next[id] = v;
+      continue;
+    }
+    if (Array.isArray(rawValue)) {
+      const v = expectStringArray(issues, `keybindings.${id}`, rawValue);
+      if (v !== void 0 && v.length > 0) next[id] = v;
+      continue;
+    }
+    issues.add(`keybindings.${id}`, `expected a string or list of strings, got ${describe(rawValue)}`);
+  }
+  return next;
+}
+var TOP_LEVEL_KEYS = [
+  "version",
+  "identity",
+  "autonomy",
+  "targets",
+  "runtimePlugins",
+  "orchestrator",
+  "background",
+  "memory",
+  "workers",
+  "fleet",
+  "routing",
+  "scope",
+  "modelSelector",
+  "budget",
+  "defaults",
+  "theme",
+  "terminal",
+  "skills",
+  "delegation",
+  "keybindings",
+  "compaction",
+  "retry",
+  "guardrails"
+];
+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 };
+  }
+  issues.unknownKeys("", raw, TOP_LEVEL_KEYS);
+  if ("version" in raw && raw.version !== 1) {
+    issues.add("version", `expected 1, got ${describe(raw.version)}`);
+  }
+  if ("identity" in raw) {
+    const v = expectString(issues, "identity", raw.identity);
+    if (v !== void 0) settings.identity = v;
+  }
+  if ("autonomy" in raw) {
+    const v = expectEnum(issues, "autonomy", raw.autonomy, AUTONOMY_LEVELS);
+    if (v !== void 0) settings.autonomy = v;
+  }
+  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 out = [];
+      for (let i = 0; i < raw.targets.length; i += 1) {
+        const target = validateTarget(issues, `targets[${i}]`, raw.targets[i]);
+        if (!target) continue;
+        if (seen.has(target.id)) {
+          issues.add(`targets[${i}].id`, `duplicate target id '${target.id}'`);
+          continue;
+        }
+        seen.add(target.id);
+        out.push(target);
+      }
+      settings.targets = out;
+    }
+  }
+  if ("runtimePlugins" in raw) {
+    const v = expectStringArray(issues, "runtimePlugins", raw.runtimePlugins);
+    if (v !== void 0) settings.runtimePlugins = v;
+  }
+  if ("orchestrator" in raw) {
+    settings.orchestrator = validateWorkerTarget(
+      issues,
+      "orchestrator",
+      raw.orchestrator,
+      settings.orchestrator,
+      settings.targets
+    );
+  }
+  if ("background" in raw) {
+    settings.background = validateWorkerTarget(
+      issues,
+      "background",
+      raw.background,
+      settings.background,
+      settings.targets
+    );
+  }
+  if ("memory" in raw) settings.memory = validateMemorySettings(issues, raw.memory);
+  if ("fleet" in raw) {
+    settings.fleet = validateFleet(issues, raw.fleet);
+  }
+  const fleetNodeIds = new Set(settings.fleet.nodes.map((node) => node.id));
+  if ("routing" in raw) {
+    if (!isPlainObject(raw.routing)) {
+      issues.add("routing", `expected a map, got ${describe(raw.routing)}`);
+    } else {
+      issues.unknownKeys("routing", raw.routing, ["activeRoles", "activePostures", "agentAutomation"]);
+      const activeRoles = expectStringArray(issues, "routing.activeRoles", raw.routing.activeRoles);
+      if (activeRoles !== void 0) {
+        const allowed = new Set(ACTIVE_ROUTING_ROLES);
+        const rawRoles = raw.routing.activeRoles;
+        const stringRoles = rawRoles.filter((role) => typeof role === "string");
+        const complete = activeRoles.length === rawRoles.length;
+        for (const role of activeRoles) {
+          if (!allowed.has(role)) issues.add("routing.activeRoles", `unsupported active role '${role}'`);
+        }
+        if (new Set(stringRoles).size !== stringRoles.length) {
+          issues.add("routing.activeRoles", "expected unique roles");
+        }
+        if (complete && activeRoles.every((role) => allowed.has(role))) {
+          settings.routing.activeRoles = activeRoles;
+        }
+      }
+      const activePostures = expectStringArray(issues, "routing.activePostures", raw.routing.activePostures);
+      if (activePostures !== void 0) {
+        const allowed = new Set(ACTIVE_ROUTING_POSTURES);
+        const rawPostures = raw.routing.activePostures;
+        const stringPostures = rawPostures.filter((posture) => typeof posture === "string");
+        const complete = activePostures.length === rawPostures.length;
+        for (const posture of activePostures) {
+          if (!allowed.has(posture)) issues.add("routing.activePostures", `unsupported active posture '${posture}'`);
+        }
+        if (new Set(stringPostures).size !== stringPostures.length) {
+          issues.add("routing.activePostures", "expected unique postures");
+        }
+        if (complete && activePostures.every((posture) => allowed.has(posture))) {
+          settings.routing.activePostures = activePostures;
+        }
+      }
+      if (!isPlainObject(raw.routing.agentAutomation)) {
+        issues.add("routing.agentAutomation", "expected a map");
+      } else {
+        const automation = raw.routing.agentAutomation;
+        issues.unknownKeys("routing.agentAutomation", automation, ["activeAgentRoles"]);
+        if (!Array.isArray(automation.activeAgentRoles)) {
+          issues.add("routing.agentAutomation.activeAgentRoles", "expected a list");
+        } else {
+          const pairs = [];
+          const seen = /* @__PURE__ */ new Set();
+          for (const [index, value] of automation.activeAgentRoles.entries()) {
+            const path = `routing.agentAutomation.activeAgentRoles[${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 key = `${agentId}\0${executionRole}`;
+            if (seen.has(key)) {
+              issues.add(path, "duplicate agent and execution-role pair");
+              continue;
+            }
+            seen.add(key);
+            pairs.push({ agentId, executionRole });
+          }
+          if (pairs.length === automation.activeAgentRoles.length) {
+            settings.routing.agentAutomation.activeAgentRoles = pairs;
+          }
+        }
+      }
+    }
+  }
+  if ("workers" in raw) {
+    if (!isPlainObject(raw.workers)) {
+      issues.add("workers", `expected a map, got ${describe(raw.workers)}`);
+    } else {
+      issues.unknownKeys("workers", raw.workers, [
+        "default",
+        "profiles",
+        "agentBindings",
+        "maxRetries",
+        "onPermission",
+        "escalation",
+        "resilienceCooldownMs"
+      ]);
+      if ("default" in raw.workers) {
+        settings.workers.default = validateWorkerTarget(
+          issues,
+          "workers.default",
+          raw.workers.default,
+          settings.workers.default,
+          settings.targets,
+          { nodeIds: fleetNodeIds }
+        );
+      }
+      if ("profiles" in raw.workers) {
+        if (!isPlainObject(raw.workers.profiles)) {
+          issues.add("workers.profiles", `expected a map, got ${describe(raw.workers.profiles)}`);
+        } else {
+          const profiles = {};
+          for (const [rawName, rawProfile] of Object.entries(raw.workers.profiles)) {
+            const name = rawName.trim();
+            if (!name) {
+              issues.add("workers.profiles", "empty profile name");
+              continue;
+            }
+            const profile = validateWorkerTarget(
+              issues,
+              `workers.profiles.${name}`,
+              rawProfile,
+              DEFAULT_SETTINGS.workers.default,
+              settings.targets,
+              { nodeIds: fleetNodeIds }
+            );
+            if (!profile.target) continue;
+            profiles[name] = profile;
+          }
+          settings.workers.profiles = profiles;
+        }
+      }
+      if ("agentBindings" in raw.workers) {
+        if (!isPlainObject(raw.workers.agentBindings)) {
+          issues.add("workers.agentBindings", `expected a map, got ${describe(raw.workers.agentBindings)}`);
+        } else {
+          const agentBindings = {};
+          for (const [rawAgentId, rawProfileName] of Object.entries(raw.workers.agentBindings)) {
+            const agentId = rawAgentId.trim();
+            if (!agentId) {
+              issues.add("workers.agentBindings", "empty agent id");
+              continue;
+            }
+            if (agentId === "auto") {
+              issues.add("workers.agentBindings", "'auto' is reserved for coordinator-owned agent selection");
+              continue;
+            }
+            const profileName = expectString(issues, `workers.agentBindings.${agentId}`, rawProfileName);
+            if (profileName !== void 0) agentBindings[agentId] = profileName;
+          }
+          settings.workers.agentBindings = agentBindings;
+        }
+      }
+      if ("maxRetries" in raw.workers) {
+        const v = expectInteger(issues, "workers.maxRetries", raw.workers.maxRetries, { min: 0 });
+        if (v !== void 0) settings.workers.maxRetries = v;
+      }
+      if ("onPermission" in raw.workers) {
+        const v = expectEnum(issues, "workers.onPermission", raw.workers.onPermission, [
+          "deny",
+          "fail",
+          "escalate"
+        ]);
+        if (v !== void 0) settings.workers.onPermission = v;
+      }
+      if ("escalation" in raw.workers) {
+        if (!isPlainObject(raw.workers.escalation)) {
+          issues.add("workers.escalation", `expected a map, got ${describe(raw.workers.escalation)}`);
+        } else {
+          const base = settings.workers.escalation ?? DEFAULT_SETTINGS.workers.escalation;
+          const escalation = { timeoutMs: base?.timeoutMs ?? 12e4, fallback: base?.fallback ?? "deny" };
+          issues.unknownKeys("workers.escalation", raw.workers.escalation, ["timeoutMs", "fallback"]);
+          if ("timeoutMs" in raw.workers.escalation) {
+            const v = expectInteger(issues, "workers.escalation.timeoutMs", raw.workers.escalation.timeoutMs, {
+              min: 1
+            });
+            if (v !== void 0) escalation.timeoutMs = v;
+          }
+          if ("fallback" in raw.workers.escalation) {
+            const v = expectEnum(issues, "workers.escalation.fallback", raw.workers.escalation.fallback, [
+              "deny",
+              "fail"
+            ]);
+            if (v !== void 0) escalation.fallback = v;
+          }
+          settings.workers.escalation = escalation;
+        }
+      }
+      if ("resilienceCooldownMs" in raw.workers) {
+        const v = expectInteger(issues, "workers.resilienceCooldownMs", raw.workers.resilienceCooldownMs, { min: 0 });
+        if (v !== void 0) settings.workers.resilienceCooldownMs = v;
+      }
+    }
+  }
+  if ("scope" in raw) {
+    const v = expectStringArray(issues, "scope", raw.scope);
+    if (v !== void 0) settings.scope = normalizeScope(v, settings.targets);
+  }
+  if ("modelSelector" in raw) {
+    if (!isPlainObject(raw.modelSelector)) {
+      issues.add("modelSelector", `expected a map, got ${describe(raw.modelSelector)}`);
+    } else {
+      issues.unknownKeys("modelSelector", raw.modelSelector, ["favorites", "recentLimit"]);
+      if ("favorites" in raw.modelSelector) {
+        const v = expectStringArray(issues, "modelSelector.favorites", raw.modelSelector.favorites);
+        if (v !== void 0) settings.modelSelector.favorites = normalizeModelRefs(v, settings.targets);
+      }
+      if ("recentLimit" in raw.modelSelector) {
+        const v = expectInteger(issues, "modelSelector.recentLimit", raw.modelSelector.recentLimit, { min: 1 });
+        if (v !== void 0) settings.modelSelector.recentLimit = v;
+      }
+    }
+  }
+  if ("budget" in raw) {
+    if (!isPlainObject(raw.budget)) {
+      issues.add("budget", `expected a map, got ${describe(raw.budget)}`);
+    } else {
+      issues.unknownKeys("budget", raw.budget, ["sessionCeilingUsd", "concurrency"]);
+      if ("sessionCeilingUsd" in raw.budget) {
+        const v = expectNumber(issues, "budget.sessionCeilingUsd", raw.budget.sessionCeilingUsd, { min: 0 });
+        if (v !== void 0) settings.budget.sessionCeilingUsd = v;
+      }
+      if ("concurrency" in raw.budget) {
+        if (raw.budget.concurrency === "auto") {
+          settings.budget.concurrency = "auto";
+        } else {
+          const v = expectInteger(issues, "budget.concurrency", raw.budget.concurrency, { min: 1 });
+          if (v !== void 0) settings.budget.concurrency = v;
+        }
+      }
+    }
+  }
+  if ("defaults" in raw) {
+    if (!isPlainObject(raw.defaults)) {
+      issues.add("defaults", `expected a map, got ${describe(raw.defaults)}`);
+    } else {
+      issues.unknownKeys("defaults", raw.defaults, ["maxTokens"]);
+      if ("maxTokens" in raw.defaults) {
+        const v = expectInteger(issues, "defaults.maxTokens", raw.defaults.maxTokens, { min: 0 });
+        if (v !== void 0) settings.defaults.maxTokens = v;
+      }
+    }
+  }
+  if ("theme" in raw) {
+    const v = expectString(issues, "theme", raw.theme);
+    if (v !== void 0) settings.theme = v;
+  }
+  if ("terminal" in raw) {
+    if (!isPlainObject(raw.terminal)) {
+      issues.add("terminal", `expected a map, got ${describe(raw.terminal)}`);
+    } else {
+      issues.unknownKeys("terminal", raw.terminal, ["showTerminalProgress", "outputVerbosity"]);
+      if ("showTerminalProgress" in raw.terminal) {
+        const v = expectBoolean(issues, "terminal.showTerminalProgress", raw.terminal.showTerminalProgress);
+        if (v !== void 0) settings.terminal.showTerminalProgress = v;
+      }
+      if ("outputVerbosity" in raw.terminal) {
+        const v = expectString(issues, "terminal.outputVerbosity", raw.terminal.outputVerbosity);
+        if (v === "minimal" || v === "default" || v === "verbose") settings.terminal.outputVerbosity = v;
+        else if (v !== void 0) issues.add("terminal.outputVerbosity", "expected minimal, default, or verbose");
+      }
+    }
+  }
+  if ("skills" in raw) {
+    if (!isPlainObject(raw.skills)) {
+      issues.add("skills", `expected a map, got ${describe(raw.skills)}`);
+    } else {
+      issues.unknownKeys("skills", raw.skills, ["trustProjectCompatRoots"]);
+      if ("trustProjectCompatRoots" in raw.skills) {
+        const v = expectBoolean(issues, "skills.trustProjectCompatRoots", raw.skills.trustProjectCompatRoots);
+        if (v !== void 0) settings.skills.trustProjectCompatRoots = v;
+      }
+    }
+  }
+  if ("delegation" in raw) {
+    settings.delegation = validateDelegation(issues, raw.delegation);
+  }
+  if ("keybindings" in raw) {
+    settings.keybindings = validateKeybindings(issues, raw.keybindings);
+  }
+  if ("compaction" in raw) {
+    if (!isPlainObject(raw.compaction)) {
+      issues.add("compaction", `expected a map, got ${describe(raw.compaction)}`);
+    } else {
+      issues.unknownKeys("compaction", raw.compaction, ["auto", "threshold", "excludeLastTurns", "model", "systemPrompt"]);
+      if ("auto" in raw.compaction) {
+        const v = expectBoolean(issues, "compaction.auto", raw.compaction.auto);
+        if (v !== void 0) settings.compaction.auto = v;
+      }
+      if ("threshold" in raw.compaction) {
+        const v = expectNumber(issues, "compaction.threshold", raw.compaction.threshold, { min: 0, max: 1 });
+        if (v !== void 0) settings.compaction.threshold = v;
+      }
+      if ("excludeLastTurns" in raw.compaction) {
+        const v = expectInteger(issues, "compaction.excludeLastTurns", raw.compaction.excludeLastTurns, { min: 1 });
+        if (v !== void 0) settings.compaction.excludeLastTurns = v;
+      }
+      if ("model" in raw.compaction) {
+        const v = expectString(issues, "compaction.model", raw.compaction.model);
+        if (v !== void 0) settings.compaction.model = v;
+      }
+      if ("systemPrompt" in raw.compaction) {
+        const v = expectString(issues, "compaction.systemPrompt", raw.compaction.systemPrompt);
+        if (v !== void 0) settings.compaction.systemPrompt = v;
+      }
+    }
+  }
+  if ("retry" in raw) {
+    if (!isPlainObject(raw.retry)) {
+      issues.add("retry", `expected a map, got ${describe(raw.retry)}`);
+    } else {
+      issues.unknownKeys("retry", raw.retry, ["enabled", "maxRetries", "baseDelayMs", "maxDelayMs"]);
+      if ("enabled" in raw.retry) {
+        const v = expectBoolean(issues, "retry.enabled", raw.retry.enabled);
+        if (v !== void 0) settings.retry.enabled = v;
+      }
+      for (const key of ["maxRetries", "baseDelayMs", "maxDelayMs"]) {
+        if (key in raw.retry) {
+          const v = expectInteger(issues, `retry.${key}`, raw.retry[key], { min: 0 });
+          if (v !== void 0) settings.retry[key] = v;
+        }
+      }
+    }
+  }
+  if ("guardrails" in raw) {
+    if (!isPlainObject(raw.guardrails)) {
+      issues.add("guardrails", `expected a map, got ${describe(raw.guardrails)}`);
+    } else {
+      const keys = [
+        "turnToolCallBudget",
+        "workerToolCallCap",
+        "maxDispatchRuns",
+        "readMaxBytes",
+        "observationTurnBudgetBytes",
+        "internalDispatchTimeoutMs"
+      ];
+      issues.unknownKeys("guardrails", raw.guardrails, keys);
+      for (const key of keys) {
+        if (key in raw.guardrails) {
+          const v = expectInteger(issues, `guardrails.${key}`, raw.guardrails[key], { min: 1 });
+          if (v !== void 0) settings.guardrails[key] = v;
+        }
+      }
+    }
+  }
+  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 = parseYaml(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(settings) {
+  safeResourceWrite(settingsPath(), stringifyYaml(settings), { encoding: "utf8", mode: 420 });
+}
+function settingsLockPath() {
+  return `${settingsPath()}.lock`;
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.max(1, ms));
+}
+function tryAcquireSettingsLock(lockPath, staleLockMs) {
+  try {
+    writeFileSync(lockPath, `${JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() })}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 420
+    });
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  try {
+    if (Date.now() - statSync(lockPath).mtimeMs > staleLockMs) rmSync(lockPath, { force: true });
+  } catch {
+  }
+  return false;
+}
+function withSettingsLock(fn, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const staleLockMs = options.staleLockMs ?? 5e3;
+  const pollIntervalMs = options.pollIntervalMs ?? 25;
+  const lockPath = settingsLockPath();
+  const deadline = Date.now() + timeoutMs;
+  while (!tryAcquireSettingsLock(lockPath, staleLockMs)) {
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `timed out after ${timeoutMs}ms waiting for ${lockPath}; delete it if no other clio process is running`
+      );
+    }
+    sleepSync(pollIntervalMs);
+  }
+  try {
+    return fn();
+  } finally {
+    rmSync(lockPath, { force: true });
+  }
+}
+function updateSettings(mutate, options = {}) {
+  return withSettingsLock(() => {
+    const current = readSettings();
+    const next = mutate(current) ?? current;
+    const revalidated = validateSettings(JSON.parse(JSON.stringify(next)));
+    if (revalidated.issues.length > 0) throw new SettingsValidationError(revalidated.issues);
+    persistSettings(revalidated.settings);
+    return revalidated.settings;
+  }, options);
+}
+
+export {
+  MAX_TIMER_DELAY_MS,
+  clampTimerDelayMs,
+  sleep,
+  settingsPath,
+  formatSettingsIssues,
+  formatSettingsFailure,
+  validateSettings,
+  validateSettingsFile,
+  readSettings,
+  updateSettings
+};
+//# sourceMappingURL=chunk-JWHCJDCI.js.map