@namzu/cli 35.0.0 → 36.0.0

package/dist/chunks/chunk-YYQJIECC.js

@@ -0,0 +1,1439 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  isFormatName,
+  require_dist
+} from "./chunk-KONYGNG6.js";
+import {
+  configMetadataLiteral
+} from "./chunk-NICLKFBG.js";
+import {
+  TOOL_RESULT_SCREEN_NAMES,
+  TOOL_RESULT_SCREEN_OPTION_KEYS,
+  isToolResultScreenName
+} from "./chunk-42ZK2AH4.js";
+import {
+  homePath
+} from "./chunk-US5ZFPAU.js";
+import {
+  BROWSER_ACT_TOOL_NAME,
+  BROWSER_TOOL_NAME,
+  RENAMED_PLUGIN_HOOK_EVENTS,
+  SHELL_HOOK_EVENTS,
+  canonicalizeBrowserSitePattern,
+  canonicalizeBrowserUrl,
+  resolveNamzuHome
+} from "./chunk-K5HARZ7G.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-76FLAFCG.js";
+
+// src/permissions/browser-sites.ts
+var BROWSER_SITE_LEVELS = ["deny", "read", "ask", "act"];
+var DEFAULT_BROWSER_SITE_LEVEL = "ask";
+function isBrowserSiteLevel(value) {
+  return typeof value === "string" && BROWSER_SITE_LEVELS.includes(value);
+}
+__name(isBrowserSiteLevel, "isBrowserSiteLevel");
+function canonicalBrowserSiteKey(raw) {
+  if (raw.trim() === "*") return { ok: true, key: "*" };
+  const verdict = canonicalizeBrowserSitePattern(raw);
+  return verdict.ok ? { ok: true, key: verdict.pattern } : { ok: false, reason: verdict.reason };
+}
+__name(canonicalBrowserSiteKey, "canonicalBrowserSiteKey");
+function parseSite(key, level) {
+  const match = /^(https?):\/\/(\*\.)?([^:]+)(?::(\*|\d+))?$/.exec(key);
+  if (!match) return void 0;
+  return {
+    key,
+    level,
+    scheme: match[1] ?? "",
+    host: match[3] ?? "",
+    wildcardHost: match[2] !== void 0,
+    port: match[4] ?? ""
+  };
+}
+__name(parseSite, "parseSite");
+function specificity(site) {
+  return (site.wildcardHost ? 0 : 1e6) + site.host.length * 10 + (site.port === "*" ? 0 : 1);
+}
+__name(specificity, "specificity");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function originSource(site) {
+  const host = site.wildcardHost ? `(?:[^./:?#@\\[\\]]+\\.)+${escapeRegExp(site.host)}` : escapeRegExp(site.host);
+  const port = site.port === "*" ? "(?::\\d{1,5})?" : site.port === "" ? "" : `:${site.port}`;
+  return `${site.scheme}://${host}${port}`;
+}
+__name(originSource, "originSource");
+var NAVIGATE = {
+  deny: "deny",
+  read: "allow",
+  ask: "review",
+  act: "allow"
+};
+var ACT = {
+  deny: "deny",
+  read: "deny",
+  ask: "review",
+  act: "allow"
+};
+function rulesFor(origin, level) {
+  const url = origin === void 0 ? "^" : `^${origin}(?:[/?#]|$)`;
+  const act = origin === void 0 ? "^" : `^${origin}$`;
+  return [
+    {
+      type: "argument_pattern",
+      toolNames: [BROWSER_TOOL_NAME],
+      argument: "url",
+      pattern: url,
+      decision: NAVIGATE[level]
+    },
+    {
+      type: "argument_pattern",
+      toolNames: [BROWSER_ACT_TOOL_NAME],
+      argument: "origin",
+      pattern: act,
+      decision: ACT[level]
+    }
+  ];
+}
+__name(rulesFor, "rulesFor");
+var LOOKING = [
+  {
+    type: "argument_pattern",
+    toolNames: [BROWSER_TOOL_NAME],
+    argument: "action",
+    pattern: "^(?:snapshot|screenshot|scroll|wait_for)$",
+    decision: "allow"
+  },
+  {
+    type: "argument_pattern",
+    toolNames: [BROWSER_TOOL_NAME],
+    argument: "op",
+    pattern: "^(?:list|select|close)$",
+    decision: "allow"
+  }
+];
+function normalizeBrowserSites(sites) {
+  const out = {};
+  const diagnostics = [];
+  for (const [raw, level] of Object.entries(sites ?? {})) {
+    if (!isBrowserSiteLevel(level)) {
+      diagnostics.push(`browser.sites."${raw}": use deny, read, ask or act`);
+      continue;
+    }
+    const verdict = canonicalBrowserSiteKey(raw);
+    if (!verdict.ok) {
+      diagnostics.push(`browser.sites."${raw}": ${verdict.reason}`);
+      continue;
+    }
+    const existing = out[verdict.key];
+    out[verdict.key] = existing === void 0 ? level : narrower(existing, level);
+  }
+  if (out["*"] === void 0) out["*"] = DEFAULT_BROWSER_SITE_LEVEL;
+  return { sites: out, diagnostics };
+}
+__name(normalizeBrowserSites, "normalizeBrowserSites");
+function narrower(a, b) {
+  return BROWSER_SITE_LEVELS.indexOf(a) <= BROWSER_SITE_LEVELS.indexOf(b) ? a : b;
+}
+__name(narrower, "narrower");
+function compileBrowserSites(sites) {
+  const normalized = normalizeBrowserSites(sites);
+  const diagnostics = [...normalized.diagnostics];
+  const parsed = [];
+  for (const [key, level] of Object.entries(normalized.sites)) {
+    if (key === "*") continue;
+    const site = parseSite(key, level);
+    if (site) parsed.push(site);
+    else diagnostics.push(`browser.sites."${key}": could not be read`);
+  }
+  const denies = parsed.filter((site) => site.level === "deny");
+  const others = parsed.filter((site) => site.level !== "deny").sort((a, b) => specificity(b) - specificity(a) || (a.key < b.key ? -1 : 1));
+  const rules = [
+    // A blank tab is where the browser starts; it loads nothing.
+    {
+      type: "argument_pattern",
+      toolNames: [BROWSER_TOOL_NAME],
+      argument: "url",
+      pattern: "^about:blank$",
+      decision: "allow"
+    },
+    ...denies.flatMap((site) => rulesFor(originSource(site), "deny")),
+    ...others.flatMap((site) => rulesFor(originSource(site), site.level)),
+    ...rulesFor(void 0, normalized.sites["*"] ?? DEFAULT_BROWSER_SITE_LEVEL),
+    ...LOOKING
+  ];
+  return { rules, sites: normalized.sites, diagnostics };
+}
+__name(compileBrowserSites, "compileBrowserSites");
+var BROWSER_TOOLS = /* @__PURE__ */ new Set([BROWSER_TOOL_NAME, BROWSER_ACT_TOOL_NAME]);
+function isBrowserDeny(rule) {
+  switch (rule.type) {
+    case "deny_by_name":
+      return rule.toolNames.some((name) => BROWSER_TOOLS.has(name));
+    case "argument_pattern":
+      return rule.decision === "deny" && rule.toolNames.some((name) => BROWSER_TOOLS.has(name));
+    case "custom_pattern":
+      return rule.decision === "deny" && (rule.pattern.startsWith(`^${BROWSER_TOOL_NAME}`) || rule.pattern.startsWith(`^${BROWSER_ACT_TOOL_NAME}`));
+    default:
+      return false;
+  }
+}
+__name(isBrowserDeny, "isBrowserDeny");
+function withBrowserSiteRules(tableRules, siteRules) {
+  return [
+    ...tableRules.filter(isBrowserDeny),
+    ...siteRules,
+    ...tableRules.filter((rule) => !isBrowserDeny(rule))
+  ];
+}
+__name(withBrowserSiteRules, "withBrowserSiteRules");
+function browserSiteRuleFor(sites, origin) {
+  const normalized = normalizeBrowserSites(sites).sites;
+  const parsed = Object.entries(normalized).filter(([key]) => key !== "*").map(([key, level]) => parseSite(key, level)).filter((site) => site !== void 0);
+  const hits = parsed.filter((site) => new RegExp(`^${originSource(site)}$`).test(origin));
+  const deny = hits.find((site) => site.level === "deny");
+  if (deny) return { site: deny.key, level: "deny" };
+  const best = hits.sort((a, b) => specificity(b) - specificity(a))[0];
+  if (best) return { site: best.key, level: best.level };
+  return { site: "*", level: normalized["*"] ?? DEFAULT_BROWSER_SITE_LEVEL };
+}
+__name(browserSiteRuleFor, "browserSiteRuleFor");
+function browserCallOrigin(toolName, input) {
+  if (typeof input !== "object" || input === null) return void 0;
+  const record = input;
+  if (toolName === BROWSER_ACT_TOOL_NAME) {
+    return typeof record.origin === "string" ? record.origin : void 0;
+  }
+  if (toolName === BROWSER_TOOL_NAME && typeof record.url === "string") {
+    const verdict = canonicalizeBrowserUrl(record.url);
+    return verdict.ok && verdict.url !== "about:blank" ? verdict.origin : void 0;
+  }
+  return void 0;
+}
+__name(browserCallOrigin, "browserCallOrigin");
+
+// src/config/schema.ts
+var DEFAULT_CONFIG = Object.freeze({
+  format: "text",
+  quiet: false
+});
+
+// src/config/load.ts
+import { readFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+
+// src/config/composer-triggers.ts
+var COMPOSER_TRIGGER_IDS = [
+  "hypermode",
+  "save-skill",
+  "schedule",
+  "max-effort"
+];
+var COMPOSER_TRIGGER_LANGUAGES = ["en", "tr"];
+var COMPOSER_TRIGGER_DEFAULTS = {
+  hypermode: "arm",
+  "save-skill": "arm",
+  schedule: "suggest",
+  "max-effort": "off"
+};
+var RANK = { off: 0, suggest: 1, arm: 2 };
+function resolveComposerTriggers(config) {
+  return {
+    enabled: config?.enabled ?? true,
+    suggest: config?.suggest ?? true,
+    languages: config?.languages ?? COMPOSER_TRIGGER_LANGUAGES,
+    arming: { ...COMPOSER_TRIGGER_DEFAULTS, ...config?.builtin ?? {} }
+  };
+}
+__name(resolveComposerTriggers, "resolveComposerTriggers");
+function mergeComposerTriggers(below, layer, projectControlled) {
+  if (!projectControlled) {
+    const builtin2 = { ...below?.builtin ?? {}, ...layer.builtin ?? {} };
+    return {
+      ...below ?? {},
+      ...layer,
+      ...Object.keys(builtin2).length > 0 ? { builtin: builtin2 } : {}
+    };
+  }
+  const current = resolveComposerTriggers(below);
+  const enabled = current.enabled && (layer.enabled ?? true);
+  const suggest = current.suggest && (layer.suggest ?? true);
+  const languages = layer.languages ? current.languages.filter((language) => layer.languages?.includes(language)) : void 0;
+  const builtin = {
+    ...below?.builtin ?? {}
+  };
+  for (const [id, arming] of Object.entries(layer.builtin ?? {})) {
+    const now = current.arming[id];
+    builtin[id] = RANK[arming] < RANK[now] ? arming : now;
+  }
+  return {
+    ...below ?? {},
+    ...layer.enabled !== void 0 || below?.enabled !== void 0 ? { enabled } : {},
+    ...layer.suggest !== void 0 || below?.suggest !== void 0 ? { suggest } : {},
+    ...languages !== void 0 ? { languages } : {},
+    ...Object.keys(builtin).length > 0 ? { builtin } : {}
+  };
+}
+__name(mergeComposerTriggers, "mergeComposerTriggers");
+
+// src/config/load.ts
+var MANAGED_CONFIG_PATH = process.platform === "win32" ? join(process.env.PROGRAMDATA ?? "C:\\ProgramData", "namzu", "config.json") : "/etc/namzu/config.json";
+function loadConfigWithProvenance(opts = {}) {
+  return resolveConfigWithProvenance(opts, {
+    includeProject: true,
+    deferUnknownProfile: false
+  });
+}
+__name(loadConfigWithProvenance, "loadConfigWithProvenance");
+function loadBootstrapConfigWithProvenance(opts = {}) {
+  return resolveConfigWithProvenance(opts, {
+    includeProject: false,
+    deferUnknownProfile: true
+  });
+}
+__name(loadBootstrapConfigWithProvenance, "loadBootstrapConfigWithProvenance");
+function resolveConfigWithProvenance(opts, mode) {
+  const cwd = opts.cwd ?? process.cwd();
+  const env = opts.env ?? process.env;
+  const userPath = join(
+    resolveNamzuHome({ ...opts.home ? { home: opts.home } : {}, env }),
+    "config.yaml"
+  );
+  const projectPath = resolve(cwd, "namzu.config.json");
+  const managedPath = opts.managedPath ?? MANAGED_CONFIG_PATH;
+  const userCfg = readYamlIfExists(userPath);
+  const projectCfg = mode.includeProject ? readJsonIfExists(projectPath, PROJECT_FILE_LABEL) : {};
+  const managedCfg = readJsonIfExists(managedPath, shortHomePath(managedPath));
+  const { config: envCfg, variables: envVariables } = readEnv(env);
+  const profileName = opts.profile ?? env.NAMZU_PROFILE;
+  const profiles = profileLayers(
+    profileName,
+    [
+      [userCfg, userPath],
+      [projectCfg, projectPath],
+      [managedCfg, managedPath]
+    ],
+    mode.deferUnknownProfile
+  );
+  return mergeConfigs(
+    constantLayer(DEFAULT_CONFIG, { kind: "default" }),
+    constantLayer(userCfg, { kind: "user-file", path: userPath }),
+    constantLayer(projectCfg, { kind: "project-file", path: projectPath }),
+    ...profiles,
+    {
+      config: envCfg,
+      sourceFor: /* @__PURE__ */ __name((key) => {
+        const variable = envVariables[key];
+        if (variable === void 0) {
+          throw new Error(`no env variable recorded for config key '${key}'`);
+        }
+        return { kind: "env", variable };
+      }, "sourceFor")
+    },
+    // Last, so it beats the project file and the environment both. That
+    // ordering is the whole of what a managed layer is.
+    constantLayer(managedCfg, { kind: "managed", path: managedPath })
+  );
+}
+__name(resolveConfigWithProvenance, "resolveConfigWithProvenance");
+function readPermissionLayers(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const env = opts.env ?? process.env;
+  const userPath = join(
+    resolveNamzuHome({ ...opts.home ? { home: opts.home } : {}, env }),
+    "config.yaml"
+  );
+  const projectPath = resolve(cwd, "namzu.config.json");
+  const managedPath = opts.managedPath ?? MANAGED_CONFIG_PATH;
+  const layers = [];
+  for (const [source, path, config] of [
+    ["user-file", userPath, readYamlIfExists(userPath)],
+    [
+      "project-file",
+      projectPath,
+      opts.includeProject === false ? {} : readJsonIfExists(projectPath, PROJECT_FILE_LABEL)
+    ],
+    ["managed", managedPath, readJsonIfExists(managedPath, shortHomePath(managedPath))]
+  ]) {
+    const browserDenies = Object.entries(config.browser?.sites ?? {}).filter(([site, level]) => site !== "*" && level === "deny").map(([site]) => site);
+    if (config.permissions || browserDenies.length > 0)
+      layers.push({
+        source,
+        path,
+        permissions: config.permissions ?? {},
+        ...browserDenies.length > 0 ? { browserDenies } : {}
+      });
+  }
+  return layers;
+}
+__name(readPermissionLayers, "readPermissionLayers");
+function profileLayers(name, files, deferUnknown = false) {
+  if (name === void 0 || name === "") return [];
+  const layers = [];
+  const declared = /* @__PURE__ */ new Set();
+  const declaringFiles = [];
+  for (const [config, path] of files) {
+    const profiles = config.profiles;
+    if (profiles === void 0) continue;
+    declaringFiles.push(path);
+    for (const key of Object.keys(profiles)) declared.add(key);
+    if (!Object.hasOwn(profiles, name)) continue;
+    const selected = profiles[name];
+    if (selected === void 0) continue;
+    layers.push(constantLayer(selected, { kind: "profile", name, path }));
+  }
+  if (layers.length === 0) {
+    if (deferUnknown) return [];
+    const known = [...declared].sort();
+    const where = declaringFiles[0] ?? files[1]?.[1] ?? "";
+    throw new ConfigLoadError(
+      where,
+      known.length === 0 ? `No profile named "${name}" \u2014 no config file declares any profiles.` : `No profile named "${name}". Declared in ${declaringFiles.join(", ")}: ${known.join(", ")}.`
+    );
+  }
+  return layers;
+}
+__name(profileLayers, "profileLayers");
+function loadConfig(opts = {}) {
+  return loadConfigWithProvenance(opts).config;
+}
+__name(loadConfig, "loadConfig");
+var ConfigLoadError = class extends Error {
+  static {
+    __name(this, "ConfigLoadError");
+  }
+  /** The file whose contents could not be established. */
+  path;
+  /** The message already says what to do next, so the caller adds no second line. */
+  complete;
+  constructor(path, message, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "ConfigLoadError";
+    this.path = path;
+    this.complete = options?.complete === true;
+  }
+};
+var ConfigValueError = class extends Error {
+  static {
+    __name(this, "ConfigValueError");
+  }
+  source;
+  /** Dot/bracket path to the invalid known setting, without its source. */
+  settingPath;
+  constructor(source, settingPath, message) {
+    const origin = source.kind === "file" ? `config file ${configMetadataLiteral(source.path)}` : `environment variable ${source.variable}`;
+    super(`${origin}: ${settingPath} ${message}`);
+    this.name = "ConfigValueError";
+    this.source = source;
+    this.settingPath = settingPath;
+  }
+};
+function readYamlIfExists(path) {
+  const raw = readIfPresent(path);
+  if (raw === null) return {};
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(raw);
+  } catch (cause) {
+    const at = cause?.linePos?.[0];
+    const where = at === void 0 ? "" : ` (line ${at.line}, column ${at.col})`;
+    throw new ConfigLoadError(
+      path,
+      `${shortHomePath(path)} isn't valid YAML${where}. Fix it, then start Namzu again.`,
+      { cause, complete: true }
+    );
+  }
+  return asConfigObject(path, parsed);
+}
+__name(readYamlIfExists, "readYamlIfExists");
+var PROJECT_FILE_LABEL = "namzu.config.json in this project";
+function shortHomePath(path) {
+  return homePath(path);
+}
+__name(shortHomePath, "shortHomePath");
+function readJsonIfExists(path, label) {
+  const raw = readIfPresent(path);
+  if (raw === null) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ConfigLoadError(path, invalidJsonSentence(label, raw, cause), {
+      cause,
+      complete: true
+    });
+  }
+  return asConfigObject(path, parsed, label);
+}
+__name(readJsonIfExists, "readJsonIfExists");
+function invalidJsonSentence(name, raw, cause) {
+  const position = jsonErrorPosition(raw, cause);
+  let where = "";
+  if (position !== void 0) {
+    const before = raw.slice(0, position);
+    const line = before.split("\n").length;
+    const column = position - (before.lastIndexOf("\n") + 1) + 1;
+    where = ` (line ${line}, column ${column})`;
+  }
+  return `${name} isn't valid JSON${where}. Fix it, then start Namzu again.`;
+}
+__name(invalidJsonSentence, "invalidJsonSentence");
+function jsonErrorPosition(raw, cause) {
+  const text = cause instanceof Error ? cause.message : String(cause);
+  const at = /position (\d+)/.exec(text);
+  if (at) return Math.min(Number(at[1]), raw.length);
+  if (/end of JSON input/i.test(text)) return raw.length;
+  return void 0;
+}
+__name(jsonErrorPosition, "jsonErrorPosition");
+function readIfPresent(path) {
+  try {
+    return stripByteOrderMark(readFileSync(path, "utf8"));
+  } catch (cause) {
+    const code = cause?.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return null;
+    throw new ConfigLoadError(path, `${path} could not be read: ${reasonOf(cause)}`, { cause });
+  }
+}
+__name(readIfPresent, "readIfPresent");
+function asConfigObject(path, parsed, label = shortHomePath(path)) {
+  if (parsed === null || parsed === void 0) return {};
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new ConfigLoadError(
+      path,
+      `${label} must be a set of named settings, not ${describe(parsed)}. Fix it, then start Namzu again.`,
+      { complete: true }
+    );
+  }
+  return sanitize(parsed, { kind: "file", path });
+}
+__name(asConfigObject, "asConfigObject");
+function describe(value) {
+  return Array.isArray(value) ? "a list" : `a ${typeof value}`;
+}
+__name(describe, "describe");
+function stripByteOrderMark(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+__name(stripByteOrderMark, "stripByteOrderMark");
+function reasonOf(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+__name(reasonOf, "reasonOf");
+var COMPOSER_TRIGGERS_KEYS = ["enabled", "suggest", "languages", "builtin"];
+var SKILLS_CONFIG_KEYS = [
+  "builtin",
+  "disabled",
+  "suggest",
+  "suggestMinToolCalls"
+];
+var CONFIG_READERS = {
+  format: /* @__PURE__ */ __name((v, context) => {
+    if (typeof v === "string" && isFormatName(v)) return v;
+    return invalidConfigValue(context, [], 'must be one of "text", "json", or "yaml"');
+  }, "format"),
+  quiet: /* @__PURE__ */ __name((v, context) => {
+    if (typeof v === "boolean") return v;
+    return invalidConfigValue(context, [], "must be a boolean");
+  }, "quiet"),
+  modelCatalogueRefresh: /* @__PURE__ */ __name((v, context) => {
+    if (typeof v === "boolean") return v;
+    return invalidConfigValue(context, [], "must be a boolean");
+  }, "modelCatalogueRefresh"),
+  // Shape only. Per-entry validation belongs to `compilePermissions`, which
+  // reports a bad effect or an unusable pattern as a diagnostic the user
+  // sees; dropping those entries here would silence it.
+  permissions: /* @__PURE__ */ __name((v, context) => {
+    if (isConfigMapping(v)) return v;
+    return invalidConfigValue(context, [], "must be a mapping of tool names");
+  }, "permissions"),
+  // Shape only, like `permissions` and for the same reason: per-entry
+  // validation belongs to `verifyPermissionChecks`, which reports a bad
+  // check by index. Dropping a malformed one here would turn "your check is
+  // unreadable" into "your check passed".
+  permissionChecks: /* @__PURE__ */ __name((v, context) => {
+    if (Array.isArray(v)) return v;
+    return invalidConfigValue(context, [], "must be a list");
+  }, "permissionChecks"),
+  // Every declared profile is checked when its file loads, not only when it is
+  // selected. Typed config in a lower-precedence layer cannot become valid
+  // merely because another layer happens to win today. Unknown profile keys
+  // remain non-strict and are ignored by `sanitize`, like unknown base keys.
+  profiles: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) {
+      return invalidConfigValue(context, [], "must be a mapping of profile names");
+    }
+    const profiles = {};
+    for (const name of Object.keys(v)) {
+      const entry = v[name];
+      if (!isConfigMapping(entry)) {
+        return invalidConfigValue(context, [name], "must be a mapping of settings");
+      }
+      const parsed = sanitize(entry, context.source, [...context.path, name], false);
+      Object.defineProperty(profiles, name, {
+        value: parsed,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    return profiles;
+  }, "profiles"),
+  // Shape only, for the same reason as `permissions`: an entry that names
+  // neither a command nor a url — or both — is reported by name when the
+  // connection is attempted. Dropping it here would turn a mistake the
+  // operator can see into a server that silently was never there.
+  mcpServers: /* @__PURE__ */ __name((v, context) => {
+    if (isConfigMapping(v)) return v;
+    return invalidConfigValue(context, [], "must be a mapping of server names");
+  }, "mcpServers"),
+  memory: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    for (const key of Object.keys(v)) {
+      if (key !== "recall" && key !== "identifierGrounding")
+        return invalidConfigValue(context, [key], "is not a memory key");
+    }
+    if (v.recall !== void 0 && typeof v.recall !== "boolean") {
+      return invalidConfigValue(context, ["recall"], "must be true or false");
+    }
+    if (v.identifierGrounding !== void 0 && typeof v.identifierGrounding !== "boolean") {
+      return invalidConfigValue(context, ["identifierGrounding"], "must be true or false");
+    }
+    return {
+      ...v.recall === void 0 ? {} : { recall: v.recall },
+      ...v.identifierGrounding === void 0 ? {} : { identifierGrounding: v.identifierGrounding }
+    };
+  }, "memory"),
+  compaction: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    const raw = v;
+    for (const key of Object.keys(v)) {
+      if (key !== "strategy" && key !== "contextWindowTokens" && key !== "consolidate" && key !== "recallEvidence" && key !== "resolveEvidenceQueries" && key !== "retainedToolPreviewChars" && key !== "deduplicateObservations") {
+        return invalidConfigValue(context, [key], "is not a compaction key");
+      }
+    }
+    if (raw.deduplicateObservations !== void 0 && typeof raw.deduplicateObservations !== "boolean") {
+      return invalidConfigValue(context, ["deduplicateObservations"], "must be true or false");
+    }
+    if (raw.recallEvidence !== void 0 && typeof raw.recallEvidence !== "boolean")
+      return invalidConfigValue(context, ["recallEvidence"], "must be true or false");
+    if (raw.resolveEvidenceQueries !== void 0 && typeof raw.resolveEvidenceQueries !== "boolean")
+      return invalidConfigValue(context, ["resolveEvidenceQueries"], "must be true or false");
+    if (raw.consolidate !== void 0 && typeof raw.consolidate !== "boolean") {
+      return invalidConfigValue(context, ["consolidate"], "must be true or false");
+    }
+    if (raw.retainedToolPreviewChars !== void 0 && (typeof raw.retainedToolPreviewChars !== "number" || !Number.isSafeInteger(raw.retainedToolPreviewChars) || raw.retainedToolPreviewChars < 0)) {
+      return invalidConfigValue(
+        context,
+        ["retainedToolPreviewChars"],
+        "must be a nonnegative safe integer"
+      );
+    }
+    if (raw.strategy !== void 0 && raw.strategy !== "structured" && raw.strategy !== "salience") {
+      return invalidConfigValue(context, ["strategy"], "must be `structured` or `salience`");
+    }
+    if (raw.contextWindowTokens !== void 0 && (typeof raw.contextWindowTokens !== "number" || !Number.isInteger(raw.contextWindowTokens) || raw.contextWindowTokens <= 0)) {
+      return invalidConfigValue(context, ["contextWindowTokens"], "must be a positive integer");
+    }
+    return {
+      ...raw.strategy !== void 0 ? { strategy: raw.strategy } : {},
+      ...raw.contextWindowTokens !== void 0 ? { contextWindowTokens: raw.contextWindowTokens } : {},
+      ...raw.consolidate !== void 0 ? { consolidate: raw.consolidate } : {},
+      ...raw.recallEvidence !== void 0 ? { recallEvidence: raw.recallEvidence } : {},
+      ...raw.resolveEvidenceQueries !== void 0 ? { resolveEvidenceQueries: raw.resolveEvidenceQueries } : {},
+      ...raw.retainedToolPreviewChars !== void 0 ? { retainedToolPreviewChars: raw.retainedToolPreviewChars } : {},
+      ...raw.deduplicateObservations !== void 0 ? { deduplicateObservations: raw.deduplicateObservations } : {}
+    };
+  }, "compaction"),
+  additionalDirectories: /* @__PURE__ */ __name((v, context) => {
+    if (!Array.isArray(v)) return invalidConfigValue(context, [], "must be a list of directories");
+    for (const [index, entry] of v.entries()) {
+      if (typeof entry !== "string" || entry.trim().length === 0) {
+        return invalidConfigValue(context, [index], "must be a directory path");
+      }
+    }
+    return v;
+  }, "additionalDirectories"),
+  toolResultScreens: /* @__PURE__ */ __name((v, context) => {
+    if (!Array.isArray(v)) {
+      return invalidConfigValue(context, [], "must be a list of screen names");
+    }
+    const names = TOOL_RESULT_SCREEN_NAMES.join(", ");
+    for (const [index, entry] of v.entries()) {
+      if (typeof entry === "string") {
+        if (!isToolResultScreenName(entry)) {
+          return invalidConfigValue(context, [index], `must be one of: ${names}`);
+        }
+        continue;
+      }
+      if (!isConfigMapping(entry)) {
+        return invalidConfigValue(
+          context,
+          [index],
+          "must be a screen name, or a mapping with a `name`"
+        );
+      }
+      const { name, ...options } = entry;
+      if (typeof name !== "string" || !isToolResultScreenName(name)) {
+        return invalidConfigValue(context, [index, "name"], `must be one of: ${names}`);
+      }
+      for (const key of Object.keys(options)) {
+        if (!TOOL_RESULT_SCREEN_OPTION_KEYS[name].includes(key)) {
+          return invalidConfigValue(
+            context,
+            [index, key],
+            `is not an option of the "${name}" screen`
+          );
+        }
+      }
+      const passthroughTools = entry.passthroughTools;
+      if (passthroughTools === void 0) continue;
+      if (!Array.isArray(passthroughTools)) {
+        return invalidConfigValue(
+          context,
+          [index, "passthroughTools"],
+          "must be a list of tool names"
+        );
+      }
+      for (const [position, toolName] of passthroughTools.entries()) {
+        if (typeof toolName !== "string" || toolName.trim().length === 0) {
+          return invalidConfigValue(
+            context,
+            [index, "passthroughTools", position],
+            "must be a tool name"
+          );
+        }
+      }
+    }
+    return v;
+  }, "toolResultScreens"),
+  hooks: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v))
+      return invalidConfigValue(context, [], "must be a mapping of event \u2192 list");
+    const events = new Set(SHELL_HOOK_EVENTS);
+    const out = {};
+    for (const [event, entries] of Object.entries(v)) {
+      const renamed = Object.hasOwn(RENAMED_PLUGIN_HOOK_EVENTS, event) ? RENAMED_PLUGIN_HOOK_EVENTS[event] : void 0;
+      if (renamed !== void 0) {
+        return invalidConfigValue(context, [event], `was renamed; name it \`${renamed}\``);
+      }
+      if (!events.has(event)) {
+        return invalidConfigValue(
+          context,
+          [event],
+          `is not a hook event (${SHELL_HOOK_EVENTS.join(", ")})`
+        );
+      }
+      if (!Array.isArray(entries))
+        return invalidConfigValue(context, [event], "must be a list of hooks");
+      const parsed = [];
+      for (const [index, entry] of entries.entries()) {
+        if (!isConfigMapping(entry)) {
+          return invalidConfigValue(context, [event, index], "must be a mapping with a `command`");
+        }
+        const raw = entry;
+        for (const key of Object.keys(entry)) {
+          if (key !== "command" && key !== "matcher" && key !== "timeoutMs") {
+            return invalidConfigValue(
+              context,
+              [event, index, key],
+              "is not a recognized hook setting"
+            );
+          }
+        }
+        if (typeof raw.command !== "string" || raw.command.trim().length === 0) {
+          return invalidConfigValue(
+            context,
+            [event, index, "command"],
+            "must be a non-empty string"
+          );
+        }
+        if (raw.matcher !== void 0 && typeof raw.matcher !== "string") {
+          return invalidConfigValue(context, [event, index, "matcher"], "must be a string");
+        }
+        if (raw.timeoutMs !== void 0 && (typeof raw.timeoutMs !== "number" || !Number.isInteger(raw.timeoutMs) || raw.timeoutMs <= 0)) {
+          return invalidConfigValue(
+            context,
+            [event, index, "timeoutMs"],
+            "must be a positive integer"
+          );
+        }
+        parsed.push({
+          command: raw.command,
+          ...raw.matcher !== void 0 ? { matcher: raw.matcher } : {},
+          ...raw.timeoutMs !== void 0 ? { timeoutMs: raw.timeoutMs } : {}
+        });
+      }
+      out[event] = parsed;
+    }
+    return out;
+  }, "hooks"),
+  browser: /* @__PURE__ */ __name((v, context) => readBrowserConfig(v, context), "browser"),
+  web: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    for (const key of Object.keys(v)) {
+      if (key !== "fetch" && key !== "search" && key !== "backend")
+        return invalidConfigValue(context, [key], "is not a recognized web setting");
+    }
+    const raw = v;
+    if (raw.backend !== void 0 && raw.backend !== "auto" && raw.backend !== "exa" && raw.backend !== "native")
+      return invalidConfigValue(context, ["backend"], "must be auto, exa or native");
+    if (raw.search === "cached" && raw.backend === "exa")
+      return invalidConfigValue(context, ["backend"], "cached search requires native");
+    if (raw.search !== void 0 && (typeof raw.search !== "string" || !["off", "cached", "live"].includes(raw.search))) {
+      return invalidConfigValue(context, ["search"], "must be off, cached, or live");
+    }
+    if (raw.fetch !== void 0 && typeof raw.fetch !== "boolean") {
+      return invalidConfigValue(context, ["fetch"], "must be a boolean");
+    }
+    return raw;
+  }, "web"),
+  limits: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    for (const key of Object.keys(v)) {
+      if (!["maxIterations", "tokenBudget", "timeoutMs", "waitForProviderMs"].includes(key))
+        return invalidConfigValue(
+          context,
+          [key],
+          "is not a limit (maxIterations, tokenBudget, timeoutMs, waitForProviderMs)"
+        );
+      const value = v[key];
+      const minimum = key === "waitForProviderMs" ? 1 : 0;
+      if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum)
+        return invalidConfigValue(context, [key], `must be a safe whole number at least ${minimum}`);
+      if (key === "timeoutMs" && value > 2147483647)
+        return invalidConfigValue(
+          context,
+          [key],
+          "must be at most 2147483647 milliseconds; use 0 for unlimited"
+        );
+    }
+    return v;
+  }, "limits"),
+  plugins: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    const known = /* @__PURE__ */ new Set(["enabled", "autoDiscovery", "allowedScopes", "hookTimeoutMs"]);
+    for (const key of Object.keys(v)) {
+      if (!known.has(key)) {
+        return invalidConfigValue(context, [key], "is not a recognized plugin setting");
+      }
+    }
+    const raw = v;
+    if (raw.enabled !== void 0 && typeof raw.enabled !== "boolean") {
+      return invalidConfigValue(context, ["enabled"], "must be a boolean");
+    }
+    if (raw.autoDiscovery !== void 0 && typeof raw.autoDiscovery !== "boolean") {
+      return invalidConfigValue(context, ["autoDiscovery"], "must be a boolean");
+    }
+    let allowedScopes;
+    if (raw.allowedScopes !== void 0) {
+      if (!Array.isArray(raw.allowedScopes)) {
+        return invalidConfigValue(context, ["allowedScopes"], "must be a list");
+      }
+      const invalidIndex = raw.allowedScopes.findIndex(
+        (scope) => scope !== "project" && scope !== "user"
+      );
+      if (invalidIndex >= 0) {
+        return invalidConfigValue(
+          context,
+          ["allowedScopes", invalidIndex],
+          'must be one of "project" or "user"'
+        );
+      }
+      if (new Set(raw.allowedScopes).size !== raw.allowedScopes.length) {
+        return invalidConfigValue(context, ["allowedScopes"], "must not contain duplicates");
+      }
+      allowedScopes = raw.allowedScopes;
+    }
+    if (raw.hookTimeoutMs !== void 0 && (!Number.isInteger(raw.hookTimeoutMs) || raw.hookTimeoutMs <= 0 || raw.hookTimeoutMs > 2147483647)) {
+      return invalidConfigValue(
+        context,
+        ["hookTimeoutMs"],
+        "must be an integer from 1 to 2147483647"
+      );
+    }
+    return {
+      ...raw.enabled !== void 0 ? { enabled: raw.enabled } : {},
+      ...raw.autoDiscovery !== void 0 ? { autoDiscovery: raw.autoDiscovery } : {},
+      ...allowedScopes !== void 0 ? { allowedScopes } : {},
+      ...raw.hookTimeoutMs !== void 0 ? { hookTimeoutMs: raw.hookTimeoutMs } : {}
+    };
+  }, "plugins"),
+  // Read field by field rather than shape-only, unlike the two above.
+  // Those hand their entries to a compiler that reports a bad one by name;
+  // this one is consumed directly, and a misspelled `require_isolation` or
+  // a string where a list belongs would otherwise become "no requirement"
+  // — a security control silently downgraded by a typo, which is the
+  // failure this whole change exists to remove.
+  sandbox: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    const raw = v;
+    for (const key of ["enabled", "allowEscape", "allowUnattendedEscape"]) {
+      if (raw[key] !== void 0 && typeof raw[key] !== "boolean") {
+        return invalidConfigValue(context, [key], "must be a boolean");
+      }
+    }
+    if (raw.requireIsolation !== void 0 && !Array.isArray(raw.requireIsolation)) {
+      return invalidConfigValue(context, ["requireIsolation"], "must be a list");
+    }
+    const requireIsolation = raw.requireIsolation;
+    const invalidIndex = requireIsolation?.findIndex(
+      (value) => value !== "filesystem" && value !== "network" && value !== "process"
+    );
+    if (invalidIndex !== void 0 && invalidIndex >= 0) {
+      return invalidConfigValue(
+        context,
+        ["requireIsolation", invalidIndex],
+        'must be one of "filesystem", "network", or "process"'
+      );
+    }
+    if (raw.workspace !== void 0 && raw.workspace !== "working-directory" && raw.workspace !== "ephemeral") {
+      return invalidConfigValue(
+        context,
+        ["workspace"],
+        'must be one of "working-directory" or "ephemeral"'
+      );
+    }
+    if (raw.teardownTimeoutMs !== void 0 && (!Number.isInteger(raw.teardownTimeoutMs) || raw.teardownTimeoutMs < 0 || raw.teardownTimeoutMs > 2147483647)) {
+      return invalidConfigValue(
+        context,
+        ["teardownTimeoutMs"],
+        "must be an integer from 0 to 2147483647"
+      );
+    }
+    return {
+      ...raw.enabled !== void 0 ? { enabled: raw.enabled } : {},
+      ...raw.allowEscape !== void 0 ? { allowEscape: raw.allowEscape } : {},
+      ...raw.allowUnattendedEscape !== void 0 ? { allowUnattendedEscape: raw.allowUnattendedEscape } : {},
+      ...requireIsolation !== void 0 ? {
+        requireIsolation
+      } : {},
+      ...raw.workspace !== void 0 ? { workspace: raw.workspace } : {},
+      ...raw.teardownTimeoutMs !== void 0 ? { teardownTimeoutMs: raw.teardownTimeoutMs } : {}
+    };
+  }, "sandbox"),
+  // Field by field, for the same reason as `sandbox` and one stronger:
+  // this one decides whether conversation content leaves the machine. A
+  // misspelled `redacters` read shape-only could change the export's security
+  // posture while it still ran. A malformed known field therefore refuses the
+  // config rather than selecting either "off" or a different redactor set.
+  telemetry: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    const raw = v;
+    if (raw.sessionExport === void 0) return {};
+    const se = raw.sessionExport;
+    if (!isConfigMapping(se)) {
+      return invalidConfigValue(context, ["sessionExport"], "must be a mapping");
+    }
+    const entry = se;
+    if (typeof entry.destination !== "string" || entry.destination.length === 0) {
+      return invalidConfigValue(
+        context,
+        ["sessionExport", "destination"],
+        "must be a non-empty string"
+      );
+    }
+    let eventTypes;
+    if (entry.eventTypes !== void 0) {
+      if (!Array.isArray(entry.eventTypes)) {
+        return invalidConfigValue(context, ["sessionExport", "eventTypes"], "must be a list");
+      }
+      const invalidIndex = entry.eventTypes.findIndex((event) => typeof event !== "string");
+      if (invalidIndex >= 0) {
+        return invalidConfigValue(
+          context,
+          ["sessionExport", "eventTypes", invalidIndex],
+          "must be a string"
+        );
+      }
+      eventTypes = entry.eventTypes;
+    }
+    let redactors;
+    if (entry.redactors !== void 0) {
+      if (!Array.isArray(entry.redactors)) {
+        return invalidConfigValue(context, ["sessionExport", "redactors"], "must be a list");
+      }
+      const invalidIndex = entry.redactors.findIndex((redactor) => redactor !== "secrets");
+      if (invalidIndex >= 0) {
+        return invalidConfigValue(
+          context,
+          ["sessionExport", "redactors", invalidIndex],
+          'must be "secrets"'
+        );
+      }
+      redactors = entry.redactors;
+    }
+    return {
+      sessionExport: {
+        destination: entry.destination,
+        ...eventTypes !== void 0 ? { eventTypes } : {},
+        ...redactors !== void 0 ? { redactors } : {}
+      }
+    };
+  }, "telemetry"),
+  // TUI notifications are terminal escape writes only. Invalid nested values
+  // refuse rather than silently selecting a different event/protocol or
+  // disabling the feature the operator explicitly configured.
+  skills: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    for (const key of Object.keys(v)) {
+      if (!SKILLS_CONFIG_KEYS.includes(key)) {
+        return invalidConfigValue(
+          context,
+          [key],
+          `is not a skills setting (${SKILLS_CONFIG_KEYS.join(", ")})`
+        );
+      }
+    }
+    const raw = v;
+    if (raw.builtin !== void 0 && typeof raw.builtin !== "boolean") {
+      return invalidConfigValue(context, ["builtin"], "must be true or false");
+    }
+    if (raw.suggest !== void 0 && typeof raw.suggest !== "boolean") {
+      return invalidConfigValue(context, ["suggest"], "must be true or false");
+    }
+    if (raw.suggestMinToolCalls !== void 0 && (typeof raw.suggestMinToolCalls !== "number" || !Number.isInteger(raw.suggestMinToolCalls) || raw.suggestMinToolCalls < 1)) {
+      return invalidConfigValue(
+        context,
+        ["suggestMinToolCalls"],
+        "must be a whole number of at least 1"
+      );
+    }
+    if (raw.disabled !== void 0 && (!Array.isArray(raw.disabled) || raw.disabled.some((name) => typeof name !== "string" || name.trim() === ""))) {
+      return invalidConfigValue(context, ["disabled"], "must be a list of skill names");
+    }
+    return {
+      ...raw.builtin !== void 0 ? { builtin: raw.builtin } : {},
+      ...raw.disabled !== void 0 ? { disabled: raw.disabled.map((name) => name.trim()) } : {},
+      ...raw.suggest !== void 0 ? { suggest: raw.suggest } : {},
+      ...raw.suggestMinToolCalls !== void 0 ? { suggestMinToolCalls: raw.suggestMinToolCalls } : {}
+    };
+  }, "skills"),
+  schedule: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    for (const key of Object.keys(v)) {
+      if (key !== "maxConcurrentRuns" && key !== "notifications") {
+        return invalidConfigValue(
+          context,
+          [key],
+          "is not a schedule setting (maxConcurrentRuns, notifications)"
+        );
+      }
+    }
+    const raw = v;
+    if (raw.maxConcurrentRuns !== void 0 && (typeof raw.maxConcurrentRuns !== "number" || !Number.isSafeInteger(raw.maxConcurrentRuns) || raw.maxConcurrentRuns < 1 || raw.maxConcurrentRuns > 16)) {
+      return invalidConfigValue(
+        context,
+        ["maxConcurrentRuns"],
+        "must be a whole number from 1 to 16"
+      );
+    }
+    if (raw.notifications !== void 0 && typeof raw.notifications !== "boolean") {
+      return invalidConfigValue(context, ["notifications"], "must be a boolean");
+    }
+    return {
+      ...raw.maxConcurrentRuns !== void 0 ? { maxConcurrentRuns: raw.maxConcurrentRuns } : {},
+      ...raw.notifications !== void 0 ? { notifications: raw.notifications } : {}
+    };
+  }, "schedule"),
+  // Shape only: the words themselves are matched by the interactive
+  // terminal, which is the only reader. A wrong key or value still refuses,
+  // because an operator who wrote `enabled: flase` believes it is off.
+  composerTriggers: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    for (const key of Object.keys(v)) {
+      if (!COMPOSER_TRIGGERS_KEYS.includes(key)) {
+        return invalidConfigValue(
+          context,
+          [key],
+          `is not a composerTriggers setting (${COMPOSER_TRIGGERS_KEYS.join(", ")})`
+        );
+      }
+    }
+    const raw = v;
+    for (const key of ["enabled", "suggest"]) {
+      if (raw[key] !== void 0 && typeof raw[key] !== "boolean")
+        return invalidConfigValue(context, [key], "must be true or false");
+    }
+    let languages;
+    if (raw.languages !== void 0) {
+      if (!Array.isArray(raw.languages))
+        return invalidConfigValue(context, ["languages"], "must be a list: en, tr");
+      languages = [];
+      for (const [index, language] of raw.languages.entries()) {
+        if (!COMPOSER_TRIGGER_LANGUAGES.includes(language))
+          return invalidConfigValue(context, ["languages", index], "must be en or tr");
+        languages.push(language);
+      }
+    }
+    let builtin;
+    if (raw.builtin !== void 0) {
+      if (!isConfigMapping(raw.builtin))
+        return invalidConfigValue(
+          context,
+          ["builtin"],
+          "must be a mapping of trigger to arm, suggest or off"
+        );
+      builtin = {};
+      for (const [id, arming] of Object.entries(raw.builtin)) {
+        if (!COMPOSER_TRIGGER_IDS.includes(id))
+          return invalidConfigValue(
+            context,
+            ["builtin", id],
+            `is not a built-in trigger (${COMPOSER_TRIGGER_IDS.join(", ")})`
+          );
+        if (arming !== "arm" && arming !== "suggest" && arming !== "off")
+          return invalidConfigValue(context, ["builtin", id], "must be arm, suggest or off");
+        builtin[id] = arming;
+      }
+    }
+    return {
+      ...raw.enabled !== void 0 ? { enabled: raw.enabled } : {},
+      ...raw.suggest !== void 0 ? { suggest: raw.suggest } : {},
+      ...languages !== void 0 ? { languages } : {},
+      ...builtin !== void 0 ? { builtin } : {}
+    };
+  }, "composerTriggers"),
+  tui: /* @__PURE__ */ __name((v, context) => {
+    if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+    const raw = v;
+    let notifications;
+    if (typeof raw.notifications === "boolean") notifications = raw.notifications;
+    else if (Array.isArray(raw.notifications)) {
+      const invalidIndex = raw.notifications.findIndex(
+        (event) => event !== "turn-settled" && event !== "approval-required"
+      );
+      if (invalidIndex >= 0) {
+        return invalidConfigValue(
+          context,
+          ["notifications", invalidIndex],
+          'must be one of "turn-settled" or "approval-required"'
+        );
+      }
+      notifications = raw.notifications;
+    } else if (raw.notifications !== void 0) {
+      return invalidConfigValue(context, ["notifications"], "must be a boolean or a list");
+    }
+    const method = raw.notificationMethod;
+    if (method !== void 0 && method !== "osc9" && method !== "bel") {
+      return invalidConfigValue(context, ["notificationMethod"], 'must be "osc9" or "bel"');
+    }
+    return {
+      ...notifications !== void 0 ? { notifications } : {},
+      ...method !== void 0 ? { notificationMethod: method } : {}
+    };
+  }, "tui")
+};
+var ENV_VARIABLE_NAMES = {
+  format: "NAMZU_FORMAT",
+  quiet: "NAMZU_QUIET",
+  permissions: void 0,
+  // Deliberately not env-settable, and for a sharper reason than the rest:
+  // a variable that could replace the checks could also empty them, which
+  // would silence the one thing that says a policy stopped meaning what its
+  // author wrote — from a shell profile, with nothing in the config file to
+  // show for it.
+  permissionChecks: void 0,
+  // The SET of profiles is not env-settable — it is the thing being chosen
+  // BETWEEN, and a variable that could replace it could hand a shell a
+  // profile the files never declared. `NAMZU_PROFILE` selects one of the
+  // declared profiles and is read in the cascade rather than here, because
+  // it does not set a config field.
+  profiles: void 0,
+  mcpServers: void 0,
+  // Executable code must never be enabled by ambient shell state. The file
+  // and its provenance are the reviewable source of this authority.
+  plugins: void 0,
+  sandbox: void 0,
+  limits: void 0,
+  // Outbound reach is opted into in the file, never from the environment.
+  web: void 0,
+  // A browser signed in to the operator's sites, and which of them it may
+  // change: a file decision, never a shell's.
+  browser: void 0,
+  // A hook runs a command with the operator's authority; the file is the only
+  // place one may be declared.
+  hooks: void 0,
+  additionalDirectories: void 0,
+  // Absent here for the reason `additionalDirectories` is: the environment
+  // carries scalars, and a screen is a list of names whose meaning belongs
+  // where a project's runs are reviewed.
+  toolResultScreens: void 0,
+  // A strategy is a property of a project's runs, declared where they are reviewed.
+  compaction: void 0,
+  memory: void 0,
+  // Deliberately not env-settable. A `NAMZU_TELEMETRY_SESSION_EXPORT=/tmp/x`
+  // in a shell profile would start exporting conversation content with
+  // nothing in the config file to show for it — the disclosure would be
+  // honest and the *reason* would be invisible.
+  telemetry: void 0,
+  // Terminal notifications are an interactive UI choice. An environment
+  // variable in a shell profile must not start producing them invisibly.
+  tui: void 0,
+  // How many unattended runs a machine starts is the machine owner's to say,
+  // in a file; never a variable a profile could carry invisibly.
+  schedule: void 0,
+  // A list of names and a switch that decide what reaches the model's prompt;
+  // declared in a file, where a project's runs are reviewed.
+  skills: void 0,
+  // What typed words do in the operator's own composer: a file decision,
+  // never a variable a shell profile could carry invisibly.
+  composerTriggers: void 0,
+  // A scalar switch, and the one a CI job or a test harness needs to keep a
+  // launch off the network without writing a config file.
+  modelCatalogueRefresh: "NAMZU_MODEL_CATALOGUE_REFRESH"
+};
+function readEnv(env) {
+  const config = {};
+  const variables = {};
+  const formatVar = ENV_VARIABLE_NAMES.format;
+  if (formatVar) {
+    const format = env[formatVar];
+    if (format !== void 0) {
+      if (!isFormatName(format)) {
+        throw new ConfigValueError(
+          { kind: "environment", variable: formatVar },
+          "format",
+          'must be one of "text", "json", or "yaml"'
+        );
+      }
+      config.format = format;
+      variables.format = formatVar;
+    }
+  }
+  const quietVar = ENV_VARIABLE_NAMES.quiet;
+  if (quietVar) {
+    const quiet = env[quietVar];
+    if (quiet !== void 0) {
+      if (quiet !== "1" && quiet !== "true" && quiet !== "0" && quiet !== "false") {
+        throw new ConfigValueError(
+          { kind: "environment", variable: quietVar },
+          "quiet",
+          'must be one of "1", "true", "0", or "false"'
+        );
+      }
+      config.quiet = quiet === "1" || quiet === "true";
+      variables.quiet = quietVar;
+    }
+  }
+  const refreshVar = ENV_VARIABLE_NAMES.modelCatalogueRefresh;
+  if (refreshVar) {
+    const refresh = env[refreshVar];
+    if (refresh !== void 0) {
+      if (refresh !== "1" && refresh !== "true" && refresh !== "0" && refresh !== "false") {
+        throw new ConfigValueError(
+          { kind: "environment", variable: refreshVar },
+          "modelCatalogueRefresh",
+          'must be one of "1", "true", "0", or "false"'
+        );
+      }
+      config.modelCatalogueRefresh = refresh === "1" || refresh === "true";
+      variables.modelCatalogueRefresh = refreshVar;
+    }
+  }
+  return { config, variables };
+}
+__name(readEnv, "readEnv");
+function sanitize(value, source, prefix = [], allowProfiles = true) {
+  const v = value;
+  const out = {};
+  for (const key of Object.keys(CONFIG_READERS)) {
+    if (!Object.hasOwn(v, key)) continue;
+    if (!allowProfiles && (key === "profiles" || key === "plugins")) {
+      throw new ConfigValueError(
+        source,
+        formatSettingPath([...prefix, key]),
+        key === "plugins" ? "cannot be declared inside a profile because profiles may be selected by the environment" : "cannot be declared inside a profile"
+      );
+    }
+    const parsed = CONFIG_READERS[key](v[key], {
+      source,
+      path: [...prefix, key]
+    });
+    out[key] = parsed;
+  }
+  return out;
+}
+__name(sanitize, "sanitize");
+function isConfigMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isConfigMapping, "isConfigMapping");
+function invalidConfigValue(context, suffix, message) {
+  throw new ConfigValueError(
+    context.source,
+    formatSettingPath([...context.path, ...suffix]),
+    message
+  );
+}
+__name(invalidConfigValue, "invalidConfigValue");
+function formatSettingPath(segments) {
+  let out = "";
+  for (const segment of segments) {
+    if (typeof segment === "number") {
+      out += `[${segment}]`;
+      continue;
+    }
+    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
+      out += out === "" ? segment : `.${segment}`;
+      continue;
+    }
+    out += `[${configMetadataLiteral(segment)}]`;
+  }
+  return out;
+}
+__name(formatSettingPath, "formatSettingPath");
+function constantLayer(config, source) {
+  return { config, sourceFor: /* @__PURE__ */ __name(() => source, "sourceFor") };
+}
+__name(constantLayer, "constantLayer");
+function mergeConfigs(...layers) {
+  const out = {};
+  const provenance = {};
+  for (const layer of layers) {
+    for (const key of Object.keys(layer.config)) {
+      if (key === "browser" && layer.config.browser) {
+        out.browser = mergeBrowserConfig(out.browser, layer.config.browser, layer.sourceFor(key));
+        provenance[key] = layer.sourceFor(key);
+        continue;
+      }
+      if (key === "composerTriggers" && layer.config.composerTriggers) {
+        out.composerTriggers = mergeComposerTriggers(
+          out.composerTriggers,
+          layer.config.composerTriggers,
+          isProjectSource(layer.sourceFor(key))
+        );
+        provenance[key] = layer.sourceFor(key);
+        continue;
+      }
+      ;
+      out[key] = layer.config[key];
+      provenance[key] = layer.sourceFor(key);
+    }
+  }
+  return { config: out, provenance };
+}
+__name(mergeConfigs, "mergeConfigs");
+var BROWSER_KEYS = /* @__PURE__ */ new Set([
+  "enabled",
+  "defaultProfile",
+  "engine",
+  "headless",
+  "sites",
+  "keepOpen"
+]);
+var BROWSER_PROFILE_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function readBrowserConfig(v, context) {
+  if (!isConfigMapping(v)) return invalidConfigValue(context, [], "must be a mapping");
+  for (const key of Object.keys(v)) {
+    if (!BROWSER_KEYS.has(key)) {
+      return invalidConfigValue(
+        context,
+        [key],
+        "is not a browser setting (enabled, defaultProfile, engine, headless, sites, keepOpen)"
+      );
+    }
+  }
+  const raw = v;
+  for (const key of ["enabled", "keepOpen"]) {
+    if (raw[key] !== void 0 && typeof raw[key] !== "boolean")
+      return invalidConfigValue(context, [key], "must be true or false");
+  }
+  if (raw.defaultProfile !== void 0 && (typeof raw.defaultProfile !== "string" || raw.defaultProfile.length > 64 || !BROWSER_PROFILE_NAME.test(raw.defaultProfile))) {
+    return invalidConfigValue(
+      context,
+      ["defaultProfile"],
+      "must be a profile name: lowercase letters, digits and single hyphens, at most 64 characters"
+    );
+  }
+  if (raw.engine !== void 0 && !["auto", "windows", "local"].includes(raw.engine))
+    return invalidConfigValue(context, ["engine"], "must be auto, windows or local");
+  if (raw.headless !== void 0 && !["auto", "always", "never"].includes(raw.headless))
+    return invalidConfigValue(context, ["headless"], "must be auto, always or never");
+  let sites;
+  if (raw.sites !== void 0) {
+    if (!isConfigMapping(raw.sites))
+      return invalidConfigValue(context, ["sites"], "must be a mapping of site to level");
+    sites = {};
+    for (const [key, level] of Object.entries(raw.sites)) {
+      if (!isBrowserSiteLevel(level))
+        return invalidConfigValue(context, ["sites", key], "must be deny, read, ask or act");
+      const verdict = canonicalBrowserSiteKey(key);
+      if (!verdict.ok) return invalidConfigValue(context, ["sites", key], verdict.reason);
+      const existing = sites[verdict.key];
+      sites[verdict.key] = existing === void 0 ? level : narrower(existing, level);
+    }
+  }
+  return {
+    ...raw.enabled !== void 0 ? { enabled: raw.enabled } : {},
+    ...raw.defaultProfile !== void 0 ? { defaultProfile: raw.defaultProfile } : {},
+    ...raw.engine !== void 0 ? { engine: raw.engine } : {},
+    ...raw.headless !== void 0 ? { headless: raw.headless } : {},
+    ...sites !== void 0 ? { sites } : {},
+    ...raw.keepOpen !== void 0 ? { keepOpen: raw.keepOpen } : {}
+  };
+}
+__name(readBrowserConfig, "readBrowserConfig");
+function isProjectSource(source) {
+  return source.kind === "project-file" || source.kind === "profile" && basename(source.path) === "namzu.config.json";
+}
+__name(isProjectSource, "isProjectSource");
+function mergeBrowserConfig(below, layer, source) {
+  if (layer.defaultProfile !== void 0 && isProjectSource(source)) {
+    throw new ConfigValueError(
+      { kind: "file", path: "path" in source ? source.path : "namzu.config.json" },
+      "browser.defaultProfile",
+      "cannot be set in a project file: a profile holds your sign-ins, so choose it in your user config or with /browser profile"
+    );
+  }
+  if (!below) return layer;
+  let sites = below.sites;
+  if (layer.sites) {
+    const merged = { ...below.sites ?? {} };
+    const closed = below.sites?.["*"] === "deny";
+    for (const [key, level] of Object.entries(layer.sites)) {
+      const existing = merged[key];
+      if (existing === void 0) {
+        if (closed && key !== "*") continue;
+        merged[key] = level;
+        continue;
+      }
+      merged[key] = existing === "deny" ? "deny" : level;
+    }
+    sites = merged;
+  }
+  const enabled = below.enabled === false || layer.enabled === false ? false : layer.enabled ?? below.enabled;
+  return {
+    ...below,
+    ...layer,
+    ...enabled !== void 0 ? { enabled } : {},
+    ...sites !== void 0 ? { sites } : {}
+  };
+}
+__name(mergeBrowserConfig, "mergeBrowserConfig");
+
+export {
+  canonicalBrowserSiteKey,
+  compileBrowserSites,
+  withBrowserSiteRules,
+  browserSiteRuleFor,
+  browserCallOrigin,
+  COMPOSER_TRIGGER_IDS,
+  COMPOSER_TRIGGER_DEFAULTS,
+  resolveComposerTriggers,
+  DEFAULT_CONFIG,
+  loadConfigWithProvenance,
+  loadBootstrapConfigWithProvenance,
+  readPermissionLayers,
+  loadConfig,
+  ConfigLoadError,
+  ConfigValueError
+};
+//# sourceMappingURL=chunk-YYQJIECC.js.map