@martinffx/atelier 3.6.0 → 3.8.0

package/dist/atelier.js

@@ -4559,7 +4559,7 @@ var require_sbcs = __commonJS(function(exports2) {
     return mod && mod.__esModule ? mod : { default: mod };
   };
   Object.defineProperty(exports2, "__esModule", { value: true });
-  exports2.KOI8_R = exports2.windows_1256 = exports2.windows_1251 = exports2.ISO_8859_9 = exports2.ISO_8859_8 = exports2.ISO_8859_7 = exports2.ISO_8859_6 = exports2.ISO_8859_5 = exports2.ISO_8859_2 = exports2.ISO_8859_1 = undefined;
+  exports2.KOI8_R = exports2.windows_874 = exports2.windows_1258 = exports2.windows_1257 = exports2.windows_1256 = exports2.windows_1251 = exports2.ISO_8859_9 = exports2.ISO_8859_8 = exports2.ISO_8859_7 = exports2.ISO_8859_6 = exports2.ISO_8859_5 = exports2.ISO_8859_2 = exports2.ISO_8859_1 = undefined;
   var match_1 = __importDefault(require_match());
   var N_GRAM_MASK = 16777215;
 
@@ -8575,6 +8575,446 @@ var require_sbcs = __commonJS(function(exports2) {
   }
   exports2.windows_1256 = windows_1256;
 
+  class windows_1257 extends sbcs {
+    match(det) {
+      return det.inputBytes.some((byte) => byte >= 128) ? super.match(det) : null;
+    }
+    byteMap() {
+      const byteMap = new Array(256).fill(32);
+      byteMap[39] = 0;
+      for (let i = 65;i <= 90; i++)
+        byteMap[i] = i + 32;
+      for (let i = 97;i <= 122; i++)
+        byteMap[i] = i;
+      byteMap[142] = 142;
+      byteMap[168] = byteMap[184] = 184;
+      byteMap[170] = byteMap[186] = 186;
+      byteMap[175] = byteMap[191] = 191;
+      byteMap[181] = 181;
+      for (let i = 192;i <= 214; i++)
+        byteMap[i] = i + 32;
+      for (let i = 216;i <= 222; i++)
+        byteMap[i] = i + 32;
+      byteMap[223] = 223;
+      for (let i = 224;i <= 246; i++)
+        byteMap[i] = i;
+      for (let i = 248;i <= 254; i++)
+        byteMap[i] = i;
+      return byteMap;
+    }
+    ngrams() {
+      return [
+        new NGramsPlusLang("et", [
+          2122090,
+          2122098,
+          2123109,
+          2124135,
+          2124385,
+          2124641,
+          2124645,
+          2124649,
+          2124655,
+          2124661,
+          2124897,
+          2125417,
+          2125678,
+          2126441,
+          2126693,
+          2126949,
+          6365281,
+          6365290,
+          6365291,
+          6365292,
+          6382112,
+          6382624,
+          6384499,
+          6386549,
+          6386785,
+          6387297,
+          6561908,
+          6578464,
+          6583667,
+          6627435,
+          6627443,
+          6645100,
+          6645107,
+          6646816,
+          6646885,
+          6646900,
+          6648608,
+          6648692,
+          6889579,
+          6906912,
+          6910570,
+          6910752,
+          6971680,
+          7037299,
+          7038309,
+          7039346,
+          7040879,
+          7041893,
+          7041908,
+          7104875,
+          7107616,
+          7544929,
+          7544939,
+          7562528,
+          7562604,
+          7566437,
+          7566441,
+          7566708,
+          7627115,
+          7627124,
+          7629088,
+          7697184,
+          7697253,
+          7697505
+        ]),
+        new NGramsPlusLang("lv", [
+          2122098,
+          2122601,
+          2122849,
+          2124146,
+          2124154,
+          2124897,
+          2125282,
+          2125921,
+          2125938,
+          2126433,
+          2126689,
+          2126699,
+          2126949,
+          2127214,
+          2127457,
+          6365289,
+          6365301,
+          6365302,
+          6382185,
+          6383904,
+          6384499,
+          6384751,
+          6385778,
+          6386293,
+          6386464,
+          6386806,
+          6449509,
+          6452512,
+          6515052,
+          6515060,
+          6578464,
+          6578546,
+          6583584,
+          6584864,
+          6644850,
+          6646123,
+          6646643,
+          6647393,
+          6648608,
+          6680693,
+          6889577,
+          6907236,
+          6907376,
+          6908642,
+          6909046,
+          7041908,
+          7102836,
+          7106404,
+          7233824,
+          7300193,
+          7496043,
+          7501166,
+          7544947,
+          7544949,
+          7544950,
+          7566453,
+          7566574,
+          7632160,
+          7632489,
+          7676022,
+          7695904,
+          7697184,
+          7758188,
+          14840608
+        ]),
+        new NGramsPlusLang("lt", [
+          2122089,
+          2122341,
+          2124146,
+          2124641,
+          2124905,
+          2125167,
+          2126433,
+          2126689,
+          2126699,
+          2126709,
+          2126945,
+          2126949,
+          2126965,
+          2127457,
+          2127465,
+          6365300,
+          6365424,
+          6383904,
+          6383988,
+          6384112,
+          6384738,
+          6384993,
+          6385268,
+          6386274,
+          6386292,
+          6386976,
+          6387050,
+          6418553,
+          6447392,
+          6448489,
+          6448494,
+          6647401,
+          6648949,
+          6889569,
+          6889577,
+          6889579,
+          6889581,
+          6906217,
+          6907246,
+          6907252,
+          6909543,
+          6910496,
+          6910752,
+          6942827,
+          6971757,
+          6972704,
+          7037289,
+          7037292,
+          7103073,
+          7104869,
+          7170419,
+          7171947,
+          7269152,
+          7301733,
+          7302009,
+          7303968,
+          7496176,
+          7544937,
+          7544939,
+          7544950,
+          7564129,
+          7629088,
+          7632246,
+          7957356
+        ])
+      ];
+    }
+    name() {
+      return "windows-1257";
+    }
+  }
+  exports2.windows_1257 = windows_1257;
+
+  class windows_1258 extends sbcs {
+    match(det) {
+      return det.inputBytes.some((byte) => byte >= 128) ? super.match(det) : null;
+    }
+    byteMap() {
+      const byteMap = new Array(256).fill(32);
+      byteMap[39] = 0;
+      for (let i = 65;i <= 90; i++)
+        byteMap[i] = i + 32;
+      for (let i = 97;i <= 122; i++)
+        byteMap[i] = i;
+      byteMap[131] = 131;
+      byteMap[136] = 136;
+      byteMap[140] = byteMap[156] = 156;
+      byteMap[159] = 255;
+      byteMap[170] = 170;
+      byteMap[181] = 181;
+      byteMap[186] = 186;
+      for (let i = 192;i <= 203; i++)
+        byteMap[i] = i + 32;
+      byteMap[204] = 204;
+      for (let i = 205;i <= 209; i++)
+        byteMap[i] = i + 32;
+      byteMap[210] = 210;
+      for (let i = 211;i <= 214; i++)
+        byteMap[i] = i + 32;
+      for (let i = 216;i <= 221; i++)
+        byteMap[i] = i + 32;
+      byteMap[222] = 222;
+      byteMap[223] = 223;
+      for (let i = 224;i <= 246; i++)
+        byteMap[i] = i;
+      for (let i = 248;i <= 253; i++)
+        byteMap[i] = i;
+      byteMap[255] = 255;
+      return byteMap;
+    }
+    ngrams() {
+      return [
+        2122600,
+        2122721,
+        2123625,
+        2123887,
+        2125415,
+        2125928,
+        2126952,
+        2126953,
+        2126962,
+        2127465,
+        2127584,
+        6419060,
+        6496355,
+        6496374,
+        6514720,
+        6514925,
+        6545763,
+        6758504,
+        6758510,
+        6758516,
+        6758518,
+        6812782,
+        6815198,
+        6815221,
+        6824052,
+        6844402,
+        6876526,
+        6889582,
+        6889588,
+        6941394,
+        6941420,
+        6941426,
+        7217251,
+        7217262,
+        7217268,
+        7235360,
+        7235572,
+        7235581,
+        7235616,
+        7302759,
+        7336547,
+        7610483,
+        7629053,
+        7629290,
+        7631471,
+        7676020,
+        7760362,
+        7790624,
+        13396256,
+        13397607,
+        14557288,
+        14771048,
+        15395950,
+        15397492,
+        15494759,
+        15496224,
+        15560296,
+        15885088,
+        15886624,
+        15887904,
+        15889440,
+        16018976,
+        16108649,
+        16643532
+      ];
+    }
+    name() {
+      return "windows-1258";
+    }
+    language() {
+      return "vi";
+    }
+  }
+  exports2.windows_1258 = windows_1258;
+
+  class windows_874 extends sbcs {
+    byteMap() {
+      const byteMap = new Array(256).fill(32);
+      byteMap[39] = 0;
+      for (let i = 65;i <= 90; i++)
+        byteMap[i] = i + 32;
+      for (let i = 97;i <= 122; i++)
+        byteMap[i] = i;
+      for (let i = 161;i <= 218; i++)
+        byteMap[i] = i;
+      for (let i = 223;i <= 251; i++)
+        byteMap[i] = i;
+      return byteMap;
+    }
+    ngrams() {
+      return [
+        2138578,
+        2138856,
+        2146514,
+        2148291,
+        2154949,
+        10604985,
+        10605251,
+        10669479,
+        10671554,
+        10799058,
+        11064263,
+        11195847,
+        11200960,
+        11200995,
+        11910083,
+        12042976,
+        12042979,
+        12047848,
+        12132544,
+        12165586,
+        12173522,
+        12305360,
+        12314553,
+        12636873,
+        12828960,
+        12829619,
+        12829633,
+        12832936,
+        12832994,
+        12837026,
+        13091779,
+        13095353,
+        13095617,
+        13096117,
+        13226679,
+        13226724,
+        13293544,
+        13477063,
+        13674707,
+        13689538,
+        13744416,
+        13805473,
+        13812171,
+        13812452,
+        13812512,
+        13812704,
+        13814226,
+        13821111,
+        13879249,
+        13940155,
+        14009017,
+        14010324,
+        14149837,
+        14721749,
+        14728167,
+        14796240,
+        14860964,
+        14920425,
+        14924193,
+        14989250,
+        15258279,
+        15262634,
+        15319250,
+        15328185
+      ];
+    }
+    name() {
+      return "windows-874";
+    }
+    language() {
+      return "th";
+    }
+  }
+  exports2.windows_874 = windows_874;
+
   class KOI8_R extends sbcs {
     byteMap() {
       return [
@@ -9130,6 +9570,9 @@ var require_lib2 = __commonJS(function(exports2) {
     new sbcs.ISO_8859_9,
     new sbcs.windows_1251,
     new sbcs.windows_1256,
+    new sbcs.windows_1257,
+    new sbcs.windows_1258,
+    new sbcs.windows_874,
     new sbcs.KOI8_R,
     new ascii_1.default
   ];
@@ -9547,7 +9990,7 @@ var require_utf32 = __commonJS(function(exports2) {
   }
   Utf32Encoder.prototype.write = function(str2) {
     var src = Buffer2.from(str2, "ucs2");
-    var dst = Buffer2.alloc(src.length * 2);
+    var dst = Buffer2.alloc(src.length * 2 + 4);
     var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;
     var offset = 0;
     for (var i = 0;i < src.length; i += 2) {
@@ -9614,9 +10057,9 @@ var require_utf32 = __commonJS(function(exports2) {
       }
       if (overflow.length === 4) {
         if (isLE) {
-          codepoint = overflow[i] | overflow[i + 1] << 8 | overflow[i + 2] << 16 | overflow[i + 3] << 24;
+          codepoint = overflow[0] | overflow[1] << 8 | overflow[2] << 16 | overflow[3] << 24;
         } else {
-          codepoint = overflow[i + 3] | overflow[i + 2] << 8 | overflow[i + 1] << 16 | overflow[i] << 24;
+          codepoint = overflow[3] | overflow[2] << 8 | overflow[1] << 16 | overflow[0] << 24;
         }
         overflow.length = 0;
         offset = _writeCodepoint(dst, offset, codepoint, badChar);
@@ -9651,7 +10094,11 @@ var require_utf32 = __commonJS(function(exports2) {
     return offset;
   }
   Utf32Decoder.prototype.end = function() {
+    if (this.overflow.length === 0) {
+      return;
+    }
     this.overflow.length = 0;
+    return String.fromCharCode(this.badChar);
   };
   exports2.utf32 = Utf32AutoCodec;
   exports2.ucs4 = "utf32";
@@ -10268,6 +10715,8 @@ var require_sbcs_data = __commonJS(function(exports2, module2) {
     elot928: "iso88597",
     hebrew: "iso88598",
     hebrew8: "iso88598",
+    iso88598i: "iso88598",
+    iso88598e: "iso88598",
     turkish: "iso88599",
     turkish8: "iso88599",
     thai: "iso885911",
@@ -23025,7 +23474,7 @@ var require_omap = __commonJS(function(exports2, module2) {
   function resolveYamlOmap(data) {
     if (data === null)
       return true;
-    var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data;
+    var objectKeys = {}, index, length, pair, pairKey, pairHasKey, object = data;
     for (index = 0, length = object.length;index < length; index += 1) {
       pair = object[index];
       pairHasKey = false;
@@ -23041,10 +23490,9 @@ var require_omap = __commonJS(function(exports2, module2) {
       }
       if (!pairHasKey)
         return false;
-      if (objectKeys.indexOf(pairKey) === -1)
-        objectKeys.push(pairKey);
-      else
+      if (_hasOwnProperty.call(objectKeys, pairKey))
         return false;
+      Object.defineProperty(objectKeys, pairKey, { value: true });
     }
     return true;
   }
@@ -23387,6 +23835,7 @@ var require_loader = __commonJS(function(exports2, module2) {
     this.legacy = options2["legacy"] || false;
     this.json = options2["json"] || false;
     this.listener = options2["listener"] || null;
+    this.maxTotalMergeKeys = typeof options2["maxTotalMergeKeys"] === "number" ? options2["maxTotalMergeKeys"] : 1e4;
     this.implicitTypes = this.schema.compiledImplicit;
     this.typeMap = this.schema.compiledTypeMap;
     this.length = input.length;
@@ -23394,6 +23843,7 @@ var require_loader = __commonJS(function(exports2, module2) {
     this.line = 0;
     this.lineStart = 0;
     this.lineIndent = 0;
+    this.totalMergeKeys = 0;
     this.documents = [];
   }
   function generateError(state, message) {
@@ -23467,14 +23917,22 @@ var require_loader = __commonJS(function(exports2, module2) {
       state.result += _result;
     }
   }
+  function chargeMergeWork(state) {
+    state.totalMergeKeys += 1;
+    if (state.maxTotalMergeKeys !== -1 && state.totalMergeKeys > state.maxTotalMergeKeys) {
+      throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
+    }
+  }
   function mergeMappings(state, destination, source, overridableKeys) {
     var sourceKeys, key, index, quantity;
     if (!common.isObject(source)) {
       throwError(state, "cannot merge mappings; the provided source object is unacceptable");
     }
+    chargeMergeWork(state);
     sourceKeys = Object.keys(source);
     for (index = 0, quantity = sourceKeys.length;index < quantity; index += 1) {
       key = sourceKeys[index];
+      chargeMergeWork(state);
       if (!_hasOwnProperty.call(destination, key)) {
         setProperty(destination, key, source[key]);
         overridableKeys[key] = true;
@@ -23503,6 +23961,9 @@ var require_loader = __commonJS(function(exports2, module2) {
     }
     if (keyTag === "tag:yaml.org,2002:merge") {
       if (Array.isArray(valueNode)) {
+        if (valueNode.length > 100) {
+          throwError(state, "abnormal merge sequence size");
+        }
         for (index = 0, quantity = valueNode.length;index < quantity; index += 1) {
           mergeMappings(state, _result, valueNode[index], overridableKeys);
         }
@@ -31854,7 +32315,7 @@ var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
 // src/constants.ts
-var Harness = ["claude", "opencode", "codex", "cursor"];
+var Harness = ["claude", "opencode", "codex"];
 var AGENT_NAMES = ["sentinel", "oracle", "architect", "keymaker"];
 var LEGACY_AGENT_NAME = "recon";
 
@@ -31941,6 +32402,131 @@ function listAdapters() {
   return [...adapters.values()];
 }
 
+// src/utils/thinking.ts
+var THINKING_LEVELS = ["default", "off", "on", "low", "medium", "high", "xhigh", "max"];
+function thinkingChoices(harness, model, session = false) {
+  const id = modelId(model);
+  if (/gpt-6(\.1)?-(astra|sol|luna|terra)$/.test(id)) {
+    return ["default", .../astra$|6\.1-sol$/.test(id) ? [] : ["off"], "low", "medium", "high", "xhigh", "max"];
+  }
+  if (/^(opus|opusplan|sonnet|haiku|fable|best)$/.test(id) || /claude-(opus-5[-.]5|fable-5[-.]1|sonnet-5[-.]5|haiku-5[-.]5)$/.test(id)) {
+    return ["default", "low", "medium", "high", "xhigh", ...harness === "claude" && session ? [] : ["max"]];
+  }
+  if (harness === "opencode") {
+    if (/^(glm-5\.3(-flash)?|kimi-k3(\.1-pro)?|deepseek-v4(\.1-flash(-1017)?|-pro))$/.test(id))
+      return ["default", "low", "high", "max"];
+    if (/^(mimo-v2\.6-(pro|flash)(-free)?|minimax-m3(-free)?)$/.test(id))
+      return ["default", "off", "on"];
+    if (id === "minimax-m3.1-flash")
+      return ["default", "low", "medium", "high", "xhigh", "max"];
+    if (/^(gemini-4-argon(-contributor)?|gemini-3\.[5-8]-flash(-lite)?)$/.test(id))
+      return ["default", "low", "medium", "high"];
+    if (id === "grok-4.7")
+      return ["default", "low", "medium", "high", "xhigh"];
+    if (/^mistral-large-4(-0)?$/.test(id))
+      return ["default", "off", "high"];
+    if (/^inkling(-2)?(-small)?(-free)?$/.test(id))
+      return ["default", "off", "low", "medium", "high", "max"];
+    if (/^muse-(spark-1\.3(-contributor)?|wonder(-1\.0)?)$/.test(id))
+      return ["default", "low", "medium", "high", "xhigh", "max"];
+    if (id === "muse-spark-open")
+      return ["default", "low", "medium", "high", "xhigh"];
+    if (/^nemotron-3\.5-super-vl(-free)?$/.test(id))
+      return ["default", "off", "low", "medium", "high", "xhigh"];
+    if (id === "qwen3.8-max")
+      return ["default", "off", "low", "medium", "xhigh"];
+    if (/^qwen3\.8-max-(0902|prime)$/.test(id))
+      return ["default", "low", "medium", "high", "xhigh"];
+    if (id === "hy4")
+      return ["default", "off", "high"];
+    if (id === "step-5-preview")
+      return ["default", "low", "medium", "high"];
+    if (id === "ling-3.1-flash")
+      return ["default", "off", "on"];
+    if (/^beam-(free|1\.0-501b-a23b)$/.test(id))
+      return ["default", "low", "medium", "high", "xhigh", "max"];
+  }
+  return ["default"];
+}
+var ROLES = ["session", ...AGENT_NAMES];
+var KIMI = /^kimi-k3(\.1-pro)?$/;
+var BEAM = /^beam-(free|1\.0-501b-a23b)$/;
+var RECOMMENDED = [
+  [KIMI, [["low"], ["low"], ["high"], ["high"], ["low", "high"]]],
+  [/^gemini-(4-argon(-contributor)?|\d(\.\d)?-flash(-lite)?)$/, [["medium"], ["low"], ["high"], ["high"], ["high", "medium"]]],
+  [/^deepseek-v4(\.1-flash(-1017)?|-pro)$/, [["high"], ["low"], ["high"], ["high"], ["high"]]],
+  [/^gpt-6(\.1)?-sol$/, [["medium"], ["low"], ["xhigh", "high"], ["high"], ["medium"]]],
+  [/^gpt-6(\.1)?-(terra|luna)$/, [["medium"], ["low"], ["high"], ["high"], ["medium"]]],
+  [/^gpt-6(\.1)?-astra$/, [["high"], ["low"], ["xhigh"], ["high"], ["medium"]]],
+  [/^(opus|opusplan|fable|best)$|(^|\.)claude-(opus|fable)-/, [["medium"], ["low"], ["xhigh"], ["high"], ["medium"]]],
+  [/^(sonnet|haiku)$|(^|\.)claude-(sonnet|haiku)-/, [["medium"], ["low", "default"], ["high"], ["high"], ["default"]]],
+  [/^glm-5\.3(-flash)?$/, [["high"], ["low"], ["high"], ["high"], ["high"]]],
+  [/^muse-(wonder(-1\.0)?|spark-1\.3(-contributor)?)$/, [["medium"], ["low"], ["xhigh", "high"], ["high"], ["high", "medium"]]],
+  [/^grok-4\.7$/, [["medium"], ["low"], ["high"], ["high"], ["medium"]]],
+  [/^inkling(-2)?-small(-free)?$/, [["medium"], ["low"], ["high"], ["high"], ["high"]]],
+  [/^mimo-v2\.6-(pro|flash)(-free)?$/, [["on"], ["off"], ["on"], ["on"], ["on"]]],
+  [/^minimax-m3\.1-flash$/, [["medium"], ["low"], ["high"], ["high"], ["high"]]],
+  [/^mistral-large-4(-0)?$/, [["high"], ["off"], ["high"], ["high"], ["high"]]],
+  [/^nemotron-3\.5-super-vl(-free)?$/, [["medium"], ["low"], ["high"], ["high"], ["high"]]],
+  [/^qwen3\.8-max(-0902|-prime)?$/, [["medium"], ["low"], ["xhigh"], ["high", "xhigh"], ["medium"]]],
+  [/^hy4$/, [["high"], ["off"], ["high"], ["high"], ["high"]]],
+  [/^step-5-preview$/, [["medium"], ["low"], ["high"], ["high"], ["high", "medium"]]],
+  [/^ling-3\.1-flash$/, [["on"], ["off"], ["on"], ["on"], ["on"]]],
+  [BEAM, [["low"], ["low"], ["high"], ["high"], ["low", "high"]]]
+];
+var modelId = (model) => model.split("/").at(-1).toLowerCase();
+function recommendedThinking(model, slot) {
+  const index = ROLES.indexOf(slot === "plan" ? "architect" : slot);
+  const id = modelId(model);
+  return RECOMMENDED.find(([pattern]) => pattern.test(id))?.[1][index] ?? [];
+}
+function defaultThinking(model, slot) {
+  return recommendedThinking(model, slot)[0] ?? "default";
+}
+function avoidsProviderDefault(model) {
+  const id = modelId(model);
+  return KIMI.test(id) || BEAM.test(id);
+}
+function assertThinking(harness, model, thinking, session = false) {
+  if (thinking !== undefined && !thinkingChoices(harness, model, session).includes(thinking)) {
+    throw new InvalidConfigError(`${model} does not support ${thinking} thinking in ${harness}${session ? " sessions" : ""}`);
+  }
+}
+function codexThinking(thinking, legacy) {
+  if (thinking === undefined)
+    return legacy;
+  if (thinking === "default")
+    return;
+  return thinking === "off" ? "none" : thinking;
+}
+function claudeModel(model) {
+  return { opus: "claude-opus-5-5", fable: "claude-fable-5-1", best: "claude-fable-5-1", sonnet: "claude-sonnet-5-5", haiku: "claude-haiku-5-5" }[model] ?? model;
+}
+var OPENCODE_THINKING_KEYS = ["reasoningEffort", "thinking", "effort", "reasoningConfig", "reasoning", "thinkingConfig"];
+function openCodeThinkingOptions(model, thinking) {
+  assertThinking("opencode", model, thinking);
+  if (!thinking || thinking === "default")
+    return {};
+  if (model.startsWith("amazon-bedrock/")) {
+    return { reasoningConfig: { type: "adaptive", maxReasoningEffort: thinking, display: "summarized" } };
+  }
+  if (model.startsWith("openrouter/")) {
+    if (thinking === "on" || thinking === "off")
+      return { reasoning: { enabled: thinking === "on" } };
+    return { reasoning: { effort: thinking } };
+  }
+  if (model.startsWith("google/"))
+    return { thinkingConfig: { thinkingLevel: thinking } };
+  if (model.includes("claude-"))
+    return { effort: thinking };
+  if (thinking === "on" || thinking === "off") {
+    if (/gpt-6|mistral-large|inkling|nemotron|hy4/.test(model))
+      return { reasoningEffort: "none" };
+    return { thinking: { type: thinking === "off" ? "disabled" : model.includes("minimax") ? "adaptive" : "enabled" } };
+  }
+  return { reasoningEffort: thinking };
+}
+
 // src/utils/result.ts
 function ok(value) {
   return { ok: true, value };
@@ -31997,8 +32583,14 @@ function readConfig(path = CONFIG_PATH) {
       message: "Config format has changed"
     });
   }
+  if (hasOnlyCursorHarness(parsed)) {
+    return err({
+      type: "invalid",
+      message: "This config only configures Cursor, which is no longer supported. Run `atelier remove --harness cursor` on version 3.7.0 (for example `npx @martinffx/atelier@3.7.0 remove --harness cursor`), or delete ~/.atelier/config.json."
+    });
+  }
   try {
-    return ok(validateConfig(migrateLegacyAgentName(parsed)));
+    return ok(validateConfig(migrateLegacyPlanMode(migrateLegacyAgentName(parsed))));
   } catch (validationErr) {
     const message = validationErr instanceof Error ? validationErr.message : String(validationErr);
     return err({ type: "invalid", message });
@@ -32032,6 +32624,53 @@ function migrateLegacyAgentName(config) {
   }
   return migrated;
 }
+function migrateLegacyPlanMode(config) {
+  if (typeof config !== "object" || config === null) {
+    return config;
+  }
+  const migrated = { ...config };
+  const claude = migrated.claude;
+  if (typeof claude === "object" && claude !== null) {
+    const section = { ...claude };
+    if (section.default_model === "opusplan") {
+      section.build_thinking = section.plan_thinking ?? section.build_thinking;
+    }
+    if (Array.isArray(section.agents)) {
+      section.agents = section.agents.map((agent) => {
+        if (typeof agent !== "object" || agent === null || agent.model !== "opusplan") {
+          return agent;
+        }
+        return { ...agent, model: "opus" };
+      });
+    }
+    delete section.plan_thinking;
+    migrated.claude = section;
+  }
+  const opencode = migrated.opencode;
+  if (typeof opencode === "object" && opencode !== null) {
+    const section = { ...opencode };
+    const legacy = section.build_model !== undefined || section.plan_model !== undefined;
+    if (section.default_model === undefined && section.build_model !== undefined) {
+      section.default_model = section.build_model;
+    }
+    delete section.build_model;
+    delete section.plan_model;
+    if (legacy) {
+      const supported = typeof section.default_model === "string" ? thinkingChoices("opencode", section.default_model) : [];
+      if (!supported.includes(section.plan_thinking))
+        delete section.plan_thinking;
+    }
+    migrated.opencode = section;
+  }
+  return migrated;
+}
+function hasOnlyCursorHarness(config) {
+  if (typeof config !== "object" || config === null) {
+    return false;
+  }
+  const record = config;
+  return "cursor" in record && Harness.every((harness) => record[harness] == null);
+}
 function isOldFlatConfig(config) {
   if (typeof config !== "object" || config === null) {
     return false;
@@ -32100,60 +32739,6 @@ function resolveBasePath(harness) {
   return harness === "opencode" ? getGlobalOpencodeDir() : homedir2();
 }
 
-// src/utils/thinking.ts
-var THINKING_LEVELS = ["default", "off", "on", "low", "medium", "high", "xhigh", "max"];
-function thinkingChoices(harness, model, session = false) {
-  const id = model.split("/").at(-1).toLowerCase();
-  if (/gpt-6-(astra|sol|luna)$/.test(id)) {
-    return ["default", ...id.endsWith("astra") ? [] : ["off"], "low", "medium", "high", "xhigh", "max"];
-  }
-  if (/^(opus|opusplan|sonnet|haiku|fable|best)$/.test(id) || /claude-(opus-5-5|fable-5-1|sonnet-5-5|haiku-5-5)$/.test(id)) {
-    return ["default", "low", "medium", "high", "xhigh", ...harness === "claude" && session ? [] : ["max"]];
-  }
-  if (harness === "opencode") {
-    if (/^(glm-5\.3(-flash)?|kimi-k3|deepseek-v4(\.1-flash|-pro))$/.test(id))
-      return ["default", "low", "high", "max"];
-    if (/^(mimo-v2\.6-(pro|flash)(-free)?|minimax-m3(-free)?)$/.test(id))
-      return ["default", "off", "on"];
-  }
-  return ["default"];
-}
-function assertThinking(harness, model, thinking, session = false) {
-  if (thinking !== undefined && !thinkingChoices(harness, model, session).includes(thinking)) {
-    throw new InvalidConfigError(`${model} does not support ${thinking} thinking in ${harness}${session ? " sessions" : ""}`);
-  }
-}
-function codexThinking(thinking, legacy) {
-  if (thinking === undefined)
-    return legacy;
-  if (thinking === "default")
-    return;
-  return thinking === "off" ? "none" : thinking;
-}
-function claudeModel(model) {
-  return { opus: "claude-opus-5-5", fable: "claude-fable-5-1", best: "claude-fable-5-1", sonnet: "claude-sonnet-5-5", haiku: "claude-haiku-5-5" }[model] ?? model;
-}
-function claudeModeModels(model) {
-  return model === "opusplan" ? { build: claudeModel("sonnet"), plan: claudeModel("opus") } : { build: claudeModel(model), plan: claudeModel(model) };
-}
-var OPENCODE_THINKING_KEYS = ["reasoningEffort", "thinking", "effort", "reasoningConfig"];
-function openCodeThinkingOptions(model, thinking) {
-  assertThinking("opencode", model, thinking);
-  if (!thinking || thinking === "default")
-    return {};
-  if (model.startsWith("amazon-bedrock/")) {
-    return { reasoningConfig: { type: "adaptive", maxReasoningEffort: thinking, display: "summarized" } };
-  }
-  if (model.includes("claude-"))
-    return { effort: thinking };
-  if (thinking === "on" || thinking === "off") {
-    if (model.includes("gpt-6-"))
-      return { reasoningEffort: "none" };
-    return { thinking: { type: thinking === "off" ? "disabled" : model.includes("minimax") ? "adaptive" : "enabled" } };
-  }
-  return { reasoningEffort: thinking };
-}
-
 // src/services/prompt.ts
 async function promptForSection(adapter, section) {
   return adapter.promptSection(esm_default12, section);
@@ -32170,114 +32755,107 @@ async function promptForOpenCodeProvider(prompt, choices, current) {
   ]);
   return answer.provider;
 }
-async function promptForSimpleModels(prompt, section, models, harness = "claude") {
-  const answers = await prompt.prompt([
-    {
-      type: "list",
-      name: "default_model",
-      message: "Select default model",
-      choices: modelChoices(models, section.default_model),
-      default: section.default_model
-    },
-    ...AGENT_NAMES.map((name) => ({
-      type: "list",
-      name,
-      message: `Select model for ${name}`,
-      choices: modelChoices(models, section.agents.find((a) => a.name === name)?.model),
-      default: section.agents.find((a) => a.name === name)?.model || models[0]
-    }))
-  ]);
-  const selectedModel = answers.default_model || section.default_model;
-  const result = {
-    ...section,
-    default_model: selectedModel,
-    agents: AGENT_NAMES.map((name) => {
-      const agent = section.agents.find((a) => a.name === name);
-      return {
-        ...agent,
-        template: name,
-        name,
-        model: answers[name] || agent?.model || models[0]
-      };
-    })
-  };
-  await promptThinking(prompt, harness, result, section);
+async function promptForSimpleModels(prompt, section, models, harness = "claude", recommended, sessionOnly = []) {
+  const result = { ...section };
+  await promptModelsAndThinking(prompt, harness, result, section, models, recommended, sessionOnly);
   return result;
 }
-async function promptForOpenCodeModels(prompt, section, models, provider) {
-  const answers = await prompt.prompt([
-    {
-      type: "list",
-      name: "build_model",
-      message: "Select model for build",
-      choices: modelChoices(models, section.build_model),
-      default: section.build_model
-    },
-    {
-      type: "list",
-      name: "plan_model",
-      message: "Select model for plan",
-      choices: modelChoices(models, section.plan_model),
-      default: section.plan_model
-    },
-    ...AGENT_NAMES.map((name) => ({
-      type: "list",
-      name,
-      message: `Select model for ${name}`,
-      choices: modelChoices(models, section.agents.find((a) => a.name === name)?.model),
-      default: section.agents.find((a) => a.name === name)?.model || models[0]
-    }))
-  ]);
-  const result = {
-    ...section,
-    provider,
-    build_model: answers.build_model || section.build_model,
-    plan_model: answers.plan_model || section.plan_model,
-    agents: AGENT_NAMES.map((name) => {
-      const agent = section.agents.find((a) => a.name === name);
-      return {
-        ...agent,
-        template: name,
-        name,
-        model: answers[name] || agent?.model || models[0]
-      };
-    })
-  };
-  await promptThinking(prompt, "opencode", result, section);
+async function promptForOpenCodeModels(prompt, section, models, provider, recommended) {
+  const result = { ...section, provider };
+  await promptModelsAndThinking(prompt, "opencode", result, section, models, recommended);
+  if (provider === "openrouter") {
+    const { warming } = await prompt.prompt([{
+      type: "confirm",
+      name: "warming",
+      message: "Keep idle sessions warm? This sends keep-alive requests every few minutes, which cost money (requires OpenCode 2.2.6 or later)",
+      default: section.warming ?? false
+    }]);
+    if (warming !== undefined)
+      result.warming = warming;
+  }
   return result;
 }
-function modelChoices(models, saved) {
-  return [...new Set([...models, ...saved ? [saved] : []])];
-}
-async function promptThinking(prompt, harness, config, previous) {
-  const modelFor = (section, mode) => ("default_model" in section) ? section.default_model : section[`${mode}_model`];
-  const slots = ["build", "plan"].filter((mode) => !(mode === "plan" && harness === "claude" && modelFor(config, mode) !== "opusplan")).map((mode) => ({
-    name: `${mode}_thinking`,
-    label: mode,
-    model: modelFor(config, mode),
-    oldModel: modelFor(previous, mode),
-    saved: previous[`${mode}_thinking`],
+function modelChoices(models, saved, recommended) {
+  return [...new Set([...models, ...saved ? [saved] : []])].map((value) => ({ name: value === recommended ? `${value} (recommended)` : value, value }));
+}
+async function promptModelsAndThinking(prompt, harness, config, previous, models, recommended, sessionOnly = []) {
+  const hasPlan = harness !== "claude";
+  const sessionAnswer = await prompt.prompt([{
+    type: "list",
+    name: "default_model",
+    message: "Select default model",
+    choices: modelChoices([...models, ...sessionOnly], previous.default_model, recommended?.default_model),
+    default: previous.default_model
+  }]);
+  config.default_model = sessionAnswer.default_model || previous.default_model;
+  const planConfig = config;
+  await promptThinking(prompt, [{
+    name: "build_thinking",
+    role: "session",
+    label: harness === "claude" ? "session" : "build",
+    model: config.default_model,
+    oldModel: previous.default_model,
+    saved: previous.build_thinking,
     session: true,
     set: (value) => {
-      config[`${mode}_thinking`] = value;
+      config.build_thinking = value;
     }
-  }));
-  for (const agent of config.agents) {
-    const old = previous.agents.find((a) => a.name === agent.name);
-    slots.push({ name: `${agent.name}_thinking`, label: agent.name, model: agent.model, oldModel: old?.model ?? "", saved: old?.thinking, session: false, set: (value) => {
-      agent.thinking = value;
-    } });
-  }
+  }, ...hasPlan ? [{
+    name: "plan_thinking",
+    role: "plan",
+    label: "plan",
+    model: config.default_model,
+    oldModel: previous.default_model,
+    saved: previous.plan_thinking,
+    session: false,
+    set: (value) => {
+      planConfig.plan_thinking = value;
+    }
+  }] : []], harness);
+  const agents = [];
+  for (const name of AGENT_NAMES) {
+    const old = previous.agents.find((a) => a.name === name);
+    const answer = await prompt.prompt([{
+      type: "list",
+      name,
+      message: `Select model for ${name}`,
+      choices: modelChoices(models, old?.model, recommended?.agents.find((a) => a.name === name)?.model),
+      default: old?.model || models[0]
+    }]);
+    const agent = { ...old, template: name, name, model: answer[name] || old?.model || models[0] };
+    agents.push(agent);
+    await promptThinking(prompt, [{
+      name: `${name}_thinking`,
+      role: name,
+      label: name,
+      model: agent.model,
+      oldModel: old?.model ?? "",
+      saved: old?.thinking,
+      session: false,
+      set: (value) => {
+        agent.thinking = value;
+      }
+    }], harness);
+  }
+  config.agents = agents;
+}
+async function promptThinking(prompt, slots, harness) {
   const questions = slots.map((slot) => {
     const choices = thinkingChoices(harness, slot.model, slot.session);
-    const saved = slot.model === slot.oldModel && (slot.saved === undefined || choices.includes(slot.saved)) ? slot.saved : "default";
-    slot.set(saved);
+    const recommended = recommendedThinking(slot.model, slot.role).filter((level) => choices.includes(level));
+    const fallback = recommended[0] ?? "default";
+    const unchanged = slot.model === slot.oldModel && (slot.saved === undefined || choices.includes(slot.saved));
+    const preselected = unchanged ? slot.saved === "default" && avoidsProviderDefault(slot.model) ? fallback : slot.saved : fallback;
+    slot.set(preselected);
     return {
       type: "list",
       name: slot.name,
       message: `Select thinking for ${slot.label} (${slot.model})`,
-      choices: saved === undefined ? [{ name: "Keep existing behavior", value: "keep" }, ...choices] : choices,
-      default: saved ?? "keep"
+      choices: [
+        ...preselected === undefined ? [{ name: "Keep existing behavior", value: "keep" }] : [],
+        ...choices.map((level) => ({ name: recommended.includes(level) ? `${level} (recommended)` : level, value: level }))
+      ],
+      default: preselected ?? "keep"
     };
   });
   const answers = await prompt.prompt(questions);
@@ -32285,15 +32863,13 @@ async function promptThinking(prompt, harness, config, previous) {
     if (answers[slot.name] !== undefined)
       slot.set(answers[slot.name] === "keep" ? undefined : answers[slot.name]);
   }
-  if (harness === "claude" && "default_model" in config && config.default_model !== "opusplan")
-    config.plan_thinking = config.build_thinking;
 }
 function formatFileList(files) {
   return files.map((f) => `  ${f.action === "delete" ? "-" : f.exists ? "~" : "+"} ${f.path}`).join(`
 `);
 }
 function guardProvider(provider) {
-  if (!provider || !["opencode-zen", "opencode-go", "amazon-bedrock", "openai"].includes(provider)) {
+  if (!provider || !["opencode-zen", "opencode-go", "amazon-bedrock", "openai", "openrouter", "google"].includes(provider)) {
     throw new InvalidConfigError("A valid provider must be selected for OpenCode");
   }
   return provider;
@@ -32548,57 +33124,51 @@ var ThinkingSchema = enumType(THINKING_LEVELS);
 var AgentSchema = objectType({
   template: enumType(AGENT_NAMES),
   name: enumType(AGENT_NAMES),
-  model: stringType().min(1)
+  model: stringType().min(1),
+  thinking: ThinkingSchema.optional()
 });
-var ThinkingAgentSchema = AgentSchema.extend({ thinking: ThinkingSchema.optional() });
 var SimpleConfigSchema = objectType({
   provider: stringType().optional(),
   default_model: stringType().min(1),
   build_thinking: ThinkingSchema.optional(),
-  plan_thinking: ThinkingSchema.optional(),
-  agents: arrayType(ThinkingAgentSchema).min(1)
-});
-var CursorConfigSchema = objectType({
   agents: arrayType(AgentSchema).min(1)
-}).strict();
-var OPENCODE_PROVIDERS = ["opencode-zen", "opencode-go", "amazon-bedrock", "openai"];
+});
+var OPENCODE_PROVIDERS = ["opencode-zen", "opencode-go", "amazon-bedrock", "openai", "openrouter", "google"];
 var OpenCodeConfigSchema = objectType({
   provider: enumType(OPENCODE_PROVIDERS),
-  build_model: stringType().min(1),
-  plan_model: stringType().min(1),
+  default_model: stringType().min(1),
   build_thinking: ThinkingSchema.optional(),
   plan_thinking: ThinkingSchema.optional(),
-  agents: arrayType(ThinkingAgentSchema).min(1)
+  agents: arrayType(AgentSchema).min(1),
+  warming: booleanType().optional()
 }).superRefine((config, ctx) => checkThinking("opencode", config, ctx));
 var CLAUDE_OPTIONAL_BUILTINS = ["cron", "chrome", "remote-trigger"];
 var ClaudeConfigSchema = SimpleConfigSchema.extend({
   disabled_builtins: arrayType(enumType(CLAUDE_OPTIONAL_BUILTINS)).optional()
-}).superRefine((config, ctx) => {
-  checkThinking("claude", config, ctx);
-  if (config.default_model !== "opusplan" && config.plan_thinking !== undefined && config.plan_thinking !== config.build_thinking) {
-    ctx.addIssue({ code: "custom", path: ["plan_thinking"], message: "Separate Claude Plan/Build thinking requires opusplan" });
-  }
-});
-var CodexConfigSchema = SimpleConfigSchema.superRefine((config, ctx) => checkThinking("codex", config, ctx));
+}).superRefine((config, ctx) => checkThinking("claude", config, ctx));
+var CodexConfigSchema = SimpleConfigSchema.extend({
+  plan_thinking: ThinkingSchema.optional()
+}).superRefine((config, ctx) => checkThinking("codex", config, ctx));
 function checkThinking(harness, config, ctx) {
   const check = (model, thinking, path, session = false) => {
     if (thinking !== undefined && !thinkingChoices(harness, model, session).includes(thinking)) {
       ctx.addIssue({ code: "custom", path, message: `${model} does not support ${thinking} thinking` });
     }
   };
-  check("default_model" in config ? config.default_model : config.build_model, config.build_thinking, ["build_thinking"], true);
-  check("default_model" in config ? config.default_model : config.plan_model, config.plan_thinking, ["plan_thinking"], true);
+  check(config.default_model, config.build_thinking, ["build_thinking"], true);
+  check(config.default_model, config.plan_thinking, ["plan_thinking"]);
   config.agents.forEach((agent, i) => check(agent.model, agent.thinking, ["agents", i, "thinking"]));
 }
 
 // src/adapters/claude.ts
-var ANTHROPIC_MODELS = ["haiku", "sonnet", "opus", "fable", "best", "opusplan"];
+var ANTHROPIC_MODELS = ["haiku", "sonnet", "opus", "fable", "best"];
+var SESSION_ONLY_MODELS = ["opusplan"];
 var DEFAULT_MODELS = {
-  default_model: "opusplan",
+  default_model: "opus",
   sentinel: "haiku",
   oracle: "opus",
   architect: "opus",
-  keymaker: "haiku"
+  keymaker: "sonnet"
 };
 var CLAUDE_AI_OPT_OUTS = {
   disableClaudeAiConnectors: true,
@@ -32630,13 +33200,12 @@ function defaultSection() {
   return {
     provider: "anthropic",
     default_model: DEFAULT_MODELS.default_model,
-    build_thinking: "high",
-    plan_thinking: "high",
+    build_thinking: defaultThinking(DEFAULT_MODELS.default_model, "session"),
     agents: AGENT_NAMES.map((name) => ({
       template: name,
       name,
       model: DEFAULT_MODELS[name],
-      thinking: name === "sentinel" || name === "keymaker" ? "default" : name === "oracle" ? "xhigh" : "high"
+      thinking: defaultThinking(DEFAULT_MODELS[name], name)
     }))
   };
 }
@@ -32645,7 +33214,7 @@ function modelsForProvider(_provider) {
 }
 async function promptSection(prompt, section) {
   const claude = section;
-  const result = await promptForSimpleModels(prompt, claude, modelsForProvider());
+  const result = await promptForSimpleModels(prompt, claude, modelsForProvider(), "claude", defaultSection(), SESSION_ONLY_MODELS);
   const { disabled } = await prompt.prompt([{
     type: "checkbox",
     name: "disabled",
@@ -32685,13 +33254,15 @@ function mergeHarnessConfig(section, basePath) {
   const settingsPath = join7(claudeDir, "settings.json");
   const existing = readExistingSettings(settingsPath);
   const isNew = Object.keys(existing).length === 0;
+  removeStaleSonnetEffort(existing, config.default_model);
   const settings = {
     ...existing,
     $schema: "https://json.schemastore.org/claude-code-settings.json",
     ...CLAUDE_AI_OPT_OUTS,
     model: config.default_model || DEFAULT_MODELS.default_model
   };
-  applyModeThinking(settings, config);
+  applySessionThinking(settings, config);
+  removeLegacyAutoCompactWindow(settings);
   applyBuiltins(settings, CONFLICTING_BUILTINS);
   for (const name of CLAUDE_OPTIONAL_BUILTINS) {
     if (config.disabled_builtins?.includes(name))
@@ -32750,40 +33321,62 @@ function removeAtelierSettings(claudeDir, config) {
     return;
   }
   const content = parseSettingsJson(settingsPath);
+  removeStaleSonnetEffort(content, config.default_model);
   delete content.$schema;
   delete content.model;
   for (const [key, value] of Object.entries(CLAUDE_AI_OPT_OUTS)) {
     if (content[key] === value)
       delete content[key];
   }
-  applyModeThinking(content, config, true);
+  applySessionThinking(content, config, true);
+  removeLegacyAutoCompactWindow(content);
   removeBuiltins(content, CONFLICTING_BUILTINS);
   for (const patch of Object.values(OPTIONAL_BUILTINS))
     removeBuiltins(content, patch);
   writeOrDeleteSettings(settingsPath, content);
 }
-function applyModeThinking(settings, config, remove = false) {
-  const models = claudeModeModels(config.default_model);
+function editModelSettings(settings, models, edit) {
   const modelSettings = { ...settings.modelSettings };
-  for (const mode of ["build", "plan"]) {
-    const thinking = config[`${mode}_thinking`];
-    if (thinking === undefined)
-      continue;
-    const entry = { ...modelSettings[models[mode]] };
-    if (remove || thinking === "default")
-      delete entry.effortLevel;
-    else
-      entry.effortLevel = thinking;
+  for (const model of models) {
+    const entry = { ...modelSettings[model] };
+    edit(entry);
     if (Object.keys(entry).length)
-      modelSettings[models[mode]] = entry;
+      modelSettings[model] = entry;
     else
-      delete modelSettings[models[mode]];
+      delete modelSettings[model];
   }
   if (Object.keys(modelSettings).length)
     settings.modelSettings = modelSettings;
   else
     delete settings.modelSettings;
 }
+function applySessionThinking(settings, config, remove = false) {
+  const thinking = config.build_thinking;
+  if (thinking === undefined)
+    return;
+  const models = config.default_model === "opusplan" ? [claudeModel("opus"), claudeModel("sonnet")] : [claudeModel(config.default_model)];
+  editModelSettings(settings, models, (entry) => {
+    if (remove || thinking === "default")
+      delete entry.effortLevel;
+    else
+      entry.effortLevel = thinking;
+  });
+}
+function removeStaleSonnetEffort(settings, nextModel) {
+  if (settings.model !== "opusplan" || nextModel === "opusplan")
+    return;
+  editModelSettings(settings, [claudeModel("sonnet")], (entry) => {
+    delete entry.effortLevel;
+  });
+}
+var LEGACY_AUTO_COMPACT_WINDOW = 190000;
+var LEGACY_AUTO_COMPACT_MODELS = ["claude-sonnet-5-5", "claude-opus-5-5"];
+function removeLegacyAutoCompactWindow(settings) {
+  editModelSettings(settings, LEGACY_AUTO_COMPACT_MODELS, (entry) => {
+    if (entry.autoCompactWindow === LEGACY_AUTO_COMPACT_WINDOW)
+      delete entry.autoCompactWindow;
+  });
+}
 function applyBuiltins(settings, patch) {
   Object.assign(settings, patch.settings);
   if (patch.env)
@@ -32891,83 +33484,152 @@ var OPENCODE_PROVIDERS2 = [
   { name: "OpenCode Zen", value: "opencode-zen" },
   { name: "OpenCode Go", value: "opencode-go" },
   { name: "Amazon Bedrock", value: "amazon-bedrock" },
-  { name: "OpenAI", value: "openai" }
+  { name: "OpenAI", value: "openai" },
+  { name: "OpenRouter", value: "openrouter" },
+  { name: "Google Gemini", value: "google" }
 ];
 var PROVIDER_MODELS = {
   "opencode-zen": [
+    "gpt-6.1-sol",
     "gpt-6-astra",
     "gpt-6-sol",
     "gpt-6-luna",
     "claude-opus-5-5",
     "claude-fable-5-1",
     "claude-sonnet-5-5",
-    "claude-haiku-4-5",
+    "claude-haiku-5-5",
     "glm-5.3",
     "glm-5.3-flash",
     "kimi-k3",
-    "kimi-k2.7-code",
     "deepseek-v4.1-flash",
     "deepseek-v4-pro",
     "minimax-m3",
     "qwen3.8-max",
     "qwen3.8-flash",
     "mimo-v2.6-flash-free",
+    "gemini-4-argon",
     "gemini-3.8-flash",
-    "gemini-3.1-pro"
+    "grok-4.7",
+    "mistral-large-4",
+    "muse-spark-1.3",
+    "muse-wonder-1.0",
+    "inkling-2-small-free",
+    "nemotron-3.5-super-vl-free",
+    "nemotron-3.5-lightning-free",
+    "beam-free"
   ].map((id) => `opencode/${id}`),
   "opencode-go": [
     "glm-5.3",
     "glm-5.3-flash",
+    "kimi-k3.1-pro",
     "kimi-k3",
     "deepseek-v4.1-flash",
     "deepseek-v4-pro",
+    "minimax-m3.1-flash",
     "minimax-m3",
     "qwen3.8-max",
     "qwen3.8-flash",
     "mimo-v2.6-pro",
     "mimo-v2.6-flash",
-    "gpt-6-luna"
+    "gpt-6-luna",
+    "claude-haiku-5-5",
+    "gemini-4-argon",
+    "grok-4.7",
+    "muse-spark-1.3-contributor",
+    "hy4",
+    "step-5-preview",
+    "beam-free"
   ].map((id) => `opencode-go/${id}`),
   "amazon-bedrock": [
     "us.anthropic.claude-opus-5-5",
     "us.anthropic.claude-fable-5-1",
     "us.anthropic.claude-sonnet-5-5",
-    "us.anthropic.claude-haiku-4-5-20251001-v1:0"
+    "us.anthropic.claude-haiku-5-5"
   ].map((id) => `amazon-bedrock/${id}`),
-  openai: ["gpt-6-astra", "gpt-6-sol", "gpt-6-luna", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.3-codex-spark"].map((id) => `openai/${id}`)
+  openai: ["gpt-6.1-sol", "gpt-6.1-terra", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna"].map((id) => `openai/${id}`),
+  openrouter: [
+    "anthropic/claude-opus-5.5",
+    "anthropic/claude-fable-5.1",
+    "anthropic/claude-sonnet-5.5",
+    "anthropic/claude-haiku-5.5",
+    "openai/gpt-6.1-sol",
+    "openai/gpt-6.1-terra",
+    "openai/gpt-6-astra",
+    "openai/gpt-6-sol",
+    "openai/gpt-6-luna",
+    "google/gemini-4-argon",
+    "google/gemini-3.8-flash",
+    "z-ai/glm-5.3",
+    "z-ai/glm-5.3-flash",
+    "moonshotai/kimi-k3.1-pro",
+    "moonshotai/kimi-k3",
+    "deepseek/deepseek-v4.1-flash-1017",
+    "deepseek/deepseek-v4.1-flash",
+    "deepseek/deepseek-v4-pro",
+    "x-ai/grok-4.7",
+    "minimax/minimax-m3.1-flash",
+    "minimax/minimax-m3",
+    "qwen/qwen3.8-flash",
+    "qwen/qwen3.8-max-0902",
+    "qwen/qwen3.8-max-prime",
+    "xiaomi/mimo-v2.6-pro",
+    "mistralai/mistral-large-4-0",
+    "thinkingmachines/inkling",
+    "thinkingmachines/inkling-small",
+    "nvidia/nemotron-3.5-super-vl",
+    "nvidia/nemotron-3.5-lightning",
+    "tencent/hy4",
+    "stepfun/step-5-preview",
+    "inclusionai/ling-3.1-flash",
+    "reflection/beam-1.0-501b-a23b",
+    "meta/muse-spark-1.3",
+    "meta/muse-spark-open",
+    "meta/muse-wonder"
+  ].map((id) => `openrouter/${id}`),
+  google: ["gemini-4-argon", "gemini-3.8-flash", "gemini-3.5-flash-lite"].map((id) => `google/${id}`)
 };
 var DEFAULT_MODELS2 = {
   "opencode-zen": {
     sentinel: "opencode/glm-5.3-flash",
     oracle: "opencode/kimi-k3",
     architect: "opencode/glm-5.3",
-    keymaker: "opencode/glm-5.3-flash",
-    build: "opencode/deepseek-v4.1-flash",
-    plan: "opencode/glm-5.3"
+    keymaker: "opencode/deepseek-v4.1-flash",
+    default: "opencode/kimi-k3"
   },
   "opencode-go": {
     sentinel: "opencode-go/glm-5.3-flash",
     oracle: "opencode-go/mimo-v2.6-pro",
     architect: "opencode-go/glm-5.3",
-    keymaker: "opencode-go/glm-5.3-flash",
-    build: "opencode-go/deepseek-v4.1-flash",
-    plan: "opencode-go/glm-5.3"
+    keymaker: "opencode-go/deepseek-v4.1-flash",
+    default: "opencode-go/kimi-k3.1-pro"
   },
   "amazon-bedrock": {
-    sentinel: "amazon-bedrock/us.anthropic.claude-haiku-4-5-20251001-v1:0",
+    sentinel: "amazon-bedrock/us.anthropic.claude-haiku-5-5",
     oracle: "amazon-bedrock/us.anthropic.claude-fable-5-1",
     architect: "amazon-bedrock/us.anthropic.claude-opus-5-5",
-    keymaker: "amazon-bedrock/us.anthropic.claude-haiku-4-5-20251001-v1:0",
-    build: "amazon-bedrock/us.anthropic.claude-sonnet-5-5",
-    plan: "amazon-bedrock/us.anthropic.claude-opus-5-5"
+    keymaker: "amazon-bedrock/us.anthropic.claude-sonnet-5-5",
+    default: "amazon-bedrock/us.anthropic.claude-opus-5-5"
   },
   openai: {
     sentinel: "openai/gpt-6-luna",
     oracle: "openai/gpt-6-astra",
     architect: "openai/gpt-6-astra",
-    keymaker: "openai/gpt-6-luna",
-    build: "openai/gpt-6-sol",
-    plan: "openai/gpt-6-astra"
+    keymaker: "openai/gpt-6-sol",
+    default: "openai/gpt-6-astra"
+  },
+  openrouter: {
+    sentinel: "openrouter/z-ai/glm-5.3-flash",
+    oracle: "openrouter/moonshotai/kimi-k3.1-pro",
+    architect: "openrouter/z-ai/glm-5.3",
+    keymaker: "openrouter/deepseek/deepseek-v4.1-flash-1017",
+    default: "openrouter/moonshotai/kimi-k3.1-pro"
+  },
+  google: {
+    sentinel: "google/gemini-3.5-flash-lite",
+    oracle: "google/gemini-4-argon",
+    architect: "google/gemini-4-argon",
+    keymaker: "google/gemini-3.8-flash",
+    default: "google/gemini-4-argon"
   }
 };
 var COMMAND_MARKER = "<!-- Generated by Atelier -->";
@@ -32988,15 +33650,14 @@ function defaultSection2(provider) {
   const defaults = DEFAULT_MODELS2[selectedProvider];
   return {
     provider: selectedProvider,
-    build_model: defaults.build,
-    plan_model: defaults.plan,
-    build_thinking: "high",
-    plan_thinking: selectedProvider === "openai" ? "xhigh" : "high",
+    default_model: defaults.default,
+    build_thinking: defaultThinking(defaults.default, "session"),
+    plan_thinking: defaultThinking(defaults.default, "plan"),
     agents: AGENT_NAMES.map((name) => ({
       template: name,
       name,
       model: defaults[name],
-      thinking: name === "sentinel" || name === "keymaker" ? selectedProvider === "amazon-bedrock" ? "default" : "low" : name === "oracle" && selectedProvider === "opencode-go" ? "on" : name === "architect" && selectedProvider === "openai" ? "xhigh" : "high"
+      thinking: defaultThinking(defaults[name], name)
     }))
   };
 }
@@ -33008,7 +33669,7 @@ async function promptSection2(prompt, section) {
   const openCodeSection = section;
   const provider = guardProvider(await promptForOpenCodeProvider(prompt, OPENCODE_PROVIDERS2, openCodeSection.provider));
   const models = modelsForProvider2(provider);
-  return promptForOpenCodeModels(prompt, provider === openCodeSection.provider ? openCodeSection : defaultSection2(provider), models, provider);
+  return promptForOpenCodeModels(prompt, provider === openCodeSection.provider ? openCodeSection : defaultSection2(provider), models, provider, defaultSection2(provider));
 }
 function installAgents2(section, basePath, sharedConfig) {
   const config = OpenCodeConfigSchema.parse(section);
@@ -33082,26 +33743,37 @@ function mergeHarnessConfig2(section, basePath) {
   } catch (err) {
     throw new FileWriteError(basePath, err instanceof Error ? err.message : String(err));
   }
-  const sentinel = config.agents.find((a) => a.name === "sentinel");
-  const architect = config.agents.find((a) => a.name === "architect");
   const existingAgents = existing.agent;
-  for (const mode of ["build", "plan"]) {
-    if (config[`${mode}_thinking`] === undefined || !existingAgents?.[mode])
-      continue;
+  if (config.build_thinking !== undefined && existingAgents?.build) {
     for (const key of OPENCODE_THINKING_KEYS)
-      delete existingAgents[mode][key];
+      delete existingAgents.build[key];
+  }
+  const existingPlan = existingAgents?.plan;
+  const userOwnsPlan = existingPlan !== undefined && !isAtelierPlan(existingPlan);
+  if (config.plan_thinking !== undefined && userOwnsPlan) {
+    console.log(`Skipped agent.plan in ${shortPath(opencodeJsonPath)} because it is not managed by Atelier.`);
+  }
+  if (config.plan_thinking === undefined) {
+    if (existingAgents && typeof existingAgents === "object" && !Array.isArray(existingAgents))
+      stripModeEntry(existingAgents, "plan");
+  } else if (!userOwnsPlan && existingAgents?.plan) {
+    for (const key of OPENCODE_THINKING_KEYS)
+      delete existingAgents.plan[key];
   }
   const atelierFields = {
+    model: config.default_model,
     agent: {
       build: {
         mode: "primary",
-        model: config.build_model || sentinel?.model || DEFAULT_MODELS2[config.provider].build,
-        ...openCodeThinkingOptions(config.build_model, config.build_thinking)
+        model: config.default_model,
+        ...openCodeThinkingOptions(config.default_model, config.build_thinking)
       },
-      plan: {
-        mode: "primary",
-        model: config.plan_model || architect?.model || DEFAULT_MODELS2[config.provider].plan,
-        ...openCodeThinkingOptions(config.plan_model, config.plan_thinking)
+      ...config.plan_thinking === undefined || userOwnsPlan ? {} : {
+        plan: {
+          mode: "primary",
+          model: config.default_model,
+          ...openCodeThinkingOptions(config.default_model, config.plan_thinking)
+        }
       }
     }
   };
@@ -33114,6 +33786,18 @@ function mergeHarnessConfig2(section, basePath) {
       }
     };
   }
+  const legacyProvider = existing.provider;
+  const hasLegacyOpenrouter = !!legacyProvider && typeof legacyProvider === "object" && !Array.isArray(legacyProvider) && legacyProvider.openrouter !== undefined;
+  if (config.provider === "openrouter" && config.warming === true && hasLegacyOpenrouter) {
+    removeWarming(existing);
+    console.log(`Skipped providers.openrouter.settings.cache.warming in ${shortPath(opencodeJsonPath)} because provider.openrouter is present; warming was not applied.`);
+  } else if (config.provider === "openrouter" && config.warming === true) {
+    const warming = ["providers", "openrouter", "settings", "cache", "warming"].reduce((node, key) => node && typeof node === "object" ? node[key] : undefined, existing);
+    if (typeof warming !== "object" || warming === null)
+      atelierFields.providers = { openrouter: { settings: { cache: { warming: true } } } };
+  } else if (config.provider !== "openrouter" || config.warming === false) {
+    removeWarming(existing);
+  }
   const merged = deepMerge2(existing, atelierFields);
   try {
     writeFileSync4(opencodeJsonPath, JSON.stringify(merged, null, 2) + `
@@ -33262,7 +33946,7 @@ function writeOrDeleteOpenCodeJson(basePath, config) {
   if (!existsSync4(opencodeJsonPath)) {
     return;
   }
-  const content = stripOpenCodeConfig(readExistingOpenCodeJson(opencodeJsonPath), config.provider);
+  const content = stripOpenCodeConfig(readExistingOpenCodeJson(opencodeJsonPath), config.provider, config.default_model);
   try {
     if (Object.keys(content).length === 0) {
       rmSync3(opencodeJsonPath, { force: true });
@@ -33285,17 +33969,28 @@ function readExistingOpenCodeJson(opencodeJsonPath) {
     throw new HarnessConfigError(opencodeJsonPath, err instanceof Error ? err.message : String(err));
   }
 }
-function stripOpenCodeConfig(content, provider) {
+function isAtelierPlan(entry) {
+  return typeof entry === "object" && entry !== null && !Array.isArray(entry) && entry.mode === "primary";
+}
+function stripModeEntry(agent, mode) {
+  const entry = agent[mode];
+  if (!entry || typeof entry !== "object" || Array.isArray(entry))
+    return;
+  const record = entry;
+  if (mode === "plan" && !isAtelierPlan(record))
+    return;
+  for (const key of ["mode", "model", ...OPENCODE_THINKING_KEYS])
+    delete record[key];
+  if (!Object.keys(record).length)
+    delete agent[mode];
+}
+function stripOpenCodeConfig(content, provider, sessionModel) {
+  if (content.model === sessionModel)
+    delete content.model;
   if (content.agent && typeof content.agent === "object" && !Array.isArray(content.agent)) {
     const agent = content.agent;
     for (const mode of ["build", "plan"]) {
-      const entry = agent[mode];
-      if (!entry || typeof entry !== "object" || Array.isArray(entry))
-        continue;
-      for (const key of ["mode", "model", ...OPENCODE_THINKING_KEYS])
-        delete entry[key];
-      if (!Object.keys(entry).length)
-        delete agent[mode];
+      stripModeEntry(agent, mode);
     }
     if (Object.keys(agent).length === 0) {
       delete content.agent;
@@ -33316,8 +34011,26 @@ function stripOpenCodeConfig(content, provider) {
       delete content.provider;
     }
   }
+  removeWarming(content);
   return content;
 }
+function removeWarming(content) {
+  const path = ["providers", "openrouter", "settings", "cache"];
+  const chain = [content];
+  for (const key of path) {
+    const next = chain[chain.length - 1][key];
+    if (!next || typeof next !== "object" || Array.isArray(next))
+      return;
+    chain.push(next);
+  }
+  const cache = chain[chain.length - 1];
+  if (cache.warming !== true)
+    return;
+  delete cache.warming;
+  for (let i = chain.length - 1;i > 0 && !Object.keys(chain[i]).length; i--) {
+    delete chain[i - 1][path[i - 1]];
+  }
+}
 function getOpencodeRoot(basePath) {
   return basePath === getGlobalOpencodeDir() ? basePath : join8(basePath, ".opencode");
 }
@@ -33337,126 +34050,6 @@ function deepMerge2(target, source) {
 import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync6, existsSync as existsSync5, rmSync as rmSync4, rmdirSync as rmdirSync3, readdirSync as readdirSync4 } from "fs";
 import { join as join9 } from "path";
 
-// 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(date) {
-    let hasDate = true;
-    let hasTime = true;
-    let offset = "Z";
-    if (typeof date === "string") {
-      let match = date.match(DATE_TIME_RE);
-      if (match) {
-        if (!match[1]) {
-          hasDate = false;
-          date = `0000-01-01T${date}`;
-        }
-        hasTime = !!match[2];
-        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
-        if (match[2] && +match[2] > 23) {
-          date = "";
-        } else {
-          offset = match[3] || null;
-          date = date.toUpperCase();
-          if (!offset && hasTime)
-            date += "Z";
-        }
-      } else {
-        date = "";
-      }
-    }
-    super(date);
-    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 date = new TomlDate(jsDate);
-    date.#offset = offset;
-    return date;
-  }
-  static wrapAsLocalDateTime(jsDate) {
-    let date = new TomlDate(jsDate);
-    date.#offset = null;
-    return date;
-  }
-  static wrapAsLocalDate(jsDate) {
-    let date = new TomlDate(jsDate);
-    date.#hasTime = false;
-    date.#offset = null;
-    return date;
-  }
-  static wrapAsLocalTime(jsDate) {
-    let date = new TomlDate(jsDate);
-    date.#hasDate = false;
-    date.#offset = null;
-    return date;
-  }
-}
-
 // node_modules/smol-toml/dist/error.js
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
@@ -33486,11 +34079,11 @@ class TomlDate extends Date {
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 function getLineColFromPtr(string, ptr) {
-  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  let lines = string.slice(0, ptr).split(/\r?\n/);
   return [lines.length, lines.pop().length + 1];
 }
 function makeCodeBlock(string, line, column) {
-  let lines = string.split(/\r\n|\n|\r/g);
+  let lines = string.split(/\r?\n/);
   let codeblock = "";
   let numberLen = (Math.log10(line + 1) | 0) + 1;
   for (let i = line - 1;i <= line + 1; i++) {
@@ -33525,6 +34118,9 @@ ${codeblock}`, options2);
     this.column = column;
     this.codeblock = codeblock;
   }
+  static x(message, ctx, ptr) {
+    throw new TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+  }
 }
 
 // node_modules/smol-toml/dist/primitive.js
@@ -33555,159 +34151,99 @@ ${codeblock}`, options2);
  * 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(str2, ptr) {
-  let c = str2[ptr++];
+function parseString(ctx) {
+  let startPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
   let first = c;
-  let isLiteral = c === "'";
-  let isMultiline = c === str2[ptr] && c === str2[ptr + 1];
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
   if (isMultiline) {
-    if (str2[ptr += 2] === `
-`)
-      ptr++;
-    else if (str2[ptr] === "\r" && str2[ptr + 1] === `
-`)
-      ptr += 2;
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
   }
   let parsed = "";
-  let sliceStart = ptr;
+  let sliceStart = ctx.p;
   let state = 0;
-  for (let i = ptr;i < str2.length; i++) {
-    c = str2[i];
-    if (isMultiline && (c === `
-` || c === "\r" && str2[i + 1] === `
-`)) {
+  for (;ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
       state = state && 3;
-    } else if (c < " " && c !== "\t" || c === "\x7F") {
-      throw new TomlError("control characters are not allowed in strings", {
-        toml: str2,
-        ptr: i
-      });
-    } else if ((!state || state === 3) && c === first && (!isMultiline || str2[i + 1] === first && str2[i + 2] === first)) {
+    } else if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in strings", ctx);
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
       if (isMultiline) {
-        if (str2[i + 3] === first)
-          i++;
-        if (str2[i + 3] === first)
-          i++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
       }
-      return [
-        state ? parsed : parsed + str2.slice(sliceStart, i),
-        i + (isMultiline ? 3 : 1)
-      ];
+      if (!state) {
+        let s = ctx.s.slice(sliceStart, ctx.p);
+        parsed = parsed ? parsed + s : s;
+      }
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
     } else if (!state) {
-      if (!isLiteral && c === "\\") {
-        parsed += str2.slice(sliceStart, sliceStart = i);
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
         state = 1;
       }
     } else if (state === 1) {
-      if (c === "x" || c === "u" || c === "U") {
+      if (c === 120 || c === 117 || c === 85) {
+        let errPtr = ctx.p++ - 1;
         let value = 0;
-        let len = c === "x" ? 2 : c === "u" ? 4 : 8;
-        for (let j = 0;j < len; j++, i++) {
-          let hex = str2.charCodeAt(i + 1);
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0;j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p);
           let digit = hex >= 48 && hex <= 57 ? hex - 48 : hex >= 65 && hex <= 70 ? hex - 65 + 10 : hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1;
           if (digit < 0)
-            throw new TomlError("invalid non-hex character in unicode escape", { toml: str2, ptr: i + 1 });
+            TomlError.x("invalid non-hex character in unicode escape", ctx);
           value = value << 4 | digit;
         }
         if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
-          throw new TomlError("invalid unicode escape", { toml: str2, ptr: i });
+          TomlError.x("invalid unicode escape", ctx, errPtr);
         }
         parsed += String.fromCodePoint(value);
-        sliceStart = i + 1;
+        sliceStart = ctx.p--;
         state = 0;
-      } else if (c === " " || c === "\t") {
+      } else if (isMultiline && (c === 32 || c === 9)) {
         state = 2;
       } else {
-        if (c === "b")
+        if (c === 98)
           parsed += "\b";
-        else if (c === "t")
+        else if (c === 116)
           parsed += "\t";
-        else if (c === "n")
+        else if (c === 110)
           parsed += `
 `;
-        else if (c === "f")
+        else if (c === 102)
           parsed += "\f";
-        else if (c === "r")
+        else if (c === 114)
           parsed += "\r";
-        else if (c === "e")
+        else if (c === 101)
           parsed += "\x1B";
-        else if (c === '"')
+        else if (c === 34)
           parsed += '"';
-        else if (c === "\\")
+        else if (c === 92)
           parsed += "\\";
         else
-          throw new TomlError("unrecognized escape sequence", { toml: str2, ptr: i });
-        sliceStart = i + 1;
+          TomlError.x("unrecognised escape sequence", ctx);
+        sliceStart = ctx.p + 1;
         state = 0;
       }
-    } else if (c !== " " && c !== "\t") {
-      if (state === 2) {
-        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
-          toml: str2,
-          ptr: sliceStart
-        });
-      }
-      state = !isLiteral && c === "\\" ? 1 : 0;
-      sliceStart = i;
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2)
+        TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
     }
   }
-  throw new TomlError("unfinished string", { toml: str2, 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 date = new TomlDate(value);
-  if (!date.isValid()) {
-    throw new TomlError("invalid value", {
-      toml,
-      ptr
-    });
-  }
-  return date;
+  TomlError.x("unfinished string", ctx, startPtr);
 }
 
-// node_modules/smol-toml/dist/util.js
+// node_modules/smol-toml/dist/date.js
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -33735,65 +34271,119 @@ function parseValue(value, toml, ptr, integersAsBigInt) {
  * 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(str2, start = 0, end = str2.length) {
-  let idx = str2.indexOf(`
-`, start);
-  if (str2[idx - 1] === "\r")
-    idx--;
-  return idx <= end ? idx : -1;
-}
-function skipComment(str2, ptr) {
-  for (let i = ptr;i < str2.length; i++) {
-    let c = str2[i];
-    if (c === `
-`)
-      return i;
-    if (c === "\r" && str2[i + 1] === `
-`)
-      return i + 1;
-    if (c < " " && c !== "\t" || c === "\x7F") {
-      throw new TomlError("control characters are not allowed in comments", {
-        toml: str2,
-        ptr
-      });
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
+
+class TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date, fasttype, unsafeDelim) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    let c;
+    if (typeof date === "string") {
+      if (fasttype)
+        prep: {
+          if (fasttype < 3) {
+            if (+date.slice(11, 13) > 23) {
+              date = "";
+              break prep;
+            }
+            if (fasttype === 2) {
+              offset = null;
+              date += "Z";
+            } else if ((c = date.charCodeAt(date.length - 1)) !== 90 && c !== 122) {
+              offset = date.slice(date.length - 6);
+            }
+            if (unsafeDelim)
+              date = date.slice(0, 10) + "T" + date.slice(11);
+          } else if (fasttype === 4) {
+            date = +date.slice(0, 2) > 23 ? "" : `0000-01-01T${date}Z`;
+          }
+          hasDate = fasttype !== 4;
+          hasTime = fasttype !== 3;
+        }
+      else {
+        let match = date.match(DATE_TIME_RE);
+        if (match) {
+          if (!match[1]) {
+            hasDate = false;
+            date = `0000-01-01T${date}`;
+          }
+          hasTime = !!match[2];
+          hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+          if (match[2] && +match[2] > 23) {
+            date = "";
+          } else {
+            offset = match[3] || null;
+            if (!offset && hasTime)
+              date += "Z";
+          }
+        } else {
+          date = "";
+        }
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
     }
   }
-  return str2.length;
-}
-function skipVoid(str2, ptr, banNewLines, banComments) {
-  let c;
-  while (true) {
-    while ((c = str2[ptr]) === " " || c === "\t" || !banNewLines && (c === `
-` || c === "\r" && str2[ptr + 1] === `
-`))
-      ptr++;
-    if (banComments || c !== "#")
-      break;
-    ptr = skipComment(str2, ptr);
-  }
-  return ptr;
-}
-function skipUntil(str2, ptr, sep, end, banNewLines = false) {
-  if (!end) {
-    ptr = indexOfNewline(str2, ptr);
-    return ptr < 0 ? str2.length : ptr;
-  }
-  for (let i = ptr;i < str2.length; i++) {
-    let c = str2[i];
-    if (c === "#") {
-      i = indexOfNewline(str2, i);
-    } else if (c === sep) {
-      return i + 1;
-    } else if (c === end || banNewLines && (c === `
-` || c === "\r" && str2[i + 1] === `
-`)) {
-      return i;
-    }
-  }
-  throw new TomlError("cannot find end of structure", {
-    toml: str2,
-    ptr
-  });
+  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" || 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 date = new TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
 }
 
 // node_modules/smol-toml/dist/extract.js
@@ -33824,71 +34414,263 @@ function skipUntil(str2, ptr, sep, end, banNewLines = false) {
  * 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(str2, startPtr, endPtr) {
-  let value = str2.slice(startPtr, endPtr);
-  let commentIdx = value.indexOf("#");
-  if (commentIdx > -1) {
-    skipComment(str2, commentIdx);
-    value = value.slice(0, commentIdx);
+function isDigit(char, base = 10) {
+  return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
+}
+function isEndOfValue(char, delim) {
+  return char === 32 || char === 9 || char === 10 || char === 13 || delim && (char === delim || char === 44) || char === 35;
+}
+function extractValue(ctx, end) {
+  let errPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p);
+  if (c === 91 || c === 123) {
+    ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
+    let value = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, false;
+  }
+  if (c === 43 || c === 45) {
+    return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
   }
-  return [value.trimEnd(), commentIdx];
+  if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) {
+    return parseDate(ctx, c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 2) === 58) {
+    return parseTime(ctx, c, end);
+  }
+  return parseNumber(ctx, ctx.p, c, 0, end);
 }
-function extractValue(str2, ptr, end, depth, integersAsBigInt) {
-  if (depth === 0) {
-    throw new TomlError("document contains excessively nested structures. aborting.", {
-      toml: str2,
-      ptr
-    });
+function parseNumber(ctx, startPtr, startChr, sign, endChr) {
+  let c = startChr;
+  let state = 0;
+  let hasUnderscores = false;
+  if (c === 105) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, (sign || 1) / 0;
+  }
+  if (c === 110) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, NaN;
+  }
+  if (c === 48) {
+    if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr))
+      return ctx.bi === true ? 0n : 0;
+    if (!sign) {
+      if (c === 120)
+        return parseIntegerBaseN(ctx, startPtr, 16, endChr);
+      else if (c === 98)
+        return parseIntegerBaseN(ctx, startPtr, 2, endChr);
+      else if (c === 111)
+        return parseIntegerBaseN(ctx, startPtr, 8, endChr);
+    }
+    if (c === 46)
+      state = 2;
+    else if (c === 101 || c === 69)
+      state = 4;
+    else
+      TomlError.x("illegal leading zero", ctx, startPtr);
+  } else if (!isDigit(c))
+    TomlError.x("invalid value", ctx, startPtr);
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (!state)
+      state = 1;
+    if (c === 95) {
+      if (!(state & 1))
+        TomlError.x("illegal underscore", ctx);
+      state += 11;
+      hasUnderscores = true;
+    } else if (state === 1 && c === 46)
+      state = 2;
+    else if ((state === 1 || state === 3) && (c === 101 || c === 69))
+      state = 4;
+    else if (state === 4 && (c === 43 || c === 45)) {
+      state = 6;
+    } else if (!isDigit(c))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (state > 9)
+      state -= 11;
+    else if (!(state & 1))
+      state++;
+  }
+  if (!state) {
+    let val = (startChr - 48) * (sign || 1);
+    return ctx.bi === true ? BigInt(val) : val;
+  }
+  if (!(state & 1))
+    TomlError.x("unfinished numeric value", ctx, startPtr);
+  let str2 = ctx.s.slice(startPtr, ctx.p);
+  if (hasUnderscores)
+    str2 = str2.replaceAll("_", "");
+  return state > 1 ? parseFloat(str2) : parseInteger(ctx, str2, 10, startPtr);
+}
+function parseIntegerBaseN(ctx, startPtr, base, endChr) {
+  let c, underscore = 1;
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (c === 95) {
+      if (underscore & 1)
+        TomlError.x("illegal underscore", ctx);
+      underscore = 3;
+    } else if (!isDigit(c, base))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (underscore & 1)
+      underscore--;
+  }
+  if (underscore & 1)
+    TomlError.x("unfinished numeric value", ctx);
+  let str2 = ctx.s.slice(startPtr + 2, ctx.p);
+  if (underscore)
+    str2 = str2.replaceAll("_", "");
+  return parseInteger(ctx, str2, base, startPtr);
+}
+function parseInteger(ctx, str2, base, startPtr) {
+  if (ctx.bi !== true)
+    int: {
+      let val = parseInt(str2, base);
+      if (!Number.isSafeInteger(val)) {
+        if (ctx.bi)
+          break int;
+        TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
+      }
+      return val;
+    }
+  return base === 10 ? BigInt(str2) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str2);
+}
+function parseDate(ctx, c, endChr) {
+  let startPtr = ctx.p++, unsafeSeparator;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++))) {
+    return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
+  }
+  ctx.p += 5;
+  if (!isDigit(ctx.s.charCodeAt(ctx.p++)))
+    TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
+  if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) {
+    let t = ctx.s.slice(startPtr, ctx.p);
+    return readDate(ctx, t, 3, false, startPtr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 3) !== 58)
+    TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
+  if (ctx.s.charCodeAt(ctx.p += 3) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  if (c = ctx.s.charCodeAt(ctx.p)) {
+    if (c === 90 || c === 122) {
+      let t = ctx.s.slice(startPtr, ++ctx.p);
+      return readDate(ctx, t, 1, unsafeSeparator, startPtr, "[+00:00]");
+    }
+    if (c === 43 || c === 45) {
+      let t = ctx.s.slice(startPtr, ctx.p += 6);
+      return readDate(ctx, t, 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
+    }
+  }
+  let t = ctx.s.slice(startPtr, ctx.p);
+  return readDate(ctx, t, 2, unsafeSeparator, startPtr);
+}
+function parseTime(ctx, c, endChr) {
+  let start = ctx.p;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(++ctx.p))) {
+    return parseNumber(ctx, --ctx.p, c, 0, endChr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 4) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  let t = ctx.s.slice(start, ctx.p);
+  return readDate(ctx, t, 4, false, start);
+}
+function readDate(ctx, str2, type, unsafeDelim, errPtr, temporalSuffix) {
+  if (ctx.ld) {
+    let date = new TomlDate(str2, type, unsafeDelim);
+    if (!date.isValid())
+      TomlError.x("invalid date", ctx, errPtr);
+    return date;
   }
-  let c = str2[ptr];
-  if (c === "[" || c === "{") {
-    let [value, endPtr] = c === "[" ? parseArray(str2, ptr, depth, integersAsBigInt) : parseInlineTable(str2, ptr, depth, integersAsBigInt);
-    if (end) {
-      endPtr = skipVoid(str2, endPtr);
-      if (str2[endPtr] === ",")
-        endPtr++;
-      else if (str2[endPtr] !== end) {
-        throw new TomlError("expected comma or end of structure", {
-          toml: str2,
-          ptr: endPtr
-        });
-      }
+  try {
+    if (temporalSuffix)
+      str2 += temporalSuffix;
+    switch (type) {
+      case 1:
+        return Temporal.ZonedDateTime.from(str2);
+      case 2:
+        return Temporal.PlainDateTime.from(str2);
+      case 3:
+        return Temporal.PlainDate.from(str2);
+      case 4:
+        return Temporal.PlainTime.from(str2);
     }
-    return [value, endPtr];
+  } catch (e) {
+    TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
   }
-  if (c === '"' || c === "'") {
-    let [parsed, endPtr] = parseString(str2, ptr);
-    if (end) {
-      endPtr = skipVoid(str2, endPtr);
-      if (str2[endPtr] && str2[endPtr] !== "," && str2[endPtr] !== end && str2[endPtr] !== `
-` && str2[endPtr] !== "\r") {
-        throw new TomlError("unexpected character encountered", {
-          toml: str2,
-          ptr: endPtr
-        });
-      }
-      if (str2[endPtr] === ",")
-        endPtr++;
+}
+
+// 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 skipComment(ctx) {
+  for (;ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in comments", ctx);
     }
-    return [parsed, endPtr];
-  }
-  let endPtr = skipUntil(str2, ptr, ",", end);
-  let slice = sliceAndTrimEndOf(str2, ptr, endPtr - (str2[endPtr - 1] === "," ? 1 : 0));
-  if (!slice[0]) {
-    throw new TomlError("incomplete key-value declaration: no value specified", {
-      toml: str2,
-      ptr
-    });
   }
-  if (end && slice[1] > -1) {
-    endPtr = skipVoid(str2, ptr + slice[1]);
-    if (str2[endPtr] === ",")
-      endPtr++;
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (ctx.p < ctx.s.length) {
+    while (ctx.p < ctx.s.length && ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
   }
-  return [
-    parseValue(slice[0], str2, ptr, integersAsBigInt),
-    endPtr
-  ];
 }
 
 // node_modules/smol-toml/dist/struct.js
@@ -33919,147 +34701,112 @@ function extractValue(str2, ptr, end, depth, integersAsBigInt) {
  * 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(str2, ptr, end = "=") {
-  let dot = ptr - 1;
+function parseKey(ctx, end = 61) {
+  let startPtr;
+  let state = 0;
   let parsed = [];
-  let endPtr = str2.indexOf(end, ptr);
-  if (endPtr < 0) {
-    throw new TomlError("incomplete key-value: cannot find end of key", {
-      toml: str2,
-      ptr
-    });
-  }
+  let sliceStart;
+  let c = ctx.s.charCodeAt(startPtr = ctx.p);
   do {
-    let c = str2[ptr = ++dot];
-    if (c !== " " && c !== "\t") {
-      if (c === '"' || c === "'") {
-        if (c === str2[ptr + 1] && c === str2[ptr + 2]) {
-          throw new TomlError("multiline strings are not allowed in keys", {
-            toml: str2,
-            ptr
-          });
-        }
-        let [part, eos] = parseString(str2, ptr);
-        dot = str2.indexOf(".", eos);
-        let strEnd = str2.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: str2,
-            ptr: ptr + dot + newLine
-          });
-        }
-        if (strEnd.trimStart()) {
-          throw new TomlError("found extra tokens after the string part", {
-            toml: str2,
-            ptr: eos
-          });
-        }
-        if (endPtr < eos) {
-          endPtr = str2.indexOf(end, eos);
-          if (endPtr < 0) {
-            throw new TomlError("incomplete key-value: cannot find end of key", {
-              toml: str2,
-              ptr
-            });
-          }
-        }
-        parsed.push(part);
-      } else {
-        dot = str2.indexOf(".", ptr);
-        let part = str2.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: str2,
-            ptr
-          });
-        }
-        parsed.push(part.trimEnd());
+    if (c === end) {
+      if (!state)
+        TomlError.x("unexpected end of key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      return ctx.p++, parsed;
+    } else if (c === 46) {
+      if (!state)
+        TomlError.x("illegal empty bare key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      state = 0;
+    } else if (!state && (c === 34 || c === 39)) {
+      if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2))
+        TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
+      parsed.push(parseString(ctx));
+      state = 2;
+      ctx.p--;
+    } else if (c === 32 || c === 9) {
+      if (state === 1) {
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+        state = 2;
       }
+    } else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) {
+      TomlError.x("illegal character in key", ctx);
+    } else if (!state) {
+      state = 1;
+      sliceStart = ctx.p;
     }
-  } while (dot + 1 && dot < endPtr);
-  return [parsed, skipVoid(str2, endPtr + 1, true, true)];
+  } while (c = ctx.s.charCodeAt(++ctx.p));
+  TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
 }
-function parseInlineTable(str2, ptr, depth, integersAsBigInt) {
-  let res = {};
+function parseInlineTable(ctx) {
+  let startPtr = ctx.p++;
+  let res = Object.create(null);
   let seen = new Set;
   let c;
-  ptr++;
-  while ((c = str2[ptr++]) !== "}" && c) {
-    if (c === ",") {
-      throw new TomlError("expected value, found comma", {
-        toml: str2,
-        ptr: ptr - 1
-      });
-    } else if (c === "#")
-      ptr = skipComment(str2, ptr);
-    else if (c !== " " && c !== "\t" && c !== `
-` && c !== "\r") {
-      let k;
-      let t = res;
-      let hasOwn = false;
-      let [key, keyEndPtr] = parseKey(str2, 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: str2,
-            ptr
-          });
-        }
-        if (!hasOwn && k === "__proto__") {
-          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
-        }
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let errPtr = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0;i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = Object.create(null);
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+      }
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor")) {
+        t = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
+        break;
       }
-      if (hasOwn) {
-        throw new TomlError("trying to redefine an already defined value", {
-          toml: str2,
-          ptr
-        });
+      if (!hasOwn && unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
       }
-      let [value, valueEndPtr] = extractValue(str2, keyEndPtr, "}", depth - 1, integersAsBigInt);
+    }
+    if (hasOwn) {
+      TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+    }
+    skipVoid(ctx, true, true);
+    let value = extractValue(ctx, 125);
+    if (t && typeof (t[k] = value) === "object")
       seen.add(value);
-      t[k] = value;
-      ptr = valueEndPtr;
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
     }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
   }
-  if (!c) {
-    throw new TomlError("unfinished table encountered", {
-      toml: str2,
-      ptr
-    });
-  }
-  return [res, ptr];
+  TomlError.x("unfinished table", ctx, startPtr);
 }
-function parseArray(str2, ptr, depth, integersAsBigInt) {
+function parseArray(ctx) {
+  let startPtr = ctx.p++;
   let res = [];
   let c;
-  ptr++;
-  while ((c = str2[ptr++]) !== "]" && c) {
-    if (c === ",") {
-      throw new TomlError("expected value, found comma", {
-        toml: str2,
-        ptr: ptr - 1
-      });
-    } else if (c === "#")
-      ptr = skipComment(str2, ptr);
-    else if (c !== " " && c !== "\t" && c !== `
-` && c !== "\r") {
-      let e = extractValue(str2, ptr - 1, "]", depth - 1, integersAsBigInt);
-      res.push(e[0]);
-      ptr = e[1];
-    }
-  }
-  if (!c) {
-    throw new TomlError("unfinished array encountered", {
-      toml: str2,
-      ptr
-    });
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(ctx, 93));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
   }
-  return [res, ptr];
+  TomlError.x("unfinished array", ctx, startPtr);
 }
 
 // node_modules/smol-toml/dist/parse.js
@@ -34090,7 +34837,7 @@ function parseArray(str2, ptr, depth, integersAsBigInt) {
  * 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, meta, type) {
+function peekTable(ctx, key, table, meta, type) {
   let t = table;
   let m = meta;
   let k;
@@ -34098,7 +34845,7 @@ function peekTable(key, table, meta, type) {
   let state;
   for (let i = 0;i < key.length; i++) {
     if (i) {
-      t = hasOwn ? t[k] : t[k] = {};
+      t = hasOwn ? t[k] : t[k] = Object.create(null);
       m = (state = m[k]).c;
       if (type === 0 && (state.t === 1 || state.t === 2)) {
         return null;
@@ -34114,7 +34861,10 @@ function peekTable(key, table, meta, type) {
       return null;
     }
     if (!hasOwn) {
-      if (k === "__proto__") {
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor"))
+        return false;
+      if (unsafe) {
         Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
         Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
       }
@@ -34122,7 +34872,7 @@ function peekTable(key, table, meta, type) {
         t: i < key.length - 1 && type === 2 ? 3 : type,
         d: false,
         i: 0,
-        c: {}
+        c: Object.create(null)
       };
     }
   }
@@ -34135,70 +34885,78 @@ function peekTable(key, table, meta, type) {
       state.d = true;
       t[k] = [];
     }
-    t[k].push(t = {});
-    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+    t[k].push(t = Object.create(null));
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: Object.create(null) };
   }
   if (state.d) {
     return null;
   }
   state.d = true;
   if (type === 1) {
-    t = hasOwn ? t[k] : t[k] = {};
+    t = hasOwn ? t[k] : t[k] = Object.create(null);
   } else if (type === 0 && hasOwn) {
     return null;
   }
   return [k, t, state.c];
 }
-function parse2(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
-  let res = {};
-  let meta = {};
+function validateTablePeek(ctx, peek, ptr) {
+  if (peek === null || ctx.uk === 2)
+    TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
+}
+function parse2(toml, options2 = {}) {
+  let ctx = {
+    s: toml,
+    p: 0,
+    d: options2.maxDepth ?? 1000,
+    bi: options2.integersAsBigInt ?? false,
+    ld: options2.useLegacyDate ?? true,
+    uk: options2.unsafeKeyBehaviour === "throw" ? 2 : options2.unsafeKeyBehaviour === "drop" ? 1 : 0
+  };
+  let res = Object.create(null);
+  let meta = Object.create(null);
+  let tmp;
+  let skipping = false;
   let tbl = res;
   let m = meta;
-  for (let ptr = skipVoid(toml, 0);ptr < toml.length; ) {
-    if (toml[ptr] === "[") {
-      let isTableArray = toml[++ptr] === "[";
-      let k = parseKey(toml, ptr += +isTableArray, "]");
+  if (toml.charCodeAt(0) === 65279)
+    ctx.p++;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      skipping = false;
+      let k = parseKey(ctx, 93);
       if (isTableArray) {
-        if (toml[k[1] - 1] !== "]") {
-          throw new TomlError("expected end of table declaration", {
-            toml,
-            ptr: k[1] - 1
-          });
+        if (toml.charCodeAt(ctx.p) !== 93) {
+          TomlError.x("expected end of table array declaration", ctx);
         }
-        k[1]++;
+        ctx.p++;
       }
-      let p = peekTable(k[0], res, meta, isTableArray ? 2 : 1);
+      let p = peekTable(ctx, k, res, meta, isTableArray ? 2 : 1);
       if (!p) {
-        throw new TomlError("trying to redefine an already defined table or value", {
-          toml,
-          ptr
-        });
+        validateTablePeek(ctx, p, tmp);
+        skipping = true;
+      } else {
+        m = p[2];
+        tbl = p[1];
       }
-      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);
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(ctx, k, tbl, m, 0);
+      if (!p && !skipping)
+        validateTablePeek(ctx, p, tmp);
+      skipVoid(ctx, true, true);
+      let v = extractValue(ctx, undefined);
+      if (p && !skipping)
+        p[1][p[0]] = v;
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) {
+      TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
+    }
+    skipVoid(ctx);
   }
   return res;
 }
@@ -34232,13 +34990,28 @@ function parse2(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 var BARE_KEY = /^[a-z0-9-_]+$/i;
+var HAS_WELLFORMED = !!"".isWellFormed;
 function extendedTypeOf(obj) {
   let type = typeof obj;
   if (type === "object") {
     if (Array.isArray(obj))
       return "array";
-    if (obj instanceof Date)
+    if (typeof obj.getUTCDate === "function" && obj instanceof Date)
       return "date";
+    if (globalThis.Temporal) {
+      if (obj.until) {
+        if (obj instanceof Temporal.ZonedDateTime)
+          return "temporal/tz+uc";
+        if (obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainDate)
+          return "temporal/uc";
+        if (obj instanceof Temporal.PlainTime || obj instanceof Temporal.Instant)
+          return "temporal";
+        if (obj instanceof Temporal.PlainYearMonth)
+          return "temporal/x";
+      } else if (obj.toPlainDate && obj instanceof Temporal.PlainMonthDay || obj.negated && obj instanceof Temporal.Duration) {
+        return "temporal/x";
+      }
+    }
   }
   return type;
 }
@@ -34249,44 +35022,67 @@ function isArrayOfTables(obj) {
   }
   return obj.length != 0;
 }
+function formatWellFormedStringUnchecked(s) {
+  return JSON.stringify(s).replaceAll("\x7F", "\\u007f");
+}
 function formatString(s) {
-  return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+  return formatWellFormedStringUnchecked(HAS_WELLFORMED ? s.toWellFormed() : s);
+}
+function formatKey(s) {
+  if (BARE_KEY.test(s))
+    return s;
+  if (HAS_WELLFORMED && !s.isWellFormed())
+    throw new RangeError("key contains illegal lone surrogates");
+  return formatWellFormedStringUnchecked(s);
 }
-function stringifyValue(val, type, depth, numberAsFloat) {
+function stringifyValue(val, type, depth, numberAsFloat, strictTemporal) {
   if (depth === 0) {
     throw new Error("Could not stringify the object: maximum object depth exceeded");
   }
-  if (type === "number") {
-    if (isNaN(val))
-      return "nan";
-    if (val === Infinity)
-      return "inf";
-    if (val === -Infinity)
-      return "-inf";
-    if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
-      return val.toFixed(1);
-    return val.toString();
-  }
-  if (type === "bigint" || type === "boolean") {
-    return val.toString();
-  }
-  if (type === "string") {
-    return formatString(val);
-  }
-  if (type === "date") {
-    if (isNaN(val.getTime())) {
-      throw new TypeError("cannot serialize invalid date");
-    }
-    return val.toISOString();
-  }
-  if (type === "object") {
-    return stringifyInlineTable(val, depth, numberAsFloat);
-  }
-  if (type === "array") {
-    return stringifyArray(val, depth, numberAsFloat);
+  switch (type) {
+    case "number":
+      if (isNaN(val))
+        return "nan";
+      if (val === Infinity)
+        return "inf";
+      if (val === -Infinity)
+        return "-inf";
+      if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
+        return val.toFixed(1);
+    case "bigint":
+    case "boolean":
+    case "temporal":
+      return val.toString();
+    case "string":
+      return formatString(val);
+    case "date":
+      if (isNaN(val.getTime()))
+        throw new TypeError("cannot serialize invalid date");
+      return val.toISOString();
+    case "object":
+      return stringifyInlineTable(val, depth, numberAsFloat, strictTemporal);
+    case "array":
+      return stringifyArray(val, depth, numberAsFloat, strictTemporal);
+    case "temporal/tz+uc":
+      if (strictTemporal) {
+        let tz = val.timeZoneId;
+        let tzc = tz.charCodeAt(0);
+        if (tzc !== 43 && tzc !== 45 && (tzc !== 85 && tzc !== 71 && tzc !== 90 && tzc !== 69 || tz !== "UTC" && tz !== "UCT" && tz !== "Universal" && tz !== "Zulu" && !tz.startsWith("GMT") && tz !== "Greenwich" && !tz.startsWith("Etc/"))) {
+          throw new TypeError("Temporal objects with an IANA timezone are not allowed in Temporal strict mode");
+        }
+      }
+    case "temporal/uc":
+      if (strictTemporal && val.calendarId !== "iso8601")
+        throw new TypeError("Temporal objects with a non-default calendar are not allowed in Temporal strict mode");
+      return val.toString({
+        calendarName: "never",
+        timeZoneName: "never"
+      });
+    case "temporal/x":
+      throw new TypeError("Unsupported " + val[Symbol.toStringTag]);
   }
 }
-function stringifyInlineTable(obj, depth, numberAsFloat) {
+function stringifyInlineTable(obj, depth, numberAsFloat, strictTemporal) {
   let keys = Object.keys(obj);
   if (keys.length === 0)
     return "{}";
@@ -34295,13 +35091,11 @@ function stringifyInlineTable(obj, depth, numberAsFloat) {
     let k = keys[i];
     if (i)
       res += ", ";
-    res += BARE_KEY.test(k) ? k : formatString(k);
-    res += " = ";
-    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+    res += formatKey(k) + " = " + stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat, strictTemporal);
   }
   return res + " }";
 }
-function stringifyArray(array, depth, numberAsFloat) {
+function stringifyArray(array, depth, numberAsFloat, strictTemporal) {
   if (array.length === 0)
     return "[]";
   let res = "[ ";
@@ -34311,11 +35105,11 @@ function stringifyArray(array, depth, numberAsFloat) {
     if (array[i] === null || array[i] === undefined) {
       throw new TypeError("arrays cannot contain null or undefined values");
     }
-    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat, strictTemporal);
   }
   return res + " ]";
 }
-function stringifyArrayTable(array, key, depth, numberAsFloat) {
+function stringifyArrayTable(array, key, depth, numberAsFloat, strictTemporal) {
   if (depth === 0) {
     throw new Error("Could not stringify the object: maximum object depth exceeded");
   }
@@ -34324,11 +35118,11 @@ function stringifyArrayTable(array, key, depth, numberAsFloat) {
     res += `${res && `
 `}[[${key}]]
 `;
-    res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+    res += stringifyTable(0, array[i], key, depth, numberAsFloat, strictTemporal);
   }
   return res;
 }
-function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat, strictTemporal) {
   if (depth === 0) {
     throw new Error("Could not stringify the object: maximum object depth exceeded");
   }
@@ -34342,18 +35136,18 @@ function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
       if (type === "symbol" || type === "function") {
         throw new TypeError(`cannot serialize values of type '${type}'`);
       }
-      let key = BARE_KEY.test(k) ? k : formatString(k);
+      let key = formatKey(k);
       if (type === "array" && isArrayOfTables(obj[k])) {
         tables += (tables && `
-`) + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+`) + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat, strictTemporal);
       } else if (type === "object") {
         let tblKey = prefix ? `${prefix}.${key}` : key;
         tables += (tables && `
-`) + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+`) + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat, strictTemporal);
       } else {
         preamble += key;
         preamble += " = ";
-        preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat, strictTemporal);
         preamble += `
 `;
       }
@@ -34365,11 +35159,11 @@ ${preamble}` : `[${tableKey}]`;
   return preamble && tables ? `${preamble}
 ${tables}` : preamble || tables;
 }
-function stringify(obj, { maxDepth = 1000, numbersAsFloat = false } = {}) {
+function stringify(obj, { maxDepth = 1000, numbersAsFloat = false, strictTemporal = false } = {}) {
   if (extendedTypeOf(obj) !== "object") {
     throw new TypeError("stringify can only be called with an object");
   }
-  let str2 = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+  let str2 = stringifyTable(0, obj, "", maxDepth, numbersAsFloat, strictTemporal);
   if (str2[str2.length - 1] !== `
 `)
     return str2 + `
@@ -34408,24 +35202,18 @@ function stringify(obj, { maxDepth = 1000, numbersAsFloat = false } = {}) {
 
 // src/adapters/codex.ts
 var OPENAI_MODELS = [
+  "gpt-6.1-sol",
+  "gpt-6.1-terra",
   "gpt-6-astra",
   "gpt-6-sol",
-  "gpt-6-luna",
-  "gpt-5.6-sol",
-  "gpt-5.6-terra",
-  "gpt-5.6-luna",
-  "gpt-5.5",
-  "gpt-5.4",
-  "gpt-5.4-mini",
-  "gpt-5.4-nano",
-  "gpt-5.3-codex-spark"
+  "gpt-6-luna"
 ];
 var DEFAULT_MODELS3 = {
-  default_model: "gpt-6-sol",
+  default_model: "gpt-6-astra",
   sentinel: "gpt-6-luna",
   oracle: "gpt-6-astra",
   architect: "gpt-6-astra",
-  keymaker: "gpt-6-luna"
+  keymaker: "gpt-6-sol"
 };
 var WRITABLE_AGENTS = ["keymaker"];
 var MANAGED_CODEX_KEYS = [
@@ -34458,13 +35246,13 @@ function defaultSection3() {
   return {
     provider: "openai",
     default_model: DEFAULT_MODELS3.default_model,
-    build_thinking: "high",
-    plan_thinking: "xhigh",
+    build_thinking: defaultThinking(DEFAULT_MODELS3.default_model, "session"),
+    plan_thinking: defaultThinking(DEFAULT_MODELS3.default_model, "plan"),
     agents: AGENT_NAMES.map((name) => ({
       template: name,
       name,
       model: DEFAULT_MODELS3[name],
-      thinking: { sentinel: "low", oracle: "high", architect: "xhigh", keymaker: "low" }[name]
+      thinking: defaultThinking(DEFAULT_MODELS3[name], name)
     }))
   };
 }
@@ -34472,7 +35260,7 @@ function modelsForProvider3(_provider) {
   return [...OPENAI_MODELS];
 }
 async function promptSection3(prompt, section) {
-  return promptForSimpleModels(prompt, section, modelsForProvider3(), "codex");
+  return promptForSimpleModels(prompt, section, modelsForProvider3(), "codex", defaultSection3());
 }
 function installAgents3(section, basePath) {
   const config = CodexConfigSchema.parse(section);
@@ -34519,7 +35307,7 @@ function mergeHarnessConfig3(section, basePath) {
     ...existing,
     model: config.default_model,
     ...effortField("model_reasoning_effort", codexThinking(config.build_thinking, "medium")),
-    ...effortField("plan_mode_reasoning_effort", codexThinking(config.plan_thinking, "high")),
+    ...effortField("plan_mode_reasoning_effort", codexThinking(config.plan_thinking)),
     sandbox_mode: "danger-full-access",
     approval_policy: "on-request",
     features: {
@@ -34643,117 +35431,15 @@ function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/adapters/cursor.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync5, rmdirSync as rmdirSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join10 } from "path";
-var CURSOR_MODELS = [
-  "composer-2.5",
-  "cursor-grok-4.5-high",
-  "gpt-5.6-luna-medium",
-  "gpt-5.6-terra-medium",
-  "gpt-5.6-sol-medium",
-  "claude-opus-4-8-high",
-  "claude-sonnet-5-high",
-  "kimi-k2.7-code",
-  "glm-5.2-high"
-];
-var DEFAULT_MODELS4 = {
-  sentinel: "composer-2.5",
-  oracle: "claude-opus-4-8-high",
-  architect: "gpt-5.6-sol-medium",
-  keymaker: "composer-2.5"
-};
-var cursorAdapter = {
-  name: "cursor",
-  configSchema: CursorConfigSchema,
-  defaultSection: defaultSection4,
-  modelsForProvider: modelsForProvider4,
-  promptSection: promptSection4,
-  installAgents: installAgents4,
-  mergeHarnessConfig: mergeHarnessConfig4,
-  fileList: fileList4,
-  remove: remove5
-};
-function defaultSection4() {
-  return {
-    agents: AGENT_NAMES.map((name) => ({ template: name, name, model: DEFAULT_MODELS4[name] }))
-  };
-}
-function modelsForProvider4(_provider) {
-  return CURSOR_MODELS;
-}
-async function promptSection4(prompt, section) {
-  const config = section;
-  const answers = await prompt.prompt(AGENT_NAMES.map((name) => ({
-    type: "list",
-    name,
-    message: `Select model for ${name}`,
-    choices: CURSOR_MODELS,
-    default: config.agents.find((agent) => agent.name === name)?.model ?? DEFAULT_MODELS4[name]
-  })));
-  return {
-    agents: AGENT_NAMES.map((name) => ({
-      template: name,
-      name,
-      model: answers[name] ?? DEFAULT_MODELS4[name]
-    }))
-  };
-}
-function installAgents4(section, basePath) {
-  const config = section;
-  const agentsDir = join10(basePath, ".cursor", "agents");
-  try {
-    mkdirSync5(agentsDir, { recursive: true });
-  } catch (err) {
-    throw new FileWriteError(agentsDir, err instanceof Error ? err.message : String(err));
-  }
-  rmSync5(join10(agentsDir, `${LEGACY_AGENT_NAME}.md`), { force: true });
-  for (const agent of config.agents) {
-    const template = readTemplate(agent.template);
-    const content = `---
-name: ${agent.name}
-description: ${template.description}
-model: ${agent.model}
----
-${template.body}`;
-    const agentPath = join10(agentsDir, `${agent.name}.md`);
-    writeFileSync6(agentPath, content);
-    console.log(`Created ${shortPath(agentPath)}`);
-  }
-}
-function mergeHarnessConfig4(_section, _basePath) {}
-function fileList4(basePath) {
-  return AGENT_NAMES.map((name) => {
-    const path = join10(basePath, ".cursor", "agents", `${name}.md`);
-    return { path, exists: existsSync6(path) };
-  });
-}
-function remove5(section, basePath) {
-  const config = section;
-  const agentsDir = join10(basePath, ".cursor", "agents");
-  try {
-    for (const agent of config.agents) {
-      rmSync5(join10(agentsDir, `${agent.name}.md`), { force: true });
-    }
-    rmSync5(join10(agentsDir, `${LEGACY_AGENT_NAME}.md`), { force: true });
-    if (existsSync6(agentsDir) && readdirSync5(agentsDir).length === 0) {
-      rmdirSync4(agentsDir);
-    }
-  } catch (err) {
-    throw new FileWriteError(agentsDir, err instanceof Error ? err.message : String(err));
-  }
-}
-
 // src/adapters/index.ts
 registerAdapter(claudeAdapter);
 registerAdapter(opencodeAdapter);
 registerAdapter(codexAdapter);
-registerAdapter(cursorAdapter);
 
 // src/atelier.ts
 var harnessChoices2 = Harness.join(", ");
 var program2 = new Command2;
-program2.name("atelier").description("Atelier CLI - configure Claude Code, OpenCode, Codex, and Cursor for spec-driven development").version("0.1.0");
+program2.name("atelier").description("Atelier CLI - configure Claude Code, OpenCode, and Codex for spec-driven development").version("0.1.0");
 program2.command("init", { isDefault: true }).description("Initialize atelier globally").option(`--harness <type>`, `Harness type (${harnessChoices2})`).option("--yes", "Non-interactive mode with defaults").action((options2) => {
   init(options2).catch(handleError);
 });