@kyo-so/cli 0.5.0 → 0.6.0

package/dist/bin/kyoso.js

@@ -8125,7 +8125,7 @@ ${lanes.join(`
           writeOutputIsTTY() {
             return process.stdout.isTTY;
           },
-          readFile: readFile2,
+          readFile: readFile3,
           writeFile: writeFile22,
           watchFile: watchFile2,
           watchDirectory,
@@ -8318,7 +8318,7 @@ ${lanes.join(`
         function fsWatchWorker(fileOrDirectory, recursive, callback) {
           return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ? { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
         }
-        function readFile2(fileName, _encoding) {
+        function readFile3(fileName, _encoding) {
           let buffer;
           try {
             buffer = _fs.readFileSync(fileName);
@@ -39385,7 +39385,7 @@ ${lanes.join(`
       const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
       return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
     }
-    function parseCommandLineWorker(diagnostics, commandLine, readFile2) {
+    function parseCommandLineWorker(diagnostics, commandLine, readFile3) {
       const options = {};
       let watchOptions;
       const fileNames = [];
@@ -39423,7 +39423,7 @@ ${lanes.join(`
         }
       }
       function parseResponseFile(fileName) {
-        const text = tryReadFile(fileName, readFile2 || ((fileName2) => sys.readFile(fileName2)));
+        const text = tryReadFile(fileName, readFile3 || ((fileName2) => sys.readFile(fileName2)));
         if (!isString(text)) {
           errors3.push(text);
           return;
@@ -39526,8 +39526,8 @@ ${lanes.join(`
       unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
       optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
     };
-    function parseCommandLine(commandLine, readFile2) {
-      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile2);
+    function parseCommandLine(commandLine, readFile3) {
+      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile3);
     }
     function getOptionFromName(optionName, allowShort) {
       return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
@@ -39595,8 +39595,8 @@ ${lanes.join(`
       result.originalFileName = result.fileName;
       return parseJsonSourceFileConfigFileContent(result, host, getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd), optionsToExtend, getNormalizedAbsolutePath(configFileName, cwd), undefined, extraFileExtensions, extendedConfigCache, watchOptionsToExtend);
     }
-    function readConfigFile(fileName, readFile2) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile2);
+    function readConfigFile(fileName, readFile3) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile3);
       return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
     }
     function parseConfigFileTextToJson(fileName, jsonText) {
@@ -39606,14 +39606,14 @@ ${lanes.join(`
         error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined
       };
     }
-    function readJsonConfigFile(fileName, readFile2) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile2);
+    function readJsonConfigFile(fileName, readFile3) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile3);
       return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
     }
-    function tryReadFile(fileName, readFile2) {
+    function tryReadFile(fileName, readFile3) {
       let text;
       try {
-        text = readFile2(fileName);
+        text = readFile3(fileName);
       } catch (e) {
         return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
       }
@@ -107510,12 +107510,12 @@ ${lanes.join(`
     function createCompilerHost(options, setParentNodes) {
       return createCompilerHostWorker(options, setParentNodes);
     }
-    function createGetSourceFile(readFile2, setParentNodes) {
+    function createGetSourceFile(readFile3, setParentNodes) {
       return (fileName, languageVersionOrOptions, onError) => {
         let text;
         try {
           mark("beforeIORead");
-          text = readFile2(fileName);
+          text = readFile3(fileName);
           mark("afterIORead");
           measure("I/O Read", "beforeIORead", "afterIORead");
         } catch (e) {
@@ -108306,7 +108306,7 @@ ${lanes.join(`
         getRedirectFromOutput,
         forEachResolvedProjectReference: forEachResolvedProjectReference2
       });
-      const readFile2 = host.readFile.bind(host);
+      const readFile3 = host.readFile.bind(host);
       (_e = tracing) == null || _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
       const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
       (_f = tracing) == null || _f.pop();
@@ -108483,7 +108483,7 @@ ${lanes.join(`
         shouldTransformImportCall,
         emitBuildInfo,
         fileExists,
-        readFile: readFile2,
+        readFile: readFile3,
         directoryExists,
         getSymlinkCache,
         realpath: (_o = host.realpath) == null ? undefined : _o.bind(host),
@@ -121385,7 +121385,7 @@ ${lanes.join(`
           if (importingFile !== usableByFileName)
             return;
           return forEachEntry(exportInfo, (info, key2) => {
-            const { symbolName: symbolName2, ambientModuleName } = parseKey(key2);
+            const { symbolName: symbolName2, ambientModuleName } = parseKey2(key2);
             const name = preferCapitalized && info[0].capitalizedSymbolName || symbolName2;
             if (matches(name, info[0].targetFlags)) {
               const rehydrated = info.map(rehydrateCachedInfo);
@@ -121449,7 +121449,7 @@ ${lanes.join(`
         const moduleKey = ambientModuleName || "";
         return `${importedName.length} ${getSymbolId(skipAlias(symbol2, checker))} ${importedName} ${moduleKey}`;
       }
-      function parseKey(key2) {
+      function parseKey2(key2) {
         const firstSpace = key2.indexOf(" ");
         const secondSpace = key2.indexOf(" ", firstSpace + 1);
         const symbolNameLength = parseInt(key2.substring(0, firstSpace), 10);
@@ -150513,14 +150513,14 @@ ${newComment.split(`
     });
     function mapCode(sourceFile, contents, focusLocations, host, formatContext, preferences) {
       return ts_textChanges_exports.ChangeTracker.with({ host, formatContext, preferences }, (changeTracker) => {
-        const parsed = contents.map((c) => parse5(sourceFile, c));
+        const parsed = contents.map((c) => parse6(sourceFile, c));
         const flattenedLocations = focusLocations && flatten(focusLocations);
         for (const nodes of parsed) {
           placeNodeGroup(sourceFile, changeTracker, nodes, flattenedLocations);
         }
       });
     }
-    function parse5(sourceFile, content) {
+    function parse6(sourceFile, content) {
       const nodeKinds = [
         {
           parse: () => createSourceFile("__mapcode_content_nodes.ts", content, sourceFile.languageVersion, true, sourceFile.scriptKind),
@@ -169600,12 +169600,13 @@ function languageFromPath(path) {
 
 // src/cli/doctor.ts
 import { accessSync } from "node:fs";
-import { delimiter as delimiter2 } from "node:path";
+import { delimiter as delimiter2, resolve as resolve4 } from "node:path";
 
 // src/config/loadConfig.ts
-import { access as access2, readFile as readFile3 } from "node:fs/promises";
+import { access as access2, readFile as readFile4 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
 import { stderr, stdin } from "node:process";
-import { resolve as resolve2 } from "node:path";
+import { extname as extname3, join as join2, resolve as resolve2 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 
 // src/config/defaultConfig.ts
@@ -169648,7 +169649,7 @@ var defaultConfig = {
       command: "npx",
       args: ["-y", "@agentclientprotocol/claude-agent-acp@0.57.0"],
       role: "architecture_security_reviewer",
-      timeoutMs: 240000,
+      timeoutMs: 300000,
       env: {
         KYOSO_CHILD_AGENT: "1"
       },
@@ -169736,6 +169737,172 @@ var defaultConfig = {
   }
 };
 
+// src/config/projectScope.ts
+var PROJECT_GLOBAL_ONLY_MESSAGE = "Move global-only settings to the user global config:";
+function mergeProjectTomlConfig(baseConfig, projectConfig, options) {
+  const violations = collectProjectScopeViolations(projectConfig);
+  if (violations.length > 0) {
+    throw new Error(formatProjectScopeError(violations, options));
+  }
+  const projectDeny = readPath(projectConfig, ["workspace", "deny"]);
+  const mergeableProjectConfig = omitPath(projectConfig, ["workspace", "deny"]);
+  const merged = deepMerge(baseConfig, mergeableProjectConfig);
+  if (projectDeny !== undefined) {
+    writePath(merged, ["workspace", "deny"], Array.isArray(projectDeny) && allStrings(projectDeny) ? unionStrings(readStringArray(baseConfig, ["workspace", "deny"]), [
+      ...projectDeny
+    ]) : projectDeny);
+  }
+  return merged;
+}
+function collectProjectScopeViolations(config) {
+  const leaves = flattenLeaves(config);
+  const violations = [];
+  for (const leaf of leaves) {
+    const path = leaf.path.join(".");
+    if (!isAllowedProjectPath(leaf.path)) {
+      violations.push({ path });
+      continue;
+    }
+    const reason = tightenOnlyReason(leaf.path, leaf.value);
+    if (reason)
+      violations.push({ path, reason });
+  }
+  return violations.sort((left, right) => left.path.localeCompare(right.path));
+}
+function isAllowedProjectPath(path) {
+  const [top, second, third, fourth] = path;
+  if (top === "tools" && path.length === 2 && ["planReview", "securityReview", "diffReview"].includes(second ?? "")) {
+    return true;
+  }
+  if (top === "agents" && path.length === 3 && ["codex", "claude"].includes(second ?? "") && ["enabled", "model", "role", "timeoutMs"].includes(third ?? "")) {
+    return true;
+  }
+  if (top === "verification" && path.length === 2 && ["enabled", "maxFindings", "timeoutMs"].includes(second ?? "")) {
+    return true;
+  }
+  if (top === "workspace" && path.length === 2 && ["maxContextBytes", "maxDiffBytes", "deny"].includes(second ?? "")) {
+    return true;
+  }
+  if (top === "network" && second === "defaultMode" && path.length === 2) {
+    return true;
+  }
+  if (top === "secrets" && path.length === 2 && ["blockOnDetectedSecret", "allowOverride"].includes(second ?? "")) {
+    return true;
+  }
+  if (top === "judge" && path.length === 2 && ["mode", "provider", "timeoutMs"].includes(second ?? "")) {
+    return true;
+  }
+  if (top === "securityReview" && second === "cisaSecureByDesign" && path.length >= 3) {
+    if (third === "dimensions") {
+      return path.length === 4 && [
+        "customerSecurityOutcomes",
+        "secureByDefault",
+        "transparencyAndAccountability",
+        "governance"
+      ].includes(fourth ?? "");
+    }
+    return path.length === 3 && ["enabled", "gate"].includes(third ?? "");
+  }
+  return false;
+}
+function tightenOnlyReason(path, value) {
+  const dotted = path.join(".");
+  if (dotted === "network.defaultMode" && value !== "model_only") {
+    return 'must be "model_only" in project TOML';
+  }
+  if (dotted === "secrets.blockOnDetectedSecret" && value !== true) {
+    return "must be true in project TOML";
+  }
+  if (dotted === "secrets.allowOverride" && value !== false) {
+    return "must be false in project TOML";
+  }
+  if (path[0] === "securityReview" && path[1] === "cisaSecureByDesign" && value !== true) {
+    return "must be true in project TOML";
+  }
+  return;
+}
+function formatProjectScopeError(violations, options) {
+  const entries = violations.map((violation) => violation.reason ? `${violation.path} (${violation.reason})` : violation.path);
+  return [
+    `Project TOML config ${options.projectPath} contains settings that are not allowed in project scope: ${entries.join(", ")}`,
+    `${PROJECT_GLOBAL_ONLY_MESSAGE} ${options.globalConfigPath}. If a key is misspelled, fix the name instead.`
+  ].join(`
+`);
+}
+function flattenLeaves(value, path = []) {
+  if (!isRecord(value))
+    return path.length > 0 ? [{ path, value }] : [];
+  const entries = Object.entries(value);
+  if (entries.length === 0)
+    return path.length > 0 ? [{ path, value }] : [];
+  return entries.flatMap(([key, child]) => flattenLeaves(child, [...path, key]));
+}
+function omitPath(value, path) {
+  if (!isRecord(value) || path.length === 0)
+    return value;
+  const [head, ...tail] = path;
+  if (head === undefined)
+    return value;
+  const result = { ...value };
+  if (tail.length === 0) {
+    delete result[head];
+  } else {
+    const child = omitPath(result[head], tail);
+    if (isRecord(child) && Object.keys(child).length === 0) {
+      delete result[head];
+    } else {
+      result[head] = child;
+    }
+  }
+  return result;
+}
+function readPath(value, path) {
+  let current = value;
+  for (const key of path) {
+    if (!isRecord(current))
+      return;
+    current = current[key];
+  }
+  return current;
+}
+function writePath(target, path, value) {
+  if (!isRecord(target))
+    return;
+  let current = target;
+  for (const key of path.slice(0, -1)) {
+    const child = current[key];
+    if (!isRecord(child)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const leaf = path.at(-1);
+  if (leaf)
+    current[leaf] = value;
+}
+function readStringArray(value, path) {
+  const found = readPath(value, path);
+  return Array.isArray(found) && allStrings(found) ? [...found] : [];
+}
+function unionStrings(base, override) {
+  return [...new Set([...base, ...override])];
+}
+function allStrings(values) {
+  return values.every((value) => typeof value === "string");
+}
+function deepMerge(base, override) {
+  if (!isRecord(base) || !isRecord(override))
+    return override ?? base;
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    result[key] = deepMerge(result[key], value);
+  }
+  return result;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -184099,6 +184266,1059 @@ var kyosoConfigSchema = exports_external.object({
     includeFileContents: exports_external.boolean()
   })
 });
+function agentConfigLeafPaths(agent) {
+  return [
+    `agents.${agent}.enabled`,
+    `agents.${agent}.type`,
+    `agents.${agent}.command`,
+    `agents.${agent}.args`,
+    `agents.${agent}.model`,
+    `agents.${agent}.role`,
+    `agents.${agent}.timeoutMs`,
+    `agents.${agent}.env`,
+    `agents.${agent}.auth.mode`,
+    `agents.${agent}.auth.preferExistingLogin`,
+    `agents.${agent}.auth.preferApiKey`,
+    `agents.${agent}.auth.recommendedEnv`,
+    `agents.${agent}.auth.envWhitelist`
+  ];
+}
+var kyosoConfigKnownLeafPaths = [
+  "entrypoints.mcp",
+  "entrypoints.cli",
+  "firstClassClient",
+  "tools.planReview",
+  "tools.securityReview",
+  "tools.diffReview",
+  ...agentConfigLeafPaths("codex"),
+  ...agentConfigLeafPaths("claude"),
+  "workspace.mode",
+  "workspace.root",
+  "workspace.readOnly",
+  "workspace.maxContextBytes",
+  "workspace.maxDiffBytes",
+  "workspace.deny",
+  "secrets.mode",
+  "secrets.blockOnDetectedSecret",
+  "secrets.allowOverride",
+  "network.defaultMode",
+  "network.allowUnrestricted",
+  "network.warnOnUnrestricted",
+  "network.mediatedWeb.enabled",
+  "securityReview.cisaSecureByDesign.enabled",
+  "securityReview.cisaSecureByDesign.gate",
+  "securityReview.cisaSecureByDesign.dimensions.customerSecurityOutcomes",
+  "securityReview.cisaSecureByDesign.dimensions.secureByDefault",
+  "securityReview.cisaSecureByDesign.dimensions.transparencyAndAccountability",
+  "securityReview.cisaSecureByDesign.dimensions.governance",
+  "judge.mode",
+  "judge.provider",
+  "judge.timeoutMs",
+  "verification.enabled",
+  "verification.maxFindings",
+  "verification.timeoutMs",
+  "verification.allowDemotion",
+  "audit.enabled",
+  "audit.format",
+  "audit.directory",
+  "audit.includeRawAgentOutput",
+  "audit.includeFileContents"
+];
+var kyosoConfigRecordPrefixes = [
+  "agents.codex.env",
+  "agents.claude.env"
+];
+var kyosoConfigSecuritySensitivePrefixes = [
+  "agents.codex",
+  "agents.claude",
+  "audit",
+  "judge",
+  "network",
+  "secrets",
+  "securityReview",
+  "verification",
+  "workspace"
+];
+
+// src/security/redact.ts
+var REDACTION = "[KYOSO_REDACTED]";
+
+// src/core/constants.ts
+var DEFAULT_AGENT_TIMEOUT_MS = 120000;
+var RAW_OUTPUT_MAX_CHARS = 16384;
+var KYOSO_CHILD_AGENT = "KYOSO_CHILD_AGENT";
+var KYOSO_VERSION = "0.6.0";
+
+// src/security/sanitizeText.ts
+var SENSITIVE_TEXT_PATTERNS = [
+  /\bsk-(?:proj-)?[A-Za-z0-9_-]{8,}\b/g,
+  /\bsk-ant-[A-Za-z0-9_-]{8,}\b/g,
+  /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{8,}\b/g,
+  /\bAKIA[0-9A-Z]{8,}\b/g,
+  /\bxox[baprs]-[A-Za-z0-9-]{8,}\b/g,
+  /\bsk_(?:live|test)_[A-Za-z0-9]{8,}\b/g,
+  /\b(?:api[_-]?key|secret|token|password)\b\s*[:=]\s*["']?[A-Za-z0-9_./+=-]{8,}["']?/gi
+];
+function sanitizeText(value) {
+  return SENSITIVE_TEXT_PATTERNS.reduce((text, pattern) => text.replace(pattern, REDACTION), value);
+}
+function sanitizeTextForDisplay(value, maxChars = 240) {
+  const compact = sanitizeText(value).replace(/\s+/g, " ").trim();
+  if (compact.length <= maxChars)
+    return compact;
+  return `${compact.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function sanitizeTextForRawOutput(value, maxChars = RAW_OUTPUT_MAX_CHARS) {
+  const sanitized = sanitizeText(value);
+  const limit = Math.max(0, maxChars);
+  if (sanitized.length <= limit)
+    return sanitized;
+  return `${sanitized.slice(0, limit)}
+[KYOSO_TRUNCATED: ${sanitized.length - limit} chars omitted]`;
+}
+
+// src/config/tomlConfigLoader.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// node_modules/smol-toml/dist/date.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+
+class TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date5) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date5 === "string") {
+      let match = date5.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date5 = `0000-01-01T${date5}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date5[10] === " " && (date5 = date5.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date5 = "";
+        } else {
+          offset = match[3] || null;
+          date5 = date5.toUpperCase();
+          if (!offset && hasTime)
+            date5 += "Z";
+        }
+      } else {
+        date5 = "";
+      }
+    }
+    super(date5);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 60000);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date5 = new TomlDate(jsDate);
+    date5.#offset = offset;
+    return date5;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date5 = new TomlDate(jsDate);
+    date5.#offset = null;
+    return date5;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date5 = new TomlDate(jsDate);
+    date5.#hasTime = false;
+    date5.#offset = null;
+    return date5;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date5 = new TomlDate(jsDate);
+    date5.#hasDate = false;
+    date5.#offset = null;
+    return date5;
+  }
+}
+
+// node_modules/smol-toml/dist/error.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+function getLineColFromPtr(string4, ptr) {
+  let lines = string4.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string4, line, column) {
+  let lines = string4.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1;i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += `
+`;
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += `^
+`;
+    }
+  }
+  return codeblock;
+}
+
+class TomlError extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+}
+
+// node_modules/smol-toml/dist/primitive.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+function parseString(str, ptr) {
+  let c = str[ptr++];
+  let first = c;
+  let isLiteral = c === "'";
+  let isMultiline = c === str[ptr] && c === str[ptr + 1];
+  if (isMultiline) {
+    if (str[ptr += 2] === `
+`)
+      ptr++;
+    else if (str[ptr] === "\r" && str[ptr + 1] === `
+`)
+      ptr += 2;
+  }
+  let parsed = "";
+  let sliceStart = ptr;
+  let state = 0;
+  for (let i = ptr;i < str.length; i++) {
+    c = str[i];
+    if (isMultiline && (c === `
+` || c === "\r" && str[i + 1] === `
+`)) {
+      state = state && 3;
+    } else if (c < " " && c !== "\t" || c === "") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: i
+      });
+    } else if ((!state || state === 3) && c === first && (!isMultiline || str[i + 1] === first && str[i + 2] === first)) {
+      if (isMultiline) {
+        if (str[i + 3] === first)
+          i++;
+        if (str[i + 3] === first)
+          i++;
+      }
+      return [
+        state ? parsed : parsed + str.slice(sliceStart, i),
+        i + (isMultiline ? 3 : 1)
+      ];
+    } else if (!state) {
+      if (!isLiteral && c === "\\") {
+        parsed += str.slice(sliceStart, sliceStart = i);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === "x" || c === "u" || c === "U") {
+        let value = 0;
+        let len = c === "x" ? 2 : c === "u" ? 4 : 8;
+        for (let j = 0;j < len; j++, i++) {
+          let hex3 = str.charCodeAt(i + 1);
+          let digit = hex3 >= 48 && hex3 <= 57 ? hex3 - 48 : hex3 >= 65 && hex3 <= 70 ? hex3 - 65 + 10 : hex3 >= 97 && hex3 <= 102 ? hex3 - 97 + 10 : -1;
+          if (digit < 0)
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: str, ptr: i + 1 });
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          throw new TomlError("invalid unicode escape", { toml: str, ptr: i });
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = i + 1;
+        state = 0;
+      } else if (c === " " || c === "\t") {
+        state = 2;
+      } else {
+        if (c === "b")
+          parsed += "\b";
+        else if (c === "t")
+          parsed += "\t";
+        else if (c === "n")
+          parsed += `
+`;
+        else if (c === "f")
+          parsed += "\f";
+        else if (c === "r")
+          parsed += "\r";
+        else if (c === "e")
+          parsed += "\x1B";
+        else if (c === '"')
+          parsed += '"';
+        else if (c === "\\")
+          parsed += "\\";
+        else
+          throw new TomlError("unrecognized escape sequence", { toml: str, ptr: i });
+        sliceStart = i + 1;
+        state = 0;
+      }
+    } else if (c !== " " && c !== "\t") {
+      if (state === 2) {
+        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: str,
+          ptr: sliceStart
+        });
+      }
+      state = !isLiteral && c === "\\" ? 1 : 0;
+      sliceStart = i;
+    }
+  }
+  throw new TomlError("unfinished string", { toml: str, ptr });
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date5 = new TomlDate(value);
+  if (!date5.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date5;
+}
+
+// node_modules/smol-toml/dist/util.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf(`
+`, start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr;i < str.length; i++) {
+    let c = str[i];
+    if (c === `
+`)
+      return i;
+    if (c === "\r" && str[i + 1] === `
+`)
+      return i + 1;
+    if (c < " " && c !== "\t" || c === "") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while (true) {
+    while ((c = str[ptr]) === " " || c === "\t" || !banNewLines && (c === `
+` || c === "\r" && str[ptr + 1] === `
+`))
+      ptr++;
+    if (banComments || c !== "#")
+      break;
+    ptr = skipComment(str, ptr);
+  }
+  return ptr;
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr;i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+    } else if (c === sep) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === `
+` || c === "\r" && str[i + 1] === `
+`)) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+
+// node_modules/smol-toml/dist/extract.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  if (c === '"' || c === "'") {
+    let [parsed, endPtr2] = parseString(str, ptr);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] && str[endPtr2] !== "," && str[endPtr2] !== end && str[endPtr2] !== `
+` && str[endPtr2] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+      if (str[endPtr2] === ",")
+        endPtr2++;
+    }
+    return [parsed, endPtr2];
+  }
+  let endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - (str[endPtr - 1] === "," ? 1 : 0));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    if (str[endPtr] === ",")
+      endPtr++;
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+
+// node_modules/smol-toml/dist/struct.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "\t") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let [part, eos] = parseString(str, ptr);
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(part);
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = new Set;
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "\t" && c !== `
+` && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0;i < key.length; i++) {
+        if (i)
+          t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str,
+            ptr
+          });
+        }
+        if (!hasOwn && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "\t" && c !== `
+` && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+
+// node_modules/smol-toml/dist/parse.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+function peekTable(key, table, meta3, type) {
+  let t = table;
+  let m = meta3;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0;i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse5(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
+  let res = {};
+  let meta3 = {};
+  let tbl = res;
+  let m = meta3;
+  for (let ptr = skipVoid(toml, 0);ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(k[0], res, meta3, isTableArray ? 2 : 1);
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(k[0], tbl, m, 0);
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], undefined, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== `
+` && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+
+// node_modules/smol-toml/dist/stringify.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// node_modules/smol-toml/dist/index.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// src/config/tomlConfigLoader.ts
+async function loadTomlConfigFile(configPath) {
+  const source = await readFile2(configPath, "utf8");
+  try {
+    return parse5(source);
+  } catch (error51) {
+    throw new Error(formatTomlError(configPath, error51));
+  }
+}
+function formatTomlError(configPath, error51) {
+  if (error51 instanceof TomlError) {
+    return `TOML config parse failed for ${configPath} at ${error51.line}:${error51.column}: ${error51.message}`;
+  }
+  return `TOML config parse failed for ${configPath}: ${error51 instanceof Error ? error51.message : String(error51)}`;
+}
 
 // src/config/tsConfigLoader.ts
 var import_typescript = __toESM(require_typescript(), 1);
@@ -184143,14 +185363,14 @@ ${transpiled}
 
 // src/config/trustedConfig.ts
 import { createHash } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname as dirname3, join, resolve } from "node:path";
 function hashConfigSource(source) {
   return createHash("sha256").update(source).digest("hex");
 }
 function defaultTrustedConfigStorePath(env = process.env) {
-  return env.KYOSO_TRUST_STORE_PATH ? resolve(env.KYOSO_TRUST_STORE_PATH) : join(homedir(), ".kyoso", "trusted-configs.json");
+  return env.KYOSO_TRUST_STORE_PATH ? resolve(env.KYOSO_TRUST_STORE_PATH) : join(env.HOME ? resolve(env.HOME) : homedir(), ".kyoso", "trusted-configs.json");
 }
 async function isTrustedConfig(storePath, configPath, configHash) {
   const store = await readTrustedConfigStore(storePath);
@@ -184169,7 +185389,7 @@ async function trustConfig(storePath, configPath, configHash) {
 async function readTrustedConfigStore(storePath) {
   let parsed;
   try {
-    parsed = JSON.parse(await readFile2(storePath, "utf8"));
+    parsed = JSON.parse(await readFile3(storePath, "utf8"));
   } catch (error51) {
     if (isMissingPathError(error51))
       return {};
@@ -184177,7 +185397,7 @@ async function readTrustedConfigStore(storePath) {
       return {};
     throw error51;
   }
-  if (!isRecord(parsed))
+  if (!isRecord2(parsed))
     return {};
   const store = {};
   for (const [configPath, configHash] of Object.entries(parsed)) {
@@ -184186,7 +185406,7 @@ async function readTrustedConfigStore(storePath) {
   }
   return store;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isMissingPathError(error51) {
@@ -184194,44 +185414,178 @@ function isMissingPathError(error51) {
 }
 
 // src/config/loadConfig.ts
+var KNOWN_GLOBAL_CONFIG_LEAF_PATHS = new Set(kyosoConfigKnownLeafPaths);
+var GLOBAL_CONFIG_RECORD_PREFIXES = kyosoConfigRecordPrefixes.map((path) => path.split("."));
+var SECURITY_SENSITIVE_GLOBAL_PREFIXES = kyosoConfigSecuritySensitivePrefixes.map((path) => path.split("."));
 async function loadConfig(options = {}) {
   const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const globalConfigPath = resolveGlobalTomlConfigPath(env);
   const warnings = [];
-  let userConfig = {};
+  const sources = [];
+  let mergedConfig = defaultConfig;
   let configPath;
   let configHash;
   let configTrustStatus = options.ignoreConfig ? "ignored" : "not_found";
   if (!options.ignoreConfig) {
-    const candidate = resolve2(cwd, options.configPath ?? "kyoso.config.ts");
-    if (await exists2(candidate)) {
-      configPath = candidate;
-      const source = await readFile3(candidate, "utf8");
-      configHash = hashConfigSource(source);
-      const trustStorePath = options.trustStorePath ?? defaultTrustedConfigStorePath();
-      const trusted = await isTrustedConfig(trustStorePath, candidate, configHash);
-      const trustDecision = await resolveTrustDecision({
-        configPath: candidate,
-        configHash,
-        trusted,
+    if (await exists2(globalConfigPath)) {
+      const globalConfig2 = await loadTomlConfigFile(globalConfigPath);
+      const globalConfigWarnings = collectGlobalConfigWarnings(globalConfigPath, globalConfig2);
+      const securitySensitiveWarnings = globalConfigWarnings.filter((warning) => warning.startsWith("security-sensitive unknown settings "));
+      if (securitySensitiveWarnings.length > 0 && !options.allowUnknownConfig) {
+        throw new Error(`Security-sensitive unknown config settings rejected. Fix the key name or pass --allow-unknown-config to continue with warnings: ${securitySensitiveWarnings.join("; ")}`);
+      }
+      warnings.push(...globalConfigWarnings);
+      mergedConfig = deepMerge2(mergedConfig, globalConfig2);
+      sources.push({ path: globalConfigPath, layer: "global_toml" });
+    }
+    if (options.configPath) {
+      const explicitConfigPath = resolve2(cwd, options.configPath);
+      if (!await exists2(explicitConfigPath)) {
+        throw new Error(`Config file not found: ${explicitConfigPath} (from --config)`);
+      }
+      const loaded = await loadProjectConfig({
+        configPath: explicitConfigPath,
+        baseConfig: mergedConfig,
+        globalConfigPath,
         options
       });
-      configTrustStatus = trustDecision.status;
-      if (trustDecision.execute) {
-        userConfig = await loadUserConfig(candidate, source);
-        if (trustDecision.shouldPersist) {
-          await trustConfig(trustStorePath, candidate, configHash);
-        }
-      } else {
-        warnings.push(`untrusted config was not executed: ${candidate}; run \`kyoso doctor --trust-config\` or pass \`--trust-config\` once to trust it`);
+      mergedConfig = loaded.mergedConfig;
+      configPath = loaded.configPath;
+      configHash = loaded.configHash;
+      configTrustStatus = loaded.configTrustStatus;
+      sources.push(loaded.source);
+      warnings.push(...loaded.warnings);
+    } else {
+      const projectTomlPath = resolve2(cwd, "kyoso.toml");
+      const projectTsPath = resolve2(cwd, "kyoso.config.ts");
+      const hasProjectToml = await exists2(projectTomlPath);
+      const hasProjectTs = await exists2(projectTsPath);
+      if (hasProjectToml) {
+        mergedConfig = mergeProjectTomlConfig(mergedConfig, await loadTomlConfigFile(projectTomlPath), { projectPath: projectTomlPath, globalConfigPath });
+        configPath = projectTomlPath;
+        sources.push({ path: projectTomlPath, layer: "project_toml" });
+        if (hasProjectTs) {
+          warnings.push(`kyoso.config.ts was ignored because kyoso.toml takes precedence: ${projectTsPath}`);
+        }
+      } else if (hasProjectTs) {
+        const loaded = await loadProjectTsConfig({
+          configPath: projectTsPath,
+          baseConfig: mergedConfig,
+          options
+        });
+        mergedConfig = loaded.mergedConfig;
+        configPath = loaded.configPath;
+        configHash = loaded.configHash;
+        configTrustStatus = loaded.configTrustStatus;
+        sources.push(loaded.source);
+        warnings.push(...loaded.warnings);
       }
     }
   }
-  const parsed = kyosoConfigSchema.parse(deepMerge(defaultConfig, userConfig));
+  const parsed = kyosoConfigSchema.parse(mergedConfig);
   return {
     config: parsed,
     configPath,
     configHash,
     configTrustStatus,
+    sources,
+    warnings
+  };
+}
+function resolveGlobalTomlConfigPath(env = process.env) {
+  const configHome = env.XDG_CONFIG_HOME ? resolve2(env.XDG_CONFIG_HOME) : join2(env.HOME ? resolve2(env.HOME) : homedir2(), ".config");
+  return join2(configHome, "kyoso", "config.toml");
+}
+function collectGlobalConfigWarnings(configPath, config2) {
+  const unknownSettings = flattenLeaves(config2).map((leaf) => leaf.path).filter((path) => !isKnownGlobalConfigPath(path)).map((path) => ({
+    path: sanitizeWarningText(path.join(".")),
+    securitySensitive: isSecuritySensitiveGlobalPath(path)
+  })).sort((left, right) => left.path.localeCompare(right.path));
+  const warnings = [];
+  const securitySensitivePaths = unknownSettings.filter((setting) => setting.securitySensitive).map((setting) => setting.path);
+  const generalPaths = unknownSettings.filter((setting) => !setting.securitySensitive).map((setting) => setting.path);
+  const sanitizedConfigPath = sanitizeWarningText(configPath);
+  if (securitySensitivePaths.length > 0) {
+    warnings.push(`security-sensitive unknown settings in ${sanitizedConfigPath} were ignored: ${formatUnknownPaths(securitySensitivePaths)}`);
+  }
+  if (generalPaths.length > 0) {
+    warnings.push(`unknown settings in ${sanitizedConfigPath} were ignored: ${formatUnknownPaths(generalPaths)}`);
+  }
+  return warnings;
+}
+function sanitizeWarningText(value) {
+  const withoutControlChars = value.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
+  return sanitizeText(withoutControlChars);
+}
+function formatUnknownPaths(paths) {
+  return paths.map((path) => JSON.stringify(path)).join("; ");
+}
+function isSecuritySensitiveGlobalPath(path) {
+  return SECURITY_SENSITIVE_GLOBAL_PREFIXES.some((prefix) => pathStartsWith(path, prefix));
+}
+function isKnownGlobalConfigPath(path) {
+  if (KNOWN_GLOBAL_CONFIG_LEAF_PATHS.has(path.join(".")))
+    return true;
+  return GLOBAL_CONFIG_RECORD_PREFIXES.some((prefix) => pathStartsWith(path, prefix));
+}
+function pathStartsWith(path, prefix) {
+  return path.length >= prefix.length && prefix.every((part, index) => path[index] === part);
+}
+async function loadProjectConfig(input2) {
+  const extension = extname3(input2.configPath);
+  if (extension === ".toml") {
+    return {
+      mergedConfig: mergeProjectTomlConfig(input2.baseConfig, await loadTomlConfigFile(input2.configPath), {
+        projectPath: input2.configPath,
+        globalConfigPath: input2.globalConfigPath
+      }),
+      configPath: input2.configPath,
+      configTrustStatus: "not_found",
+      source: { path: input2.configPath, layer: "project_toml" },
+      warnings: []
+    };
+  }
+  if (extension === ".ts") {
+    return await loadProjectTsConfig(input2);
+  }
+  throw new Error(`Unsupported config file extension for ${input2.configPath}. Expected .toml or .ts.`);
+}
+async function loadProjectTsConfig(input2) {
+  const warnings = [
+    'kyoso.config.ts is deprecated; migrate to kyoso.toml (see README "Configuration")'
+  ];
+  const source = await readFile4(input2.configPath, "utf8");
+  const configHash = hashConfigSource(source);
+  const trustStorePath = input2.options.trustStorePath ?? defaultTrustedConfigStorePath(input2.options.env);
+  const trusted = await isTrustedConfig(trustStorePath, input2.configPath, configHash);
+  const trustDecision = await resolveTrustDecision({
+    configPath: input2.configPath,
+    configHash,
+    trusted,
+    options: input2.options
+  });
+  if (trustDecision.execute) {
+    const userConfig = await loadUserConfig(input2.configPath, source);
+    if (trustDecision.shouldPersist) {
+      await trustConfig(trustStorePath, input2.configPath, configHash);
+    }
+    return {
+      mergedConfig: deepMerge2(input2.baseConfig, userConfig),
+      configPath: input2.configPath,
+      configHash,
+      configTrustStatus: trustDecision.status,
+      source: { path: input2.configPath, layer: "project_ts" },
+      warnings
+    };
+  }
+  warnings.push(`untrusted config was not executed: ${input2.configPath}; run \`kyoso doctor --trust-config\` or pass \`--trust-config\` once to trust it`);
+  return {
+    mergedConfig: input2.baseConfig,
+    configPath: input2.configPath,
+    configHash,
+    configTrustStatus: trustDecision.status,
+    source: { path: input2.configPath, layer: "project_ts" },
     warnings
   };
 }
@@ -184281,16 +185635,16 @@ async function promptForConfigTrust(configPath, configHash) {
     rl.close();
   }
 }
-function deepMerge(base, override) {
-  if (!isRecord2(base) || !isRecord2(override))
+function deepMerge2(base, override) {
+  if (!isRecord3(base) || !isRecord3(override))
     return override ?? base;
   const result = { ...base };
   for (const [key, value] of Object.entries(override)) {
-    result[key] = deepMerge(result[key], value);
+    result[key] = deepMerge2(result[key], value);
   }
   return result;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function exists2(path) {
@@ -184302,43 +185656,6 @@ async function exists2(path) {
   }
 }
 
-// src/security/redact.ts
-var REDACTION = "[KYOSO_REDACTED]";
-
-// src/core/constants.ts
-var DEFAULT_AGENT_TIMEOUT_MS = 120000;
-var RAW_OUTPUT_MAX_CHARS = 16384;
-var KYOSO_CHILD_AGENT = "KYOSO_CHILD_AGENT";
-var KYOSO_VERSION = "0.5.0";
-
-// src/security/sanitizeText.ts
-var SENSITIVE_TEXT_PATTERNS = [
-  /\bsk-(?:proj-)?[A-Za-z0-9_-]{8,}\b/g,
-  /\bsk-ant-[A-Za-z0-9_-]{8,}\b/g,
-  /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{8,}\b/g,
-  /\bAKIA[0-9A-Z]{8,}\b/g,
-  /\bxox[baprs]-[A-Za-z0-9-]{8,}\b/g,
-  /\bsk_(?:live|test)_[A-Za-z0-9]{8,}\b/g,
-  /\b(?:api[_-]?key|secret|token|password)\b\s*[:=]\s*["']?[A-Za-z0-9_./+=-]{8,}["']?/gi
-];
-function sanitizeText(value) {
-  return SENSITIVE_TEXT_PATTERNS.reduce((text, pattern) => text.replace(pattern, REDACTION), value);
-}
-function sanitizeTextForDisplay(value, maxChars = 240) {
-  const compact = sanitizeText(value).replace(/\s+/g, " ").trim();
-  if (compact.length <= maxChars)
-    return compact;
-  return `${compact.slice(0, Math.max(0, maxChars - 3))}...`;
-}
-function sanitizeTextForRawOutput(value, maxChars = RAW_OUTPUT_MAX_CHARS) {
-  const sanitized = sanitizeText(value);
-  const limit = Math.max(0, maxChars);
-  if (sanitized.length <= limit)
-    return sanitized;
-  return `${sanitized.slice(0, limit)}
-[KYOSO_TRUNCATED: ${sanitized.length - limit} chars omitted]`;
-}
-
 // src/judge/prompt.ts
 var ANALYSIS_MAX_ITEMS = 5;
 var ANALYSIS_MAX_CHARS = 500;
@@ -184387,7 +185704,7 @@ function parseJudgeOutput(text, fallbackSummaryText) {
   const parsed = JSON.parse(json2);
   const summaryText = typeof parsed.summaryText === "string" && parsed.summaryText.trim().length > 0 ? sanitizeText(parsed.summaryText) : fallbackSummaryText;
   const disagreementComments = Array.isArray(parsed.disagreementComments) ? parsed.disagreementComments.flatMap((item) => {
-    if (!isRecord3(item) || typeof item.topic !== "string" || typeof item.judgeComment !== "string") {
+    if (!isRecord4(item) || typeof item.topic !== "string" || typeof item.judgeComment !== "string") {
       return [];
     }
     return [
@@ -184403,7 +185720,7 @@ function parseJudgeOutput(text, fallbackSummaryText) {
   return { summaryText, disagreementComments, analysis };
 }
 function parseAnalysis(value) {
-  if (!isRecord3(value))
+  if (!isRecord4(value))
     return;
   if (!Array.isArray(value.blindSpots) || !Array.isArray(value.contradictions) || !Array.isArray(value.partialCoverage)) {
     return;
@@ -184411,7 +185728,7 @@ function parseAnalysis(value) {
   return {
     blindSpots: value.blindSpots.slice(0, ANALYSIS_MAX_ITEMS).flatMap((item) => typeof item === "string" ? [sanitizeAnalysisText(item)] : []),
     contradictions: value.contradictions.slice(0, ANALYSIS_MAX_ITEMS).flatMap((item) => {
-      if (!isRecord3(item) || typeof item.topic !== "string" || typeof item.detail !== "string") {
+      if (!isRecord4(item) || typeof item.topic !== "string" || typeof item.detail !== "string") {
         return [];
       }
       return [
@@ -184422,7 +185739,7 @@ function parseAnalysis(value) {
       ];
     }),
     partialCoverage: value.partialCoverage.slice(0, ANALYSIS_MAX_ITEMS).flatMap((item) => {
-      if (!isRecord3(item) || typeof item.note !== "string")
+      if (!isRecord4(item) || typeof item.note !== "string")
         return [];
       const findingId = typeof item.findingId === "string" ? sanitizeAnalysisText(item.findingId) : undefined;
       return [
@@ -184469,7 +185786,7 @@ function extractFirstJsonObject(text) {
   }
   return;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -184616,9 +185933,9 @@ function hasEnv(env, key) {
 // src/cli/setup.ts
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { cp, mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { delimiter, dirname as dirname4, join as join2 } from "node:path";
+import { cp, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { delimiter, dirname as dirname4, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function runSetup(options) {
   const client = parseClient(options.client);
@@ -184626,7 +185943,7 @@ async function runSetup(options) {
   const command = options.command ? parseCommandSpec(options.command) : commandForRunner(runner);
   const context = {
     cwd: options.cwd,
-    home: options.env?.HOME ?? homedir2(),
+    home: options.env?.HOME ?? homedir3(),
     env: options.env ?? process.env,
     write: options.write,
     scope: options.global ? "global" : "project",
@@ -184672,21 +185989,21 @@ function buildClaudeMcpEntry(command) {
 function skillDestination(client, scope, cwd, home) {
   if (client === "codex") {
     const root2 = scope === "global" ? home : cwd;
-    return join2(root2, ".agents", "skills", "kyoso-review");
+    return join3(root2, ".agents", "skills", "kyoso-review");
   }
   const root = scope === "global" ? home : cwd;
-  return join2(root, ".claude", "skills", "kyoso-review");
+  return join3(root, ".claude", "skills", "kyoso-review");
 }
 function detectSetup(options) {
-  const home = options.home ?? homedir2();
+  const home = options.home ?? homedir3();
   return {
     codex: {
-      mcp: hasCodexMcp(join2(home, ".codex", "config.toml")),
-      skill: existsSync(join2(options.cwd, ".agents", "skills", "kyoso-review", "SKILL.md")) || existsSync(join2(home, ".agents", "skills", "kyoso-review", "SKILL.md"))
+      mcp: hasCodexMcp(join3(home, ".codex", "config.toml")),
+      skill: existsSync(join3(options.cwd, ".agents", "skills", "kyoso-review", "SKILL.md")) || existsSync(join3(home, ".agents", "skills", "kyoso-review", "SKILL.md"))
     },
     "claude-code": {
-      mcp: hasClaudeMcp(join2(options.cwd, ".mcp.json")) || hasClaudeMcp(join2(home, ".claude.json")),
-      skill: existsSync(join2(options.cwd, ".claude", "skills", "kyoso-review", "SKILL.md")) || existsSync(join2(home, ".claude", "skills", "kyoso-review", "SKILL.md"))
+      mcp: hasClaudeMcp(join3(options.cwd, ".mcp.json")) || hasClaudeMcp(join3(home, ".claude.json")),
+      skill: existsSync(join3(options.cwd, ".claude", "skills", "kyoso-review", "SKILL.md")) || existsSync(join3(home, ".claude", "skills", "kyoso-review", "SKILL.md"))
     }
   };
 }
@@ -184715,7 +186032,7 @@ async function setupClaudeCode(context) {
   ];
 }
 async function ensureCodexMcp(context) {
-  const configPath = join2(context.home, ".codex", "config.toml");
+  const configPath = join3(context.home, ".codex", "config.toml");
   const snippet = buildCodexMcpToml(context.mcpCommand);
   const current = await readOptionalFile(configPath);
   if (hasCodexMcpContent(current)) {
@@ -184747,10 +186064,10 @@ async function ensureClaudeMcp(context) {
   if (context.scope === "global") {
     return ensureClaudeGlobalMcp(context);
   }
-  const configPath = join2(context.cwd, ".mcp.json");
+  const configPath = join3(context.cwd, ".mcp.json");
   const current = await readJsonObject(configPath);
   const mcpServers = recordValue(current.mcpServers);
-  if (isRecord4(mcpServers.kyoso)) {
+  if (isRecord5(mcpServers.kyoso)) {
     return {
       title: "Claude Code MCP",
       status: "skipped",
@@ -184784,7 +186101,7 @@ async function ensureClaudeMcp(context) {
   };
 }
 function ensureClaudeGlobalMcp(context) {
-  const configPath = join2(context.home, ".claude.json");
+  const configPath = join3(context.home, ".claude.json");
   if (hasClaudeMcp(configPath)) {
     return {
       title: "Claude Code MCP",
@@ -184816,7 +186133,7 @@ function ensureClaudeGlobalMcp(context) {
   };
 }
 async function ensureSkill(options) {
-  const destinationSkill = join2(options.destinationDir, "SKILL.md");
+  const destinationSkill = join3(options.destinationDir, "SKILL.md");
   if (existsSync(destinationSkill)) {
     return {
       title: options.title,
@@ -184937,8 +186254,8 @@ function resolveBundledSkillDir() {
   const start = dirname4(fileURLToPath(import.meta.url));
   let current = start;
   for (let depth = 0;depth < 5; depth += 1) {
-    const candidate = join2(current, ".agents", "skills", "kyoso-review");
-    if (existsSync(join2(candidate, "SKILL.md")))
+    const candidate = join3(current, ".agents", "skills", "kyoso-review");
+    if (existsSync(join3(candidate, "SKILL.md")))
       return candidate;
     current = dirname4(current);
   }
@@ -184946,7 +186263,7 @@ function resolveBundledSkillDir() {
 }
 async function readOptionalFile(path) {
   try {
-    return await readFile4(path, "utf8");
+    return await readFile5(path, "utf8");
   } catch (error51) {
     if (isMissingPathError2(error51))
       return "";
@@ -184958,7 +186275,7 @@ async function readJsonObject(path) {
   if (content.trim().length === 0)
     return {};
   const parsed = JSON.parse(content);
-  if (!isRecord4(parsed))
+  if (!isRecord5(parsed))
     throw new Error(`${path} must contain a JSON object`);
   return parsed;
 }
@@ -184979,9 +186296,9 @@ function hasClaudeMcp(path) {
   }
 }
 function jsonHasKyosoMcp(value) {
-  if (!isRecord4(value))
+  if (!isRecord5(value))
     return false;
-  if (isRecord4(value.mcpServers) && isRecord4(value.mcpServers.kyoso)) {
+  if (isRecord5(value.mcpServers) && isRecord5(value.mcpServers.kyoso)) {
     return true;
   }
   return Object.values(value).some((child) => jsonHasKyosoMcp(child));
@@ -184992,7 +186309,7 @@ function readTextSync(path) {
 function recordValue(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function diffForAppend(path, snippet) {
@@ -185069,7 +186386,7 @@ function shellQuote(value) {
 }
 function commandExists(command, env) {
   const paths = env.PATH?.split(delimiter) ?? [];
-  return paths.some((path) => existsSync(join2(path, command)));
+  return paths.some((path) => existsSync(join3(path, command)));
 }
 function isMissingPathError2(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
@@ -185079,11 +186396,16 @@ function isMissingPathError2(error51) {
 async function runDoctor(options) {
   const env = options.env ?? process.env;
   const loaded = await loadConfig(options);
+  const globalConfigPath = resolveGlobalTomlConfigPath(env);
+  const projectTomlPath = resolve4(options.cwd, "kyoso.toml");
+  const projectTsPath = resolve4(options.cwd, "kyoso.config.ts");
   const lines = ["Kyoso doctor", "", "Runtime"];
   lines.push(`  Bun: ${commandExists2("bun", env) ? "ok" : "warning not found"}`);
   lines.push(`  Node/npm: ${commandExists2("npm", env) ? "ok" : "warning npm not found"}`);
   lines.push("", "Config");
-  lines.push(`  kyoso.config.ts: ${loaded.configPath ? `found ${loaded.configPath}` : "not found; using defaults"}`);
+  lines.push(`  global config.toml: ${formatLayer(loaded, "global_toml", globalConfigPath)}`);
+  lines.push(`  kyoso.toml: ${formatLayer(loaded, "project_toml", projectTomlPath)}`);
+  lines.push(`  kyoso.config.ts: ${formatProjectTsLayer(loaded, projectTsPath)}`);
   lines.push(`  trusted config: ${formatTrustStatus(loaded.configTrustStatus)}`);
   if (loaded.configHash)
     lines.push(`  config hash: ${loaded.configHash}`);
@@ -185119,7 +186441,7 @@ async function runDoctor(options) {
     lines.push(`  ${agent === "codex" ? "Codex" : "Claude"}: ${exists3 ? "ok" : "warning command not found"}`);
     lines.push(`    command: ${[config2.command, ...config2.args].join(" ")}`);
     if (!exists3 && config2.command === "npx" && commandExists2("bunx", env)) {
-      lines.push('    hint: replace command "npx" with "bunx" in kyoso.config.ts');
+      lines.push('    hint: set agents.<name>.command = "bunx" in config.toml');
     }
     if (agent === "claude") {
       const hasApiKey = hasEnv2(env, "ANTHROPIC_API_KEY");
@@ -185157,6 +186479,19 @@ async function runDoctor(options) {
   return lines.join(`
 `);
 }
+function formatLayer(loaded, layer, defaultPath) {
+  const source = loaded.sources.find((candidate) => candidate.layer === layer);
+  return source ? `found ${source.path}` : `not found ${defaultPath}`;
+}
+function formatProjectTsLayer(loaded, defaultPath) {
+  const source = loaded.sources.find((candidate) => candidate.layer === "project_ts");
+  if (source)
+    return `found ${source.path} (deprecated)`;
+  if (loaded.warnings.some((warning) => warning.includes("was ignored"))) {
+    return `ignored ${defaultPath} (kyoso.toml takes precedence)`;
+  }
+  return `not found ${defaultPath}`;
+}
 function formatTrustStatus(status) {
   if (status === "trusted_by_flag")
     return "trusted by --trust-config";
@@ -185190,26 +186525,31 @@ function commandExists2(command, env) {
 }
 
 // src/cli/init.ts
-import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { access as access3, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
 async function runInit(options) {
-  const configPath = join3(options.cwd, "kyoso.config.ts");
-  const skillPath = join3(options.cwd, ".agents/skills/kyoso-review/SKILL.md");
-  const gitignorePath = join3(options.cwd, ".gitignore");
+  const configPath = join4(options.cwd, "kyoso.toml");
+  const tsConfigPath = join4(options.cwd, "kyoso.config.ts");
+  const skillPath = join4(options.cwd, ".agents/skills/kyoso-review/SKILL.md");
+  const gitignorePath = join4(options.cwd, ".gitignore");
   const configResult = await writeFileWithOverwritePrompt(configPath, CONFIG_TEMPLATE, options.force);
   const skillResult = await writeFileWithOverwritePrompt(skillPath, SKILL_TEMPLATE, options.force);
   const gitignoreResult = await ensureGitignoreEntry(gitignorePath, ".kyoso/");
-  return [
-    `kyoso.config.ts: ${configResult}`,
+  const lines = [
+    `kyoso.toml: ${configResult}`,
     `.agents/skills/kyoso-review/SKILL.md: ${skillResult}`,
     `.gitignore .kyoso/: ${gitignoreResult}`
-  ].join(`
+  ];
+  if (await exists3(tsConfigPath)) {
+    lines.push("kyoso.config.ts: found deprecated config; kyoso.toml takes precedence");
+  }
+  return lines.join(`
 `);
 }
 async function ensureGitignoreEntry(path, entry) {
   let content = "";
   try {
-    content = await readFile5(path, "utf8");
+    content = await readFile6(path, "utf8");
   } catch (error51) {
     if (!isMissingPathError3(error51))
       throw error51;
@@ -185230,13 +186570,19 @@ async function ensureGitignoreEntry(path, entry) {
 function isMissingPathError3(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
 }
-var CONFIG_TEMPLATE = `import { defineConfig } from "@kyo-so/cli";
+async function exists3(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var CONFIG_TEMPLATE = `# Kyoso project config.
+# Project TOML is declarative and does not require trust approval.
 
-export default defineConfig({
-  network: {
-    defaultMode: "model_only",
-  },
-});
+[network]
+defaultMode = "model_only"
 `;
 var SKILL_TEMPLATE = `---
 name: kyoso-review
@@ -185424,10 +186770,10 @@ var require_code$1 = /* @__PURE__ */ __commonJSMin((exports) => {
   function interpolate(x) {
     return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
   }
-  function stringify(x) {
+  function stringify2(x) {
     return new _Code(safeStringify(x));
   }
-  exports.stringify = stringify;
+  exports.stringify = stringify2;
   function safeStringify(x) {
     return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
   }
@@ -188133,7 +189479,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin((exports) => {
     const schOrFunc = root.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve4.call(this, root, ref);
+    let _sch = resolve5.call(this, root, ref);
     if (_sch === undefined) {
       const schema = (_a3 = root.localRefs) === null || _a3 === undefined ? undefined : _a3[ref];
       const { schemaId } = this.opts;
@@ -188164,7 +189510,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve4(root, ref) {
+  function resolve5(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -188665,22 +190011,22 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin((exports, module) => {
   const { SCHEMES, getSchemeHandler } = require_schemes();
   function normalize(uri, options) {
     if (typeof uri === "string")
-      uri = serialize(parse5(uri, options), options);
+      uri = serialize(parse6(uri, options), options);
     else if (typeof uri === "object")
-      uri = parse5(serialize(uri, options), options);
+      uri = parse6(serialize(uri, options), options);
     return uri;
   }
-  function resolve4(baseURI, relativeURI, options) {
+  function resolve5(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const resolved = resolveComponent(parse5(baseURI, schemelessOptions), parse5(relativeURI, schemelessOptions), schemelessOptions, true);
+    const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
   function resolveComponent(base, relative, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
-      base = parse5(serialize(base, options), options);
-      relative = parse5(serialize(relative, options), options);
+      base = parse6(serialize(base, options), options);
+      relative = parse6(serialize(relative, options), options);
     }
     options = options || {};
     if (!options.tolerant && relative.scheme) {
@@ -188730,7 +190076,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function equal(uriA, uriB, options) {
     if (typeof uriA === "string") {
       uriA = unescape(uriA);
-      uriA = serialize(normalizeComponentEncoding(parse5(uriA, options), true), {
+      uriA = serialize(normalizeComponentEncoding(parse6(uriA, options), true), {
         ...options,
         skipEscape: true
       });
@@ -188741,7 +190087,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin((exports, module) => {
       });
     if (typeof uriB === "string") {
       uriB = unescape(uriB);
-      uriB = serialize(normalizeComponentEncoding(parse5(uriB, options), true), {
+      uriB = serialize(normalizeComponentEncoding(parse6(uriB, options), true), {
         ...options,
         skipEscape: true
       });
@@ -188806,7 +190152,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin((exports, module) => {
     return uriTokens.join("");
   }
   const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-  function parse5(uri, opts) {
+  function parse6(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
       scheme: undefined,
@@ -188881,11 +190227,11 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin((exports, module) => {
   const fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve4,
+    resolve: resolve5,
     resolveComponent,
     equal,
     serialize,
-    parse: parse5
+    parse: parse6
   };
   module.exports = fastUri;
   module.exports.default = fastUri;
@@ -196023,14 +197369,14 @@ function inputRequiredRoundsExceededMessage(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof SdkError ? signal.reason : new SdkError(SdkErrorCode.RequestTimeout, String(signal.reason)));
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve4();
+      resolve5();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
@@ -196792,7 +198138,7 @@ var Protocol = class {
     const flowStartedAt = Date.now();
     let onAbort;
     let cleanupMessageId;
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const earlyReject = (error51) => {
         reject(error51);
       };
@@ -196868,7 +198214,7 @@ var Protocol = class {
           return reject(decoded.error);
         if (decoded.kind === "input_required") {
           if (options?.allowInputRequired === true)
-            return resolve4(manualInputRequiredValue(decoded));
+            return resolve5(manualInputRequiredValue(decoded));
           const flow = {
             codec: codec2,
             request,
@@ -196880,12 +198226,12 @@ var Protocol = class {
               params
             }, resultSchema, legOptions)
           };
-          return resolve4(this._resolveNonCompleteResult(decoded, flow));
+          return resolve5(this._resolveNonCompleteResult(decoded, flow));
         }
         const result = decoded.result;
         validateStandardSchema(resultSchema, result).then((parseResult) => {
           if (parseResult.success)
-            resolve4(parseResult.data);
+            resolve5(parseResult.data);
           else
             reject(new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${request.method}: ${parseResult.error}`));
         }, reject);
@@ -198429,7 +199775,7 @@ var StdioServerTransport = class {
   send(message) {
     if (this._closed)
       return Promise.reject(/* @__PURE__ */ new Error("StdioServerTransport is closed"));
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const json2 = serializeMessage(message);
       let settled = false;
       const onError = (error51) => {
@@ -198446,7 +199792,7 @@ var StdioServerTransport = class {
         settled = true;
         this._stdout.off("error", onError);
         this._stdout.off("drain", onDrain);
-        resolve4();
+        resolve5();
       };
       this._stdout.once("error", onError);
       if (this._stdout.write(json2)) {
@@ -198454,7 +199800,7 @@ var StdioServerTransport = class {
           return;
         settled = true;
         this._stdout.off("error", onError);
-        resolve4();
+        resolve5();
       } else if (!settled)
         this._stdout.once("drain", onDrain);
     });
@@ -198462,12 +199808,12 @@ var StdioServerTransport = class {
 };
 
 // src/core/runReview.ts
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 
 // src/acp/AcpAgentProcess.ts
 import { spawn } from "node:child_process";
-import { readFile as readFile6, realpath } from "node:fs/promises";
-import { isAbsolute, relative, resolve as resolve4 } from "node:path";
+import { readFile as readFile7, realpath } from "node:fs/promises";
+import { isAbsolute, relative, resolve as resolve5 } from "node:path";
 import { Readable, Writable } from "node:stream";
 
 // node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -200341,14 +201687,14 @@ function ndJsonStream(output2, input2) {
 }
 // node_modules/@agentclientprotocol/sdk/dist/jsonrpc.js
 var CANCEL_REQUEST_METHOD = "$/cancel_request";
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 function cancelRequestId(params) {
-  if (!isRecord5(params) || !isJsonRpcId(params["requestId"])) {
+  if (!isRecord6(params) || !isJsonRpcId(params["requestId"])) {
     return;
   }
   return params["requestId"];
@@ -200572,12 +201918,12 @@ class Connection {
     }
     const id = this.nextRequestId++;
     let cancel = () => {};
-    const responsePromise = new Promise((resolve4, reject) => {
+    const responsePromise = new Promise((resolve5, reject) => {
       const pendingResponse = {
         resolve: (response) => {
           try {
             const value = mapResponse ? mapResponse(response) : response;
-            resolve4(value);
+            resolve5(value);
           } catch (error51) {
             reject(error51);
           }
@@ -200642,8 +201988,8 @@ class Connection {
   initialize(stream, handlers) {
     this.stream = stream;
     this.staticHandlers = handlers;
-    this.closedPromise = new Promise((resolve4) => {
-      this.abortController.signal.addEventListener("abort", () => resolve4());
+    this.closedPromise = new Promise((resolve5) => {
+      this.abortController.signal.addEventListener("abort", () => resolve5());
     });
     this.receive();
   }
@@ -200850,25 +202196,25 @@ class ConnectionBuilder {
       describe: () => this.connectionName ?? "onReceiveMessage"
     });
   }
-  onReceiveRequest(method, parse5, handler) {
+  onReceiveRequest(method, parse6, handler) {
     return this.withHandler({
       handleMessage: async (message, cx) => {
         if (message.kind !== "request" || message.method !== method) {
           return Handled.no(message);
         }
-        const request = parse5(message.params);
+        const request = parse6(message.params);
         return await handler(request, message.responder, cx) ?? Handled.yes();
       },
       describe: () => `${this.connectionName ?? "request"}:${method}`
     });
   }
-  onReceiveNotification(method, parse5, handler) {
+  onReceiveNotification(method, parse6, handler) {
     return this.withHandler({
       handleMessage: async (message, cx) => {
         if (message.kind !== "notification" || message.method !== method) {
           return Handled.no(message);
         }
-        const notification = parse5(message.params);
+        const notification = parse6(message.params);
         return await handler(notification, cx) ?? Handled.yes();
       },
       describe: () => `${this.connectionName ?? "notification"}:${method}`
@@ -201218,8 +202564,8 @@ class AsyncQueue {
     if (this.failed) {
       return Promise.reject(this.failure);
     }
-    return new Promise((resolve4, reject) => {
-      this.waiters.push({ resolve: resolve4, reject });
+    return new Promise((resolve5, reject) => {
+      this.waiters.push({ resolve: resolve5, reject });
     });
   }
 }
@@ -201921,7 +203267,7 @@ function isSeverity(value) {
   return typeof value === "string" && severities.includes(value);
 }
 function normalizeCisaSecureByDesign(value) {
-  if (!isRecord6(value))
+  if (!isRecord7(value))
     return;
   const normalized = {};
   const customerSecurityOutcomes = normalizeGateStatus(value.customerSecurityOutcomes);
@@ -201962,7 +203308,7 @@ function normalizeFindingFiles(value) {
   if (!Array.isArray(value))
     return;
   const files = value.flatMap((item) => {
-    if (!isRecord6(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
+    if (!isRecord7(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
       return [];
     }
     const file2 = {
@@ -201981,7 +203327,7 @@ function normalizeFindingFiles(value) {
 function normalizeLineNumber(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -202169,7 +203515,7 @@ async function readWorkspaceFile(workspaceDir, requestedPath, line, limit) {
     const readablePath = await resolveReadableFile(workspaceRoot, absolute);
     if (!readablePath)
       continue;
-    content = await readFile6(readablePath, "utf8").catch(() => {
+    content = await readFile7(readablePath, "utf8").catch(() => {
       return;
     });
     if (content !== undefined)
@@ -202196,13 +203542,13 @@ async function resolveReadableFile(workspaceRoot, absolute) {
   return realPath;
 }
 function resolveReadablePaths(workspaceRoot, requestedPath) {
-  const primary = resolve4(workspaceRoot, requestedPath);
+  const primary = resolve5(workspaceRoot, requestedPath);
   assertWithinWorkspace(workspaceRoot, primary);
   const relativePath = relative(workspaceRoot, primary).replaceAll("\\", "/");
   if (relativePath.startsWith("context/") || relativePath.startsWith("repo/")) {
     return [primary];
   }
-  const repoPath = resolve4(workspaceRoot, "repo", relativePath);
+  const repoPath = resolve5(workspaceRoot, "repo", relativePath);
   assertWithinWorkspace(workspaceRoot, repoPath);
   return isAbsolute(requestedPath) ? [primary, repoPath] : [repoPath, primary];
 }
@@ -202922,7 +204268,7 @@ function normalizeTitle(value) {
 
 // src/audit/trace.ts
 import { mkdir as mkdir4, appendFile } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join4 } from "node:path";
+import { dirname as dirname5, isAbsolute as isAbsolute2, join as join5 } from "node:path";
 
 // src/context/pathPolicy.ts
 import { normalize, sep } from "node:path";
@@ -203016,7 +204362,7 @@ function createTraceWriter(options) {
   }
   const date5 = new Date().toISOString().slice(0, 10);
   const directory = validateAuditDirectory(options.directory, warnings);
-  const tracePath = join4(options.cwd, directory, date5, `${options.traceId}.jsonl`);
+  const tracePath = join5(options.cwd, directory, date5, `${options.traceId}.jsonl`);
   return {
     tracePath,
     warnings,
@@ -203197,6 +204543,10 @@ function renderMarkdownResult(tool, result, options = {}) {
   lines.push(...result.testsToAdd.length > 0 ? result.testsToAdd.map((test) => `- ${test}`) : ["- None."]);
   lines.push("", "## Residual Risks", "");
   lines.push(...result.residualRisks.length > 0 ? result.residualRisks.map((risk) => `- ${risk}`) : ["- None."]);
+  if (result.audit.warnings && result.audit.warnings.length > 0) {
+    lines.push("", "## Warnings", "");
+    lines.push(...result.audit.warnings.map((warning) => `- ${escapeMarkdownText(warning)}`));
+  }
   if (result.crossModelAnalysis) {
     lines.push("", "## Cross-Model Analysis", "");
     if (result.reviewMode === "single_agent") {
@@ -203261,6 +204611,9 @@ function formatVerification(finding) {
 function formatList(items) {
   return items.length > 0 ? items.map((item) => `- ${item}`) : ["- None."];
 }
+function escapeMarkdownText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replace(/[\r\n]+/g, " ").replace(/([\\`*_{}\[\]()#+!|])/g, "\\$1");
+}
 
 // src/security/recursionGuard.ts
 function assertNotChildAgent(env = process.env) {
@@ -203454,12 +204807,12 @@ function decide(input2) {
 
 // src/workspace/createSnapshot.ts
 import { chmod, mkdir as mkdir5, mkdtemp, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname6, join as join5 } from "node:path";
+import { dirname as dirname6, join as join6 } from "node:path";
 import { tmpdir } from "node:os";
 async function createSnapshot(traceId, tool, request, options = {}) {
-  const root = await mkdtemp(join5(tmpdir(), `kyoso-${traceId}-`));
-  const repoDir = join5(root, "repo");
-  const contextDir = join5(root, "context");
+  const root = await mkdtemp(join6(tmpdir(), `kyoso-${traceId}-`));
+  const repoDir = join6(root, "repo");
+  const contextDir = join6(root, "context");
   await mkdir5(repoDir, { recursive: true });
   await mkdir5(contextDir, { recursive: true });
   let fileCount = 0;
@@ -203469,7 +204822,7 @@ async function createSnapshot(traceId, tool, request, options = {}) {
       continue;
     if (!isAllowedPath(relative2, options.allowPatterns ?? []))
       continue;
-    const dest = join5(repoDir, relative2);
+    const dest = join6(repoDir, relative2);
     await mkdir5(dirname6(dest), { recursive: true });
     await writeFile5(dest, file2.content, "utf8");
     await chmod(dest, 292).catch(() => {
@@ -203477,16 +204830,16 @@ async function createSnapshot(traceId, tool, request, options = {}) {
     });
     fileCount += 1;
   }
-  await writeFile5(join5(contextDir, "request.json"), JSON.stringify(stripContents(request), null, 2), "utf8");
-  await writeFile5(join5(contextDir, "selected_files_manifest.json"), JSON.stringify(buildSelectedFilesManifest(request), null, 2), "utf8");
-  await writeFile5(join5(contextDir, "instructions.codex.md"), buildAgentPrompt(tool, request, "codex", options.agentRoles?.codex ?? "implementation_reviewer"), "utf8");
-  await writeFile5(join5(contextDir, "instructions.claude.md"), buildAgentPrompt(tool, request, "claude", options.agentRoles?.claude ?? "architecture_security_reviewer"), "utf8");
+  await writeFile5(join6(contextDir, "request.json"), JSON.stringify(stripContents(request), null, 2), "utf8");
+  await writeFile5(join6(contextDir, "selected_files_manifest.json"), JSON.stringify(buildSelectedFilesManifest(request), null, 2), "utf8");
+  await writeFile5(join6(contextDir, "instructions.codex.md"), buildAgentPrompt(tool, request, "codex", options.agentRoles?.codex ?? "implementation_reviewer"), "utf8");
+  await writeFile5(join6(contextDir, "instructions.claude.md"), buildAgentPrompt(tool, request, "claude", options.agentRoles?.claude ?? "architecture_security_reviewer"), "utf8");
   if (request.repoSummary)
-    await writeFile5(join5(contextDir, "repo_summary.md"), request.repoSummary, "utf8");
+    await writeFile5(join6(contextDir, "repo_summary.md"), request.repoSummary, "utf8");
   if (request.currentPlan)
-    await writeFile5(join5(contextDir, "current_plan.md"), request.currentPlan, "utf8");
+    await writeFile5(join6(contextDir, "current_plan.md"), request.currentPlan, "utf8");
   if (request.diff?.unifiedDiff)
-    await writeFile5(join5(contextDir, "diff.patch"), request.diff.unifiedDiff, "utf8");
+    await writeFile5(join6(contextDir, "diff.patch"), request.diff.unifiedDiff, "utf8");
   return { root, repoDir, contextDir, fileCount };
 }
 function stripContents(request) {
@@ -203576,7 +204929,7 @@ function parseVerificationVerdicts(rawText) {
     if (!Array.isArray(parsed.verdicts))
       return;
     return parsed.verdicts.flatMap((item) => {
-      if (!isRecord7(item))
+      if (!isRecord8(item))
         return [];
       if (typeof item.findingId !== "string")
         return [];
@@ -203654,7 +205007,7 @@ function verificationNote(reasoning) {
 function isVerdict(value) {
   return value === "confirmed" || value === "refuted" || value === "uncertain";
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -203707,14 +205060,17 @@ async function runReview(tool, request, options = {}) {
     config: options.config,
     configHash: options.configHash,
     configTrustStatus: "trusted",
+    sources: [],
     warnings: []
   } : await loadConfig({
     cwd,
     configPath: options.configPath,
     ignoreConfig: options.ignoreConfig,
     trustConfig: options.trustConfig,
+    allowUnknownConfig: options.allowUnknownConfig,
     promptForTrust: options.promptForTrust,
     trustStorePath: options.trustStorePath,
+    env: options.env,
     trustPrompt: options.trustPrompt
   });
   const trace = createTraceWriter({
@@ -203737,6 +205093,7 @@ async function runReview(tool, request, options = {}) {
       traceId,
       configHash: loaded.configHash,
       configPath: loaded.configPath,
+      configSources: loaded.sources,
       configTrustStatus: loaded.configTrustStatus,
       timestamp: new Date().toISOString()
     });
@@ -204285,7 +205642,7 @@ function mergeDenyPatterns(configDeny, requestDeny) {
 function assertTrustedWorkspaceRoot(requestRoot, configRoot, cwd) {
   if (!requestRoot)
     return;
-  if (resolve5(cwd, requestRoot) !== resolve5(cwd, configRoot)) {
+  if (resolve6(cwd, requestRoot) !== resolve6(cwd, configRoot)) {
     throw new KyosoRequestError("workspace.root is not trusted by config", "UNTRUSTED_WORKSPACE_ROOT");
   }
 }
@@ -204368,6 +205725,7 @@ async function main() {
   const configPath = stringFlag(parsed.flags, "config");
   const ignoreConfig = booleanFlag(parsed.flags, "ignore-config");
   const trustConfig2 = booleanFlag(parsed.flags, "trust-config");
+  const allowUnknownConfig = booleanFlag(parsed.flags, "allow-unknown-config");
   if (parsed.command === "mcp") {
     const network = networkFlag(parsed.flags);
     await startMcpServer({
@@ -204375,6 +205733,7 @@ async function main() {
       configPath,
       ignoreConfig,
       trustConfig: trustConfig2,
+      allowUnknownConfig,
       mcpNetworkMode: network
     });
     return;
@@ -204385,6 +205744,7 @@ async function main() {
       configPath,
       ignoreConfig,
       trustConfig: trustConfig2,
+      allowUnknownConfig,
       promptForTrust: canPromptForConfigTrust()
     }));
     return;
@@ -204412,6 +205772,7 @@ async function main() {
       configPath,
       ignoreConfig,
       trustConfig: trustConfig2,
+      allowUnknownConfig,
       promptForTrust: canPromptForConfigTrust()
     });
     console.log(booleanFlag(parsed.flags, "json") ? JSON.stringify(result, null, 2) : result.summaryMarkdown);
@@ -204494,12 +205855,12 @@ function canPromptForConfigTrust() {
 var HELP = `Kyoso
 
 Usage:
-  kyoso mcp [--config kyoso.config.ts] [--ignore-config] [--trust-config] [--network model_only|unrestricted]
+  kyoso mcp [--config kyoso.toml|kyoso.config.ts] [--ignore-config] [--trust-config] [--allow-unknown-config] [--network model_only|unrestricted]
   kyoso setup [codex|claude-code] [--write] [--runner npx|bunx] [--command <command>] [--global]
-  kyoso plan --goal <text> [--plan <path-or-text>] [--file <path>] [--json] [--trust-config]
-  kyoso security --goal <text> [--diff <path>] [--file <path>] [--allow-secret-redaction] [--trust-config]
-  kyoso diff --base main --head HEAD [--json] [--trust-config]
-  kyoso doctor [--trust-config]
+  kyoso plan --goal <text> [--plan <path-or-text>] [--file <path>] [--json] [--trust-config] [--allow-unknown-config]
+  kyoso security --goal <text> [--diff <path>] [--file <path>] [--allow-secret-redaction] [--trust-config] [--allow-unknown-config]
+  kyoso diff --base main --head HEAD [--json] [--trust-config] [--allow-unknown-config]
+  kyoso doctor [--trust-config] [--allow-unknown-config]
   kyoso init [--force]
 `;
 main().catch((error51) => {