@s-berdia/opencode-router 0.0.0-stage → 1.0.1

package/dist/bin.js

@@ -0,0 +1,2951 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "util";
+
+// src/types.ts
+var PLAN_PROFILES = ["go", "go-plus", "free"];
+function isPlan(value) {
+  return typeof value === "string" && PLAN_PROFILES.includes(value);
+}
+var AGENT_ROLES = ["plan", "build", "general", "explore"];
+var INTERNAL_ROLES = ["small_model", "title", "summary", "compaction"];
+var ROLE_NAMES = [...AGENT_ROLES, ...INTERNAL_ROLES];
+function isAgentRole(value) {
+  return value !== void 0 && AGENT_ROLES.includes(value);
+}
+function isRoleName(value) {
+  return ROLE_NAMES.includes(value);
+}
+
+// src/catalog.ts
+import fs2 from "fs";
+
+// src/paths.ts
+import os from "os";
+import path from "path";
+import fs from "fs";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+var supportedEols = ["\n", "\r", "\r\n"];
+
+// node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "	";
+  }
+  const indentType = indentValue === "	" ? "	" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      ;
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      ;
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0; i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "	") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0; i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === "\n") {
+        return "\r\n";
+      }
+      return "\r";
+    } else if (ch === "\n") {
+      return "\n";
+    }
+  }
+  return options && options.eol || "\n";
+}
+function isEOL(text, offset) {
+  return "\r\n".indexOf(text.charAt(offset)) !== -1;
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: void 0 };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path5) {
+  if (!root) {
+    return void 0;
+  }
+  let node = root;
+  for (let segment of path5) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return void 0;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return void 0;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return void 0;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path5 = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = void 0;
+  let lastSegment = void 0;
+  while (path5.length > 0) {
+    lastSegment = path5.pop();
+    parent = findNodeAtLocation(root, path5);
+    if (parent === void 0 && value !== void 0) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === void 0) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== void 0) {
+      if (value === void 0) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === void 0) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === void 0 && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== void 0) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === void 0 ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1; i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var parseTree2 = parseTree;
+var findNodeAtLocation2 = findNodeAtLocation;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+function modify(text, path5, value, options) {
+  return setProperty(text, path5, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1; i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+
+// src/paths.ts
+function globalConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.length > 0 ? xdg : path.join(os.homedir(), ".config");
+  return path.join(base, "opencode");
+}
+function catalogCacheFile() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  const base = xdg && xdg.length > 0 ? xdg : path.join(os.homedir(), ".cache");
+  return path.join(base, "opencode", "models.json");
+}
+function globalRouterConfigFile() {
+  return path.join(globalConfigDir(), "router.config.json");
+}
+function projectRouterConfigFile(dir) {
+  return path.join(dir, ".opencode", "router.config.json");
+}
+function opencodeConfigCandidates(dir) {
+  return [path.join(dir, ".opencode", "opencode.json"), path.join(dir, "opencode.jsonc"), path.join(dir, "opencode.json")];
+}
+function globalOpencodeConfigCandidates() {
+  return [path.join(globalConfigDir(), "opencode.jsonc"), path.join(globalConfigDir(), "opencode.json")];
+}
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function fileExists(file) {
+  try {
+    return fs.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function pathExists(file) {
+  try {
+    fs.statSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "opencode.json",
+  "opencode.jsonc",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod"
+];
+function isProjectDir(dir) {
+  return PROJECT_MARKERS.some((marker) => pathExists(path.join(dir, marker)));
+}
+function parseJsonc(text) {
+  const errors = [];
+  const value = parse2(text, errors, { allowTrailingComma: true });
+  const first = errors[0];
+  if (first) return { error: `${printParseErrorCode(first.error)} at line ${lineAt(text, first.offset)}` };
+  return { value };
+}
+function lineAt(text, offset) {
+  return text.slice(0, offset).split("\n").length;
+}
+function readText(file) {
+  try {
+    return fs.readFileSync(file, "utf8").replace(/^/, "");
+  } catch {
+    return void 0;
+  }
+}
+function readJsonFile(file) {
+  const text = readText(file);
+  if (text === void 0 || text.trim() === "") return { status: "absent" };
+  const parsed = parseJsonc(text);
+  if (parsed.error !== void 0) return { status: "invalid", error: parsed.error };
+  return { status: "ok", value: parsed.value };
+}
+function readJson(file) {
+  const result = readJsonFile(file);
+  return result.status === "ok" ? result.value : void 0;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function writeTextAtomic(file, text) {
+  ensureDir(path.dirname(file));
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temp, text, "utf8");
+  try {
+    fs.renameSync(temp, file);
+  } catch {
+    fs.writeFileSync(file, text, "utf8");
+    fs.rmSync(temp, { force: true });
+  }
+}
+function writeJson(file, value) {
+  writeTextAtomic(file, JSON.stringify(value, null, 2) + "\n");
+}
+function hasPath(text, keyPath) {
+  const tree = parseTree2(text);
+  return tree !== void 0 && findNodeAtLocation2(tree, keyPath) !== void 0;
+}
+function editJsonFile(file, edits, initialText = "{}\n") {
+  const current = readJsonFile(file);
+  if (current.status === "invalid") {
+    throw new Error(`${file} has a JSON error (${current.error}). Fix the file and run the command again. The file was not changed.`);
+  }
+  if (current.status === "ok" && !isPlainObject(current.value)) {
+    throw new Error(`${file} does not contain a JSON object. The file was not changed.`);
+  }
+  const created = !fileExists(file);
+  let text = current.status === "ok" ? readText(file) ?? initialText : initialText;
+  const formattingOptions = {
+    insertSpaces: !/^\t/m.test(text),
+    tabSize: 2,
+    eol: text.includes("\r\n") ? "\r\n" : "\n"
+  };
+  for (const edit of edits) {
+    if (edit.value === void 0 && !hasPath(text, edit.path)) continue;
+    text = applyEdits(text, modify(text, edit.path, edit.value, { formattingOptions }));
+  }
+  writeTextAtomic(file, text);
+  return { created };
+}
+
+// src/catalog.ts
+var ROUTED_PROVIDERS = ["opencode-go", "opencode"];
+function readCatalogFile(file = catalogCacheFile()) {
+  try {
+    const raw = fs2.readFileSync(file, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function toNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function mapTiers(raw) {
+  const tiers = raw.cost?.tiers;
+  if (!Array.isArray(tiers)) return [];
+  const out = [];
+  for (const t of tiers) {
+    const size = t?.tier?.size;
+    if (typeof size !== "number") continue;
+    out.push({
+      size,
+      input: toNumber(t.input),
+      output: toNumber(t.output),
+      cacheRead: t.cache_read !== void 0 ? toNumber(t.cache_read) : void 0,
+      cacheWrite: t.cache_write !== void 0 ? toNumber(t.cache_write) : void 0
+    });
+  }
+  return out.sort((a, b) => a.size - b.size);
+}
+function isFreeModel(cost, tiers) {
+  const baseFree = cost.input === 0 && cost.output === 0;
+  const tiersFree = tiers.every((t) => t.input === 0 && t.output === 0);
+  return baseFree && tiersFree;
+}
+function mapModel(providerID, raw) {
+  const cost = {
+    input: toNumber(raw.cost?.input),
+    output: toNumber(raw.cost?.output),
+    cacheRead: raw.cost?.cache_read !== void 0 ? toNumber(raw.cost.cache_read) : void 0,
+    cacheWrite: raw.cost?.cache_write !== void 0 ? toNumber(raw.cost.cache_write) : void 0
+  };
+  const tiers = mapTiers(raw);
+  const rawInputs = raw.modalities?.input;
+  const inputModalities = Array.isArray(rawInputs) ? rawInputs.map(String) : ["text"];
+  return {
+    providerID,
+    modelID: raw.id,
+    id: `${providerID}/${raw.id}`,
+    name: raw.name ?? raw.id,
+    family: raw.family,
+    releaseDate: raw.release_date ?? raw.last_updated,
+    reasoning: raw.reasoning === true,
+    toolCall: raw.tool_call === true,
+    attachment: raw.attachment === true,
+    openWeights: raw.open_weights === true,
+    limit: {
+      context: toNumber(raw.limit?.context),
+      input: raw.limit?.input !== void 0 ? toNumber(raw.limit.input) : void 0,
+      output: toNumber(raw.limit?.output)
+    },
+    cost,
+    tiers,
+    inputModalities,
+    free: isFreeModel(cost, tiers)
+  };
+}
+function loadCatalog(file = catalogCacheFile()) {
+  const raw = readCatalogFile(file);
+  if (!raw) return [];
+  const out = [];
+  for (const providerID of ROUTED_PROVIDERS) {
+    const provider = raw[providerID];
+    if (!provider?.models) continue;
+    for (const rawModel of Object.values(provider.models)) {
+      if (rawModel && typeof rawModel.id === "string") out.push(mapModel(providerID, rawModel));
+    }
+  }
+  return out;
+}
+function catalogMeta(file = catalogCacheFile()) {
+  let mtime = null;
+  try {
+    mtime = fs2.statSync(file).mtime.toISOString();
+  } catch {
+    mtime = null;
+  }
+  return { path: file, mtime, total: loadCatalog(file).length };
+}
+
+// src/scoring.ts
+var FIVE_HOUR_SHARE = 0.2;
+var FREE_ROLE_BONUS = 6;
+var DEFAULT_UNVETTED_PENALTY = 8;
+function modelClass(model) {
+  if (model.free) return "free";
+  if (model.providerID === "opencode-go") return "subscription";
+  return "paid";
+}
+function emptyFeedScores() {
+  return { byFamily: /* @__PURE__ */ new Map(), byId: /* @__PURE__ */ new Map() };
+}
+function clamp(value, min = 0, max = 100) {
+  return Math.max(min, Math.min(max, value));
+}
+function resolveMetric(model, table, feeds, metric) {
+  const override = table.models[model.id]?.[metric];
+  if (override !== void 0) return { value: clamp(override), source: "override" };
+  const fromId = feeds.byId.get(model.id.toLowerCase())?.[metric];
+  if (fromId !== void 0) return { value: clamp(fromId), source: "feed" };
+  const fromFamily = model.family ? feeds.byFamily.get(model.family.toLowerCase())?.[metric] : void 0;
+  if (fromFamily !== void 0) return { value: clamp(fromFamily), source: "feed" };
+  const id = model.modelID.toLowerCase();
+  const pattern = table.heuristics.patterns.find((p) => id.includes(p.match.toLowerCase()));
+  if (pattern) return { value: clamp(pattern[metric]), source: "heuristic" };
+  const fallback = metric === "intelligence" ? table.heuristics.defaultIntelligence : table.heuristics.defaultSpeed;
+  return { value: clamp(fallback), source: "default" };
+}
+function resolveIntelligence(model, table, feeds) {
+  return resolveMetric(model, table, feeds, "intelligence");
+}
+function resolveSpeed(model, table, feeds) {
+  return resolveMetric(model, table, feeds, "speed");
+}
+function blendedCost(model, cfg) {
+  const { input, output, cacheRead } = cfg.blend;
+  const c = model.cost;
+  return c.input * input + c.output * output + (c.cacheRead ?? 0) * cacheRead;
+}
+function monthlyCapFor(modelId, table, plan) {
+  if (plan === "free") return null;
+  const entry = table.monthlyCaps[modelId];
+  if (!entry) return null;
+  return plan === "go-plus" ? entry.goPlus : entry.go;
+}
+function logScale(value, min, max) {
+  const lo = Math.log10(Math.max(min, 1e-6));
+  const hi = Math.log10(Math.max(max, min * 1.001));
+  const v = Math.log10(Math.max(value, 1e-6));
+  return clamp((v - lo) / (hi - lo) * 100);
+}
+function resolveEndurance(model, table, cfg) {
+  const bc = blendedCost(model, cfg);
+  if (model.free) {
+    return { score: 100, source: "cap", tokensPer5h: null, monthlyCapUSD: null, blendedCost: bc };
+  }
+  const cap = monthlyCapFor(model.id, table, cfg.plan);
+  if (cap === null) {
+    return { score: 100, source: "cap", tokensPer5h: null, monthlyCapUSD: null, blendedCost: bc };
+  }
+  if (bc <= 0) {
+    return { score: 100, source: "cap", tokensPer5h: null, monthlyCapUSD: cap, blendedCost: bc };
+  }
+  const tokensPer5h = cap * FIVE_HOUR_SHARE / bc;
+  const score = logScale(tokensPer5h, cfg.enduranceScale.minTokensPer5h, cfg.enduranceScale.maxTokensPer5h);
+  return { score, source: "cap", tokensPer5h, monthlyCapUSD: cap, blendedCost: bc };
+}
+function scoreModel(model, role, table, cfg, feeds) {
+  const intel = resolveIntelligence(model, table, feeds);
+  const speed = resolveSpeed(model, table, feeds);
+  const end = resolveEndurance(model, table, cfg);
+  const w = role.weights;
+  let score = w.intelligence * intel.value + w.speed * speed.value + w.endurance * end.score;
+  const klass = modelClass(model);
+  if (role.preferFree) {
+    if (klass === "free") score += FREE_ROLE_BONUS;
+  } else {
+    score += table.classPreference?.[cfg.plan]?.[klass] ?? 0;
+  }
+  if (table.models[model.id] === void 0) score -= table.heuristics.unvettedPenalty ?? DEFAULT_UNVETTED_PENALTY;
+  score = clamp(score);
+  return {
+    model,
+    intelligence: intel.value,
+    speed: speed.value,
+    endurance: end.score,
+    score,
+    intelligenceSource: intel.source,
+    speedSource: speed.source,
+    enduranceSource: end.source,
+    blendedCost: end.blendedCost,
+    tokensPer5h: end.tokensPer5h,
+    monthlyCapUSD: end.monthlyCapUSD
+  };
+}
+
+// src/feeds.ts
+async function loadFeedScores(cfg) {
+  const feeds = emptyFeedScores();
+  if (!cfg.feeds?.enabled || !cfg.feeds.url) return { feeds, note: null };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), cfg.feeds.timeoutMs ?? 5e3);
+  try {
+    const res = await fetch(cfg.feeds.url, { signal: controller.signal });
+    if (!res.ok) return { feeds, note: `feed ${cfg.feeds.url} returned ${res.status}; using table + heuristics` };
+    const payload = await res.json();
+    const records = Array.isArray(payload.models) ? payload.models : [];
+    for (const rec of records) {
+      if (!rec) continue;
+      const value = {};
+      if (typeof rec.intelligence === "number") value.intelligence = rec.intelligence;
+      if (typeof rec.speed === "number") value.speed = rec.speed;
+      if (value.intelligence === void 0 && value.speed === void 0) continue;
+      if (rec.id) feeds.byId.set(rec.id.toLowerCase(), value);
+      if (rec.family) feeds.byFamily.set(rec.family.toLowerCase(), value);
+    }
+    return { feeds, note: `feed ${cfg.feeds.url}: ${records.length} records` };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { feeds, note: `feed unavailable (${message}); using table + heuristics` };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// src/config.ts
+var DEFAULT_SOFT_THRESHOLD = 0.85;
+var DEFAULT_CHAIN_DEPTH = 4;
+function loadUserConfig(projectDir) {
+  const notes = [];
+  const global = readUserConfigFile(globalRouterConfigFile(), notes);
+  const project = projectDir ? readUserConfigFile(projectRouterConfigFile(projectDir), notes) : {};
+  return { config: mergeUserConfig(global, project), notes };
+}
+function readUserConfigFile(file, notes) {
+  const result = readJsonFile(file);
+  if (result.status === "absent") return {};
+  if (result.status === "invalid") {
+    notes.push(`${file} has a JSON error (${result.error}); it was ignored.`);
+    return {};
+  }
+  if (!isPlainObject(result.value)) {
+    notes.push(`${file} does not contain a JSON object; it was ignored.`);
+    return {};
+  }
+  return sanitizeUserConfig(result.value, file, notes);
+}
+function sanitizeUserConfig(raw, file, notes) {
+  const config = { ...raw };
+  const drop = (key, rule) => {
+    notes.push(`${file}: "${key}" ${rule}, not ${JSON.stringify(config[key])}; it was ignored.`);
+    delete config[key];
+  };
+  if (config.plan !== void 0 && !isPlan(config.plan)) drop("plan", `must be one of ${PLAN_PROFILES.join(" | ")}`);
+  const depth = config.chainDepth;
+  if (depth !== void 0 && !(typeof depth === "number" && Number.isInteger(depth) && depth >= 1)) {
+    drop("chainDepth", "must be a whole number of 1 or more");
+  }
+  const threshold = config.softThreshold;
+  if (threshold !== void 0 && !(typeof threshold === "number" && threshold > 0 && threshold <= 1)) {
+    drop("softThreshold", "must be a number above 0 and at most 1");
+  }
+  for (const key of ["denyModels", "allowModels"]) {
+    const list = config[key];
+    if (list !== void 0 && !(Array.isArray(list) && list.every((item) => typeof item === "string"))) {
+      drop(key, "must be a list of model IDs");
+    }
+  }
+  for (const key of ["roles", "weights"]) {
+    const perRole = config[key];
+    if (perRole === void 0) continue;
+    if (!isPlainObject(perRole)) {
+      drop(key, "must be an object keyed by role");
+      continue;
+    }
+    const known = {};
+    for (const [role, value] of Object.entries(perRole)) {
+      if (isRoleName(role)) known[role] = value;
+      else notes.push(`${file}: unknown role "${role}" in "${key}"; it was ignored.`);
+    }
+    config[key] = known;
+  }
+  return config;
+}
+function mergeByKey(base = {}, override = {}) {
+  const out = { ...base };
+  for (const key of Object.keys(override)) {
+    out[key] = { ...base[key], ...override[key] };
+  }
+  return out;
+}
+function mergeUserConfig(base, override) {
+  return {
+    ...base,
+    ...override,
+    blend: { ...base.blend, ...override.blend },
+    enduranceScale: { ...base.enduranceScale, ...override.enduranceScale },
+    weights: mergeByKey(base.weights, override.weights),
+    roles: mergeByKey(base.roles, override.roles),
+    scores: mergeByKey(base.scores, override.scores),
+    privacy: { ...base.privacy, ...override.privacy },
+    feeds: { ...base.feeds, ...override.feeds },
+    denyModels: override.denyModels ?? base.denyModels,
+    allowModels: override.allowModels ?? base.allowModels
+  };
+}
+function detectPlan(catalog) {
+  const hasGo = catalog.some((m) => m.providerID === "opencode-go" && !m.free);
+  if (hasGo) return "go";
+  const hasFree = catalog.some((m) => m.free);
+  if (hasFree) return "free";
+  return "go";
+}
+function resolveConfig(user, catalog, cliPlan) {
+  const plan = cliPlan ?? user.plan ?? detectPlan(catalog);
+  return {
+    ...user,
+    plan,
+    chainDepth: user.chainDepth ?? DEFAULT_CHAIN_DEPTH,
+    softThreshold: user.softThreshold ?? DEFAULT_SOFT_THRESHOLD,
+    blend: {
+      input: user.blend?.input ?? 0.75,
+      output: user.blend?.output ?? 0.25,
+      cacheRead: user.blend?.cacheRead ?? 0.1
+    },
+    enduranceScale: {
+      minTokensPer5h: user.enduranceScale?.minTokensPer5h ?? 0.25,
+      maxTokensPer5h: user.enduranceScale?.maxTokensPer5h ?? 40
+    },
+    denyModels: user.denyModels ?? [],
+    allowModels: user.allowModels ?? [],
+    privacy: { freeModelsOk: user.privacy?.freeModelsOk ?? true }
+  };
+}
+
+// model-scores.json
+var model_scores_default = {
+  $comment: "Committed default score table for opencode-router. Safe to edit; user config (router.config.json) overrides these values.",
+  version: 1,
+  updated: "2026-10-18",
+  roles: {
+    plan: {
+      weights: { intelligence: 0.65, speed: 0.1, endurance: 0.25 },
+      variant: "high",
+      chainDepth: 4,
+      requires: { toolCall: true, minContext: 2e5 },
+      diversifyFamily: true
+    },
+    build: {
+      weights: { intelligence: 0.4, speed: 0.25, endurance: 0.35 },
+      variant: "medium",
+      chainDepth: 4,
+      requires: { toolCall: true, minContext: 2e5 },
+      diversifyFamily: true
+    },
+    general: {
+      weights: { intelligence: 0.35, speed: 0.25, endurance: 0.4 },
+      variant: "medium",
+      chainDepth: 4,
+      requires: { toolCall: true, minContext: 2e5 },
+      diversifyFamily: true
+    },
+    explore: {
+      weights: { intelligence: 0.15, speed: 0.45, endurance: 0.4 },
+      variant: "low",
+      chainDepth: 4,
+      requires: { toolCall: true, minContext: 128e3 },
+      preferFree: true
+    },
+    small_model: {
+      weights: { intelligence: 0.05, speed: 0.55, endurance: 0.4 },
+      variant: "low",
+      chainDepth: 3,
+      requires: { toolCall: true, minContext: 1e5 },
+      preferFree: true
+    },
+    title: {
+      weights: { intelligence: 0.05, speed: 0.55, endurance: 0.4 },
+      variant: "low",
+      chainDepth: 3,
+      requires: { toolCall: true, minContext: 1e5 },
+      preferFree: true
+    },
+    summary: {
+      weights: { intelligence: 0.3, speed: 0.3, endurance: 0.4 },
+      variant: "low",
+      chainDepth: 3,
+      requires: { toolCall: true, minContext: 2e5 },
+      preferFree: true
+    },
+    compaction: {
+      weights: { intelligence: 0.3, speed: 0.2, endurance: 0.5 },
+      variant: "none",
+      chainDepth: 3,
+      requires: { toolCall: true, minContext: 1e6 },
+      preferFree: true
+    }
+  },
+  models: {
+    "opencode-go/gemini-4-argon-contributor": { intelligence: 95, speed: 25 },
+    "opencode-go/kimi-k3": { intelligence: 93, speed: 20 },
+    "opencode-go/qwen3.8-max": { intelligence: 92, speed: 35 },
+    "opencode-go/grok-4.7": { intelligence: 91, speed: 40 },
+    "opencode-go/deepseek-v4-pro": { intelligence: 90, speed: 30 },
+    "opencode-go/glm-5.3": { intelligence: 90, speed: 45 },
+    "opencode-go/glm-5.2": { intelligence: 88, speed: 45 },
+    "opencode-go/step-5-preview": { intelligence: 87, speed: 40 },
+    "opencode-go/qwen3.7-plus": { intelligence: 86, speed: 45 },
+    "opencode-go/kimi-k2.7-code": { intelligence: 85, speed: 50 },
+    "opencode-go/gpt-6-luna": { intelligence: 85, speed: 55 },
+    "opencode-go/gpt-5.6-luna": { intelligence: 84, speed: 55 },
+    "opencode-go/minimax-m3": { intelligence: 84, speed: 55 },
+    "opencode-go/hy4-preview": { intelligence: 82, speed: 40 },
+    "opencode-go/qwen3.8-flash": { intelligence: 80, speed: 70 },
+    "opencode-go/deepseek-v4.1-flash": { intelligence: 80, speed: 65 },
+    "opencode-go/space-bunny": { intelligence: 79, speed: 60 },
+    "opencode-go/glm-5.3-flash": { intelligence: 78, speed: 72 },
+    "opencode-go/mimo-v2.6-pro": { intelligence: 78, speed: 58 },
+    "opencode-go/muse-spark-1.3-contributor": { intelligence: 77, speed: 62 },
+    "opencode-go/mimo-v2.5-pro": { intelligence: 76, speed: 58 },
+    "opencode-go/longcat-2.0": { intelligence: 76, speed: 55 },
+    "opencode-go/muse-spark-1.2-contributor": { intelligence: 75, speed: 62 },
+    "opencode-go/longcat-2.5-preview-free": { intelligence: 75, speed: 60 },
+    "opencode-go/hy3": { intelligence: 74, speed: 60 },
+    "opencode-go/claude-haiku-5-5": { intelligence: 74, speed: 78 },
+    "opencode-go/mimo-v2.6-flash": { intelligence: 73, speed: 75 },
+    "opencode-go/mimo-v2.5": { intelligence: 72, speed: 72 },
+    "opencode-go/beam-free": { intelligence: 72, speed: 80 },
+    "opencode/deepseek-v4.1-flash-free": { intelligence: 80, speed: 65 },
+    "opencode/space-bunny-free": { intelligence: 79, speed: 60 },
+    "opencode/glm-5.3-flash-free": { intelligence: 78, speed: 72 },
+    "opencode/longcat-2.5-preview-free": { intelligence: 75, speed: 60 },
+    "opencode/nemotron-3-ultra-free": { intelligence: 74, speed: 62 },
+    "opencode/mimo-v2.6-flash-free": { intelligence: 73, speed: 75 },
+    "opencode/beam-free": { intelligence: 72, speed: 80 },
+    "opencode/nemotron-3.5-super-vl-free": { intelligence: 72, speed: 70 },
+    "opencode/nemotron-3.5-lightning-free": { intelligence: 68, speed: 88 },
+    "opencode/big-pickle": { intelligence: 66, speed: 70 }
+  },
+  heuristics: {
+    patterns: [
+      { match: "gemini-4-argon", intelligence: 95, speed: 25 },
+      { match: "kimi-k3", intelligence: 93, speed: 20 },
+      { match: "qwen3.8-max", intelligence: 92, speed: 35 },
+      { match: "opus", intelligence: 94, speed: 30 },
+      { match: "grok", intelligence: 91, speed: 40 },
+      { match: "deepseek-v4-pro", intelligence: 90, speed: 30 },
+      { match: "sonnet", intelligence: 88, speed: 50 },
+      { match: "step-5", intelligence: 87, speed: 40 },
+      { match: "gpt-6", intelligence: 85, speed: 55 },
+      { match: "kimi", intelligence: 85, speed: 45 },
+      { match: "gpt-5", intelligence: 84, speed: 55 },
+      { match: "minimax", intelligence: 84, speed: 55 },
+      { match: "hy4", intelligence: 82, speed: 40 },
+      { match: "claude", intelligence: 82, speed: 60 },
+      { match: "gpt", intelligence: 82, speed: 55 },
+      { match: "qwen", intelligence: 80, speed: 55 },
+      { match: "deepseek", intelligence: 80, speed: 65 },
+      { match: "glm", intelligence: 80, speed: 55 },
+      { match: "space-bunny", intelligence: 79, speed: 60 },
+      { match: "muse", intelligence: 77, speed: 62 },
+      { match: "longcat", intelligence: 76, speed: 58 },
+      { match: "hy3", intelligence: 74, speed: 60 },
+      { match: "haiku", intelligence: 74, speed: 78 },
+      { match: "mimo", intelligence: 74, speed: 72 },
+      { match: "nemotron", intelligence: 72, speed: 75 },
+      { match: "big-pickle", intelligence: 66, speed: 70 },
+      { match: "-max", intelligence: 90, speed: 35 },
+      { match: "-pro", intelligence: 88, speed: 42 },
+      { match: "-flash", intelligence: 78, speed: 74 },
+      { match: "-mini", intelligence: 74, speed: 80 },
+      { match: "-lite", intelligence: 70, speed: 84 },
+      { match: "-free", intelligence: 72, speed: 70 },
+      { match: "contributor", intelligence: 74, speed: 62 }
+    ],
+    defaultIntelligence: 60,
+    defaultSpeed: 60,
+    unvettedPenalty: 8
+  },
+  classPreference: {
+    go: { subscription: 0, paid: -6, free: -12 },
+    "go-plus": { subscription: 0, paid: -6, free: -12 },
+    free: { subscription: 0, paid: 0, free: 0 }
+  },
+  monthlyCaps: {
+    "opencode-go/longcat-2.5-preview-free": { go: null, goPlus: null },
+    "opencode-go/beam-free": { go: null, goPlus: null },
+    "opencode-go/deepseek-v4.1-flash": { go: 80, goPlus: 160 },
+    "opencode-go/longcat-2.0": { go: 60, goPlus: 240 },
+    "opencode-go/hy3": { go: 60, goPlus: 240 },
+    "opencode-go/step-5-preview": { go: 60, goPlus: 240 },
+    "opencode-go/gemini-4-argon-contributor": { go: 60, goPlus: 240 },
+    "opencode-go/glm-5.3-flash": { go: 60, goPlus: 180 },
+    "opencode-go/glm-5.2": { go: 60, goPlus: 180 },
+    "opencode-go/kimi-k2.7-code": { go: 60, goPlus: 180 },
+    "opencode-go/minimax-m3": { go: 60, goPlus: 180 },
+    "opencode-go/qwen3.7-plus": { go: 60, goPlus: 180 },
+    "opencode-go/mimo-v2.6-flash": { go: 60, goPlus: 120 },
+    "opencode-go/mimo-v2.5": { go: 60, goPlus: 120 },
+    "opencode-go/muse-spark-1.3-contributor": { go: 60, goPlus: 120 },
+    "opencode-go/muse-spark-1.2-contributor": { go: 60, goPlus: 120 },
+    "opencode-go/hy4-preview": { go: 30, goPlus: 120 },
+    "opencode-go/space-bunny": { go: 30, goPlus: 120 },
+    "opencode-go/qwen3.8-flash": { go: 30, goPlus: 90 },
+    "opencode-go/glm-5.3": { go: 15, goPlus: 120 },
+    "opencode-go/kimi-k3": { go: 15, goPlus: 60 },
+    "opencode-go/mimo-v2.6-pro": { go: 15, goPlus: 60 },
+    "opencode-go/mimo-v2.5-pro": { go: 15, goPlus: 60 },
+    "opencode-go/qwen3.8-max": { go: 15, goPlus: 60 },
+    "opencode-go/deepseek-v4-pro": { go: 15, goPlus: 60 },
+    "opencode-go/grok-4.7": { go: 15, goPlus: 60 },
+    "opencode-go/gpt-6-luna": { go: 15, goPlus: 60 },
+    "opencode-go/gpt-5.6-luna": { go: 15, goPlus: 60 },
+    "opencode-go/claude-haiku-5-5": { go: 15, goPlus: 60 }
+  }
+};
+
+// src/score-table.ts
+var DEFAULT_TABLE = model_scores_default;
+function loadDefaultTable() {
+  return structuredClone(DEFAULT_TABLE);
+}
+function mergeRole(base, override) {
+  return {
+    ...base,
+    ...override,
+    weights: { ...base.weights, ...override.weights },
+    requires: { ...base.requires, ...override.requires }
+  };
+}
+function resolveTable(user) {
+  const table = loadDefaultTable();
+  for (const role of ROLE_NAMES) {
+    let spec = table.roles[role];
+    if (!spec) continue;
+    if (user.chainDepth !== void 0) spec = { ...spec, chainDepth: user.chainDepth };
+    const override = user.roles?.[role];
+    if (override) spec = mergeRole(spec, override);
+    const weights = user.weights?.[role];
+    if (weights) spec = { ...spec, weights: { ...spec.weights, ...weights } };
+    table.roles[role] = spec;
+  }
+  for (const [id, score] of Object.entries(user.scores ?? {})) {
+    table.models[id] = { ...table.models[id], ...score };
+  }
+  return table;
+}
+
+// src/rank.ts
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function matchesAny(id, globs) {
+  return globs.some((g) => globToRegex(g).test(id));
+}
+function providerAllowed(model, plan) {
+  if (plan === "free") {
+    return model.providerID === "opencode" && model.free;
+  }
+  if (plan === "go" || plan === "go-plus") {
+    if (model.providerID === "opencode-go") return true;
+    if (model.providerID === "opencode") return model.free;
+    return false;
+  }
+  return false;
+}
+function requirementOk(model, role) {
+  const req = role.requires;
+  if (!req) return true;
+  if (req.toolCall && !model.toolCall) return false;
+  if (req.reasoning && !model.reasoning) return false;
+  if (req.minContext !== void 0 && model.limit.context < req.minContext) return false;
+  if (req.minOutput !== void 0 && model.limit.output < req.minOutput) return false;
+  if (req.inputModalities && req.inputModalities.length > 0) {
+    const ok = req.inputModalities.every((m) => model.inputModalities.includes(m));
+    if (!ok) return false;
+  }
+  return true;
+}
+function eligibleModels(catalog, role, table, cfg) {
+  return catalog.filter((model) => {
+    if (!providerAllowed(model, cfg.plan)) return false;
+    if (!requirementOk(model, role)) return false;
+    if ((cfg.plan === "go" || cfg.plan === "go-plus") && !model.free && !table.monthlyCaps[model.id]) return false;
+    if (cfg.denyModels.length > 0 && matchesAny(model.id, cfg.denyModels)) return false;
+    if (cfg.allowModels.length > 0 && !matchesAny(model.id, cfg.allowModels)) return false;
+    if (!cfg.privacy.freeModelsOk && model.free && !role.preferFree) return false;
+    return true;
+  });
+}
+function rankRole(catalog, roleName, table, cfg, feeds) {
+  const role = table.roles[roleName];
+  if (!role) return [];
+  const scored = eligibleModels(catalog, role, table, cfg).map((model) => scoreModel(model, role, table, cfg, feeds)).sort((a, b) => b.score - a.score || a.blendedCost - b.blendedCost);
+  const depth = role.chainDepth ?? cfg.chainDepth;
+  const diversify = role.diversifyFamily ?? false;
+  const chosen = [];
+  const seenFamilies = /* @__PURE__ */ new Set();
+  for (const entry of scored) {
+    if (chosen.length >= depth) break;
+    const family = (entry.model.family ?? entry.model.modelID).toLowerCase();
+    if (diversify && seenFamilies.has(family) && chosen.length < depth) continue;
+    chosen.push(entry);
+    seenFamilies.add(family);
+  }
+  if (chosen.length < depth) {
+    for (const entry of scored) {
+      if (chosen.length >= depth) break;
+      if (chosen.includes(entry)) continue;
+      chosen.push(entry);
+    }
+  }
+  return chosen.map((entry, index) => ({
+    rank: index + 1,
+    providerID: entry.model.providerID,
+    modelID: entry.model.modelID,
+    id: entry.model.id,
+    variant: role.variant,
+    score: round(entry.score),
+    intelligence: round(entry.intelligence),
+    speed: round(entry.speed),
+    endurance: round(entry.endurance),
+    tokensPer5h: entry.tokensPer5h === null ? null : round(entry.tokensPer5h, 3),
+    monthlyCapUSD: entry.monthlyCapUSD,
+    sources: {
+      intelligence: entry.intelligenceSource,
+      speed: entry.speedSource,
+      endurance: entry.enduranceSource
+    },
+    class: modelClass(entry.model)
+  }));
+}
+function round(value, digits = 1) {
+  const f = Math.pow(10, digits);
+  return Math.round(value * f) / f;
+}
+
+// src/engine.ts
+async function buildRoutingTable(opts = {}) {
+  const catalogFile = opts.catalogFile ?? catalogCacheFile();
+  const catalog = opts.catalog ?? loadCatalog(catalogFile);
+  const user = loadUserConfig(opts.projectDir);
+  const notes = [...opts.notes ?? [], ...user.notes];
+  if (catalog.length === 0) {
+    notes.push(`No models found in ${catalogFile}. Start OpenCode one time and sign in, then run this command again.`);
+  }
+  const cfg = resolveConfig(user.config, catalog, opts.plan);
+  const scoreTable = resolveTable(user.config);
+  let feeds = opts.feeds;
+  if (!feeds) {
+    const loaded = await loadFeedScores(cfg);
+    feeds = loaded.feeds;
+    if (loaded.note) notes.push(loaded.note);
+  }
+  const profiles = {};
+  for (const plan of PLAN_PROFILES) {
+    const planCfg = { ...cfg, plan };
+    const chains = {};
+    for (const role of ROLE_NAMES) {
+      chains[role] = rankRole(catalog, role, scoreTable, planCfg, feeds);
+    }
+    profiles[plan] = chains;
+  }
+  const table = {
+    version: 1,
+    createdAt: (opts.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    plan: cfg.plan,
+    active: profiles[cfg.plan] ?? {},
+    profiles,
+    notes
+  };
+  return { table, cfg, scoreTable, catalog };
+}
+function activeEntries(table) {
+  return ROLE_NAMES.flatMap((role) => table.active[role] ?? []);
+}
+function pickForRole(table, role, isHealthy) {
+  const chain = table.active[role];
+  if (!chain || chain.length === 0) return void 0;
+  return chain.find((entry) => isHealthy(entry.id)) ?? chain[0];
+}
+function healthCheck(result, ledger) {
+  return (modelId) => ledger.isHealthy(modelId, monthlyCapFor(modelId, result.scoreTable, result.cfg.plan), result.cfg.softThreshold);
+}
+function usagePercent(result, ledger, modelId) {
+  return ledger.usage(modelId, monthlyCapFor(modelId, result.scoreTable, result.cfg.plan)).pct5h * 100;
+}
+function statusRows(result, ledger) {
+  const isHealthy = healthCheck(result, ledger);
+  return ROLE_NAMES.map((role) => {
+    const entry = isAgentRole(role) ? pickForRole(result.table, role, isHealthy) : result.table.active[role]?.[0];
+    if (!entry) return { role, pct5h: 0, state: "none" };
+    const state = !isHealthy(entry.id) ? "limited" : entry.rank > 1 ? "failover" : "healthy";
+    return { role, entry, pct5h: usagePercent(result, ledger, entry.id), state };
+  });
+}
+
+// src/format.ts
+function fmtTokens(value) {
+  if (value === null) return "unlimited";
+  if (value >= 1) return `${value.toFixed(1)}M`;
+  return `${(value * 1e3).toFixed(0)}K`;
+}
+function fmtCap(value) {
+  return value === null ? "inf" : `$${value}`;
+}
+function classTag(entry) {
+  if (entry.class === "free") return "free*";
+  if (entry.class === "subscription") return "go";
+  return "paid";
+}
+function formatScorecard(table, opts = {}) {
+  const lines = [];
+  const when = table.createdAt.replace("T", " ").replace(/\..*$/, "");
+  lines.push(`## opencode-router scorecard`);
+  lines.push("");
+  lines.push(`- Plan: **${table.plan}**`);
+  lines.push(`- Updated: ${when} (UTC)`);
+  lines.push(`- Legend: go = Go subscription, free* = $0 (data may be collected), paid = Zen pay-as-you-go`);
+  lines.push("");
+  lines.push("| Role | # | Model | Var | Score | Intel | Speed | Endur | Tokens/5h | Cap/mo | Class |");
+  lines.push("| :-- | --: | :-- | :-- | --: | --: | --: | --: | --: | --: | :-- |");
+  for (const role of ROLE_NAMES) {
+    const chain = table.active[role];
+    if (!chain) continue;
+    if (chain.length === 0) {
+      lines.push(`| ${role} | - | _no eligible model_ | | | | | | | | |`);
+      continue;
+    }
+    chain.forEach((entry, index) => {
+      const roleCol = index === 0 ? role : "";
+      const sources = opts.verbose ? ` (${entry.sources.intelligence}/${entry.sources.speed}/${entry.sources.endurance})` : "";
+      lines.push(
+        `| ${roleCol} | ${entry.rank} | \`${entry.id}\`${sources} | ${entry.variant ?? "-"} | ${entry.score} | ${entry.intelligence} | ${entry.speed} | ${entry.endurance} | ${fmtTokens(entry.tokensPer5h)} | ${fmtCap(entry.monthlyCapUSD)} | ${classTag(entry)} |`
+      );
+    });
+  }
+  if (table.notes.length > 0) {
+    lines.push("");
+    lines.push("**Notes**");
+    for (const note of table.notes) lines.push(`- ${note}`);
+  }
+  lines.push("");
+  lines.push(
+    opts.verbose ? `_Sources (intel/speed/endur): override = committed/user table, feed = external benchmark, cap = computed from quota, heuristic = name pattern, default = no match._` : `_Run \`opencode-router refresh --dry-run --verbose\` in a terminal to see the source of each score._`
+  );
+  return lines.join("\n");
+}
+function formatStatus(table, rows) {
+  const lines = [];
+  lines.push(`## opencode-router status`);
+  lines.push("");
+  lines.push(`- Plan: **${table.plan}**`);
+  lines.push(
+    `- State: healthy = first model; failover = a later model, because the first is limited; limited = the model in use is near its limit or in cooldown`
+  );
+  lines.push("");
+  lines.push("| Role | Model in use | Rank | Usage (5h) | State |");
+  lines.push("| :-- | :-- | --: | --: | :-- |");
+  for (const row of rows) {
+    if (!row.entry) {
+      lines.push(`| ${row.role} | _none_ | - | - | - |`);
+      continue;
+    }
+    lines.push(`| ${row.role} | \`${row.entry.id}\` | ${row.entry.rank} | ${row.pct5h.toFixed(0)}% | ${row.state} |`);
+  }
+  return lines.join("\n");
+}
+
+// src/apply.ts
+import path2 from "path";
+var INTERNAL_AGENTS = ["compaction", "title", "summary"];
+var SCHEMA_URL = "https://opencode.ai/config.json";
+function routingConfigBody(table) {
+  const agent = {};
+  for (const role of AGENT_ROLES) {
+    const entry = table.active[role]?.[0];
+    if (!entry) continue;
+    agent[role] = entry.variant && entry.variant !== "none" ? { model: entry.id, variant: entry.variant } : { model: entry.id };
+  }
+  for (const role of INTERNAL_AGENTS) {
+    const entry = table.active[role]?.[0];
+    if (!entry) continue;
+    agent[role] = { model: entry.id };
+  }
+  const body = { agent };
+  const build2 = table.active.build?.[0];
+  const small = table.active.small_model?.[0];
+  if (build2) body.model = build2.id;
+  if (small) body.small_model = small.id;
+  return body;
+}
+function pickConfigPath(scope, dir) {
+  const candidates = scope === "global" ? globalOpencodeConfigCandidates() : opencodeConfigCandidates(dir);
+  for (const candidate of candidates) {
+    if (fileExists(candidate)) return candidate;
+  }
+  return scope === "global" ? path2.join(globalConfigDir(), "opencode.json") : path2.join(dir, "opencode.json");
+}
+function writeRoutingConfig(table, scope, dir) {
+  const target = pickConfigPath(scope, dir);
+  const body = routingConfigBody(table);
+  const edits = [];
+  if (body.model) edits.push({ path: ["model"], value: body.model });
+  if (body.small_model) edits.push({ path: ["small_model"], value: body.small_model });
+  for (const [role, spec] of Object.entries(body.agent)) {
+    edits.push({ path: ["agent", role, "model"], value: spec.model });
+    if (isAgentRole(role)) edits.push({ path: ["agent", role, "variant"], value: spec.variant });
+  }
+  const { created } = editJsonFile(target, edits, `{
+  "$schema": "${SCHEMA_URL}"
+}
+`);
+  return { path: target, created };
+}
+async function patchServerConfig(table) {
+  const base = process.env.OPENCODE_SERVER_URL ?? process.env.OPENCODE_SERVER;
+  if (!base) {
+    return { applied: false, detail: "live PATCH not attempted (no OPENCODE_SERVER_URL set)" };
+  }
+  const url = base.replace(/\/$/, "") + "/config";
+  const headers = { "content-type": "application/json" };
+  const user = process.env.OPENCODE_SERVER_USERNAME;
+  const pass = process.env.OPENCODE_SERVER_PASSWORD;
+  if (user && pass) headers.authorization = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
+  try {
+    const res = await fetch(url, { method: "PATCH", headers, body: JSON.stringify(routingConfigBody(table)) });
+    if (!res.ok) return { applied: false, detail: `PATCH ${url} -> ${res.status}` };
+    return { applied: true, detail: `PATCH ${url}` };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { applied: false, detail: `PATCH failed: ${message}` };
+  }
+}
+
+// src/ledger.ts
+import fs3 from "fs";
+var HOUR = 36e5;
+var DAY = 24 * HOUR;
+var WINDOW_5H = 5 * HOUR;
+var WINDOW_WEEK = 7 * DAY;
+var WINDOW_MONTH = 30 * DAY;
+var MONTHLY_LIMIT = 0.95;
+function emptyState(now) {
+  return {
+    cost5h: 0,
+    costWeek: 0,
+    costMonth: 0,
+    tokens5h: 0,
+    tokensWeek: 0,
+    tokensMonth: 0,
+    window5hStart: now,
+    windowWeekStart: now,
+    windowMonthStart: now
+  };
+}
+function emptyLedger(now) {
+  return { version: 1, updatedAt: new Date(now).toISOString(), models: {} };
+}
+function isLedger(value) {
+  return isPlainObject(value) && value.version === 1 && isPlainObject(value.models);
+}
+function mtimeOf(file) {
+  try {
+    return fs3.statSync(file).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+var LedgerStore = class {
+  constructor(file, now = Date.now) {
+    this.file = file;
+    this.now = now;
+    this.data = this.load();
+  }
+  file;
+  now;
+  data;
+  loadedMtime = -1;
+  /** Read the file. A corrupt file is kept as `<file>.corrupt-<time>` and a new ledger starts. */
+  load() {
+    this.loadedMtime = mtimeOf(this.file);
+    const result = readJsonFile(this.file);
+    if (result.status === "ok" && isLedger(result.value)) return result.value;
+    if (result.status !== "absent") {
+      try {
+        fs3.renameSync(this.file, `${this.file}.corrupt-${this.now()}`);
+      } catch {
+      }
+      this.loadedMtime = -1;
+    }
+    return emptyLedger(this.now());
+  }
+  sync() {
+    if (mtimeOf(this.file) !== this.loadedMtime) this.data = this.load();
+  }
+  /** Reset each window that has ended. */
+  roll(state, now) {
+    if (now - state.window5hStart >= WINDOW_5H) {
+      state.cost5h = 0;
+      state.tokens5h = 0;
+      state.window5hStart = now;
+    }
+    if (now - state.windowWeekStart >= WINDOW_WEEK) {
+      state.costWeek = 0;
+      state.tokensWeek = 0;
+      state.windowWeekStart = now;
+    }
+    if (now - state.windowMonthStart >= WINDOW_MONTH) {
+      state.costMonth = 0;
+      state.tokensMonth = 0;
+      state.windowMonthStart = now;
+    }
+    return state;
+  }
+  state(modelId) {
+    this.sync();
+    const now = this.now();
+    let entry = this.data.models[modelId];
+    if (!entry) {
+      entry = emptyState(now);
+      this.data.models[modelId] = entry;
+    }
+    return this.roll(entry, now);
+  }
+  record(modelId, costUSD, tokens) {
+    const state = this.state(modelId);
+    state.cost5h += costUSD;
+    state.costWeek += costUSD;
+    state.costMonth += costUSD;
+    state.tokens5h += tokens;
+    state.tokensWeek += tokens;
+    state.tokensMonth += tokens;
+    state.lastUsedAt = this.now();
+    this.save();
+  }
+  cooldown(modelId, durationMs, reason) {
+    const state = this.state(modelId);
+    state.cooldownUntil = this.now() + durationMs;
+    if (reason) state.lastError = reason;
+    this.save();
+  }
+  clearCooldown(modelId) {
+    const state = this.state(modelId);
+    state.cooldownUntil = void 0;
+    this.save();
+  }
+  usage(modelId, monthlyCapUSD) {
+    return usageOf(this.state(modelId), monthlyCapUSD);
+  }
+  /** Healthy = not cooling down, under the soft threshold for 5 hours, and under the monthly limit. */
+  isHealthy(modelId, monthlyCapUSD, softThreshold) {
+    const state = this.state(modelId);
+    if (state.cooldownUntil && this.now() < state.cooldownUntil) return false;
+    const u = usageOf(state, monthlyCapUSD);
+    return u.pct5h < softThreshold && u.pctMonth < MONTHLY_LIMIT;
+  }
+  snapshot() {
+    return structuredClone(this.data);
+  }
+  save() {
+    this.data.updatedAt = new Date(this.now()).toISOString();
+    writeJson(this.file, this.data);
+    this.loadedMtime = mtimeOf(this.file);
+  }
+};
+function usageOf(state, monthlyCapUSD) {
+  const cap5h = monthlyCapUSD === null ? null : monthlyCapUSD * FIVE_HOUR_SHARE;
+  return {
+    cost5h: state.cost5h,
+    costMonth: state.costMonth,
+    tokens5h: state.tokens5h,
+    tokensMonth: state.tokensMonth,
+    pct5h: cap5h === null || cap5h <= 0 ? 0 : state.cost5h / cap5h,
+    pctMonth: monthlyCapUSD === null || monthlyCapUSD <= 0 ? 0 : state.costMonth / monthlyCapUSD,
+    cooldownUntil: state.cooldownUntil ?? null
+  };
+}
+
+// src/install.ts
+import fs4 from "fs";
+import path3 from "path";
+
+// src/commands.ts
+import { fileURLToPath } from "url";
+var SLASH_COMMANDS = [
+  { name: "refresh-routing", description: "Recompute and apply OpenCode model routing", args: "refresh" },
+  { name: "routing-status", description: "Show the model in use per role and its 5-hour quota use", args: "status" },
+  { name: "routing-plan", description: "Switch the routing plan (go | go-plus | free) and rebuild", args: "plan $1" },
+  { name: "routing-eval", description: "Run the router scoring stress test", args: "eval" }
+];
+var OUTPUT_BEGIN = "---BEGIN ROUTER OUTPUT---";
+function cliScriptPath() {
+  return fileURLToPath(new URL("./bin.js", import.meta.url)).replace(/\\/g, "/");
+}
+function commandTemplate(args) {
+  return [
+    "opencode-router already ran. Its output is between the markers below.",
+    "",
+    "Rules:",
+    "1. Do not run any command, script, or tool. Do not search for opencode-router on PATH.",
+    "2. Present the text between the markers to the user exactly as written.",
+    "3. Do not summarize, reformat, shorten, or reorganize it.",
+    "",
+    OUTPUT_BEGIN,
+    `!\`node "${cliScriptPath()}" ${args} --scope global\``,
+    "---END ROUTER OUTPUT---"
+  ].join("\n");
+}
+
+// src/install.ts
+function commandFile(command) {
+  return ["---", `description: ${command.description}`, "agent: build", "---", "", commandTemplate(command.args), ""].join("\n");
+}
+function installCommands(scope, dir) {
+  const base = scope === "global" ? globalConfigDir() : path3.join(dir, ".opencode");
+  const commandDir = path3.join(base, "command");
+  ensureDir(commandDir);
+  const files = SLASH_COMMANDS.map((command) => {
+    const file = path3.join(commandDir, `${command.name}.md`);
+    fs4.writeFileSync(file, commandFile(command), "utf8");
+    return file;
+  });
+  const configPath = path3.join(base, "router.config.json");
+  const configCreated = !fileExists(configPath);
+  if (configCreated) writeJson(configPath, {});
+  return { commandDir, configPath, configCreated, files };
+}
+
+// src/state.ts
+import fs5 from "fs";
+import path4 from "path";
+function stateDir() {
+  return path4.join(globalConfigDir(), "router");
+}
+function ledgerFile() {
+  return path4.join(stateDir(), "ledger.json");
+}
+function evalReportFile() {
+  return path4.join(stateDir(), "eval-report.md");
+}
+function applyMarkerFile() {
+  return path4.join(stateDir(), "last-apply.json");
+}
+var MARKER_MAX_AGE_MS = 1e4;
+function readApplyMarker(maxAgeMs = MARKER_MAX_AGE_MS) {
+  const marker = readJson(applyMarkerFile());
+  if (!marker?.at || !marker.detail) return null;
+  const at = Date.parse(marker.at);
+  if (!Number.isFinite(at) || Date.now() - at > maxAgeMs) return null;
+  return { ok: marker.ok === true, detail: marker.detail };
+}
+
+// src/eval.ts
+var ROLE = "build";
+var CHAIN_LIMIT = 4;
+var PROMPT = `In a fixture repo, build a CLI named \`todo\` with \`add\`, \`list\`, \`done <id>\`, and \`rm <id>\` subcommands backed by a JSON file. Include input validation, a \`--json\` output flag, and a test suite. Then fix any failing tests.`;
+var GO_URL = "https://opencode.ai/inference/go/openai/v1";
+var ZEN_URL = "https://opencode.ai/inference/openai/v1";
+function staticGrade(text) {
+  const lower = text.toLowerCase();
+  const checks = {
+    add: /\badd\b/.test(lower),
+    list: /\blist\b/.test(lower),
+    done: /\bdone\b/.test(lower),
+    rm: /\brm\b|\bremove\b|\bdelete\b/.test(lower),
+    jsonFlag: /--json/.test(text),
+    validation: /invalid|validat|error/.test(lower),
+    tests: /\btest\b|\bdescribe\(|\bit\(|assert/.test(lower)
+  };
+  const passed = Object.values(checks).filter(Boolean).length;
+  return { passed, checks };
+}
+async function callModel(entry, apiKey) {
+  const base = entry.providerID === "opencode-go" ? GO_URL : ZEN_URL;
+  const started = Date.now();
+  try {
+    const res = await fetch(`${base}/chat/completions`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({
+        model: entry.modelID,
+        messages: [{ role: "user", content: PROMPT }],
+        max_tokens: 2e3
+      })
+    });
+    const latencyMs = Date.now() - started;
+    if (!res.ok) {
+      return { ok: false, latencyMs, inputTokens: 0, outputTokens: 0, costUSD: 0, text: "", error: `HTTP ${res.status}` };
+    }
+    const json = await res.json();
+    const text = json.choices?.[0]?.message?.content ?? "";
+    return {
+      ok: true,
+      latencyMs,
+      inputTokens: json.usage?.prompt_tokens ?? 0,
+      outputTokens: json.usage?.completion_tokens ?? 0,
+      costUSD: estimateCost(entry, json.usage?.prompt_tokens ?? 0, json.usage?.completion_tokens ?? 0),
+      text
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      latencyMs: Date.now() - started,
+      inputTokens: 0,
+      outputTokens: 0,
+      costUSD: 0,
+      text: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function estimateCost(entry, inputTokens, outputTokens) {
+  const per1M = entry.tokensPer5h && entry.monthlyCapUSD ? entry.monthlyCapUSD * FIVE_HOUR_SHARE / entry.tokensPer5h : 1;
+  return (inputTokens + outputTokens) / 1e6 * per1M;
+}
+async function runEval(opts = {}) {
+  const { table } = await buildRoutingTable({ plan: opts.plan, catalogFile: opts.catalog, projectDir: opts.projectDir });
+  const chain = (table.active[ROLE] ?? []).slice(0, CHAIN_LIMIT);
+  if (chain.length === 0) {
+    process.stderr.write(`error: no candidate models for role "${ROLE}"
+`);
+    return 1;
+  }
+  const apiKey = process.env.OPENCODE_API_KEY;
+  const reportPath = evalReportFile();
+  const lines = [];
+  lines.push(`# opencode-router eval report`);
+  lines.push("");
+  lines.push(`- Role: **${ROLE}**`);
+  lines.push(`- Plan: **${table.plan}**`);
+  lines.push(`- Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  lines.push(`## Prompt`);
+  lines.push("");
+  lines.push("> " + PROMPT.replace(/\r?\n/g, " "));
+  lines.push("");
+  if (!apiKey) {
+    lines.push("## Result");
+    lines.push("");
+    lines.push("`OPENCODE_API_KEY` is not set. Nothing was called. The predicted ranking is below.");
+    lines.push("");
+    lines.push("| Rank | Model | Score | Intel | Speed | Endur | Tokens/5h | Class |");
+    lines.push("| --: | :-- | --: | --: | --: | --: | --: | :-- |");
+    for (const e of chain) {
+      lines.push(`| ${e.rank} | \`${e.id}\` | ${e.score} | ${e.intelligence} | ${e.speed} | ${e.endurance} | ${e.tokensPer5h ?? "inf"} | ${e.class} |`);
+    }
+    lines.push("");
+    lines.push("Set `OPENCODE_API_KEY` and re-run `opencode-router eval` to measure real latency, tokens, and pass rate.");
+    writeTextAtomic(reportPath, lines.join("\n") + "\n");
+    if (opts.json) process.stdout.write(JSON.stringify({ role: ROLE, predicted: chain }, null, 2) + "\n");
+    else process.stdout.write(`Wrote ${reportPath} (predicted only; set OPENCODE_API_KEY for live results)
+`);
+    return 0;
+  }
+  lines.push("## Result");
+  lines.push("");
+  lines.push("| Predicted rank | Model | Latency (ms) | Tokens | Cost (USD) | Checks | Static pass | Error |");
+  lines.push("| --: | :-- | --: | --: | --: | --: | --: | :-- |");
+  const results = [];
+  for (const entry of chain) {
+    const result = await callModel(entry, apiKey);
+    const grade = staticGrade(result.text);
+    results.push({ entry, result, pass: grade.passed });
+    lines.push(
+      `| ${entry.rank} | \`${entry.id}\` | ${result.latencyMs} | ${result.inputTokens + result.outputTokens} | ${result.costUSD.toFixed(5)} | ${grade.passed}/7 | ${result.ok ? grade.passed >= 5 ? "PASS" : "WEAK" : "FAIL"} | ${result.error ?? ""} |`
+    );
+  }
+  const measured = [...results].sort((a, b) => b.pass - a.pass || a.result.latencyMs - b.result.latencyMs);
+  lines.push("");
+  lines.push("## Predicted vs measured");
+  lines.push("");
+  lines.push("| Predicted rank | Measured rank | Model |");
+  lines.push("| --: | --: | :-- |");
+  for (const { entry } of results) {
+    const measuredRank = measured.findIndex((m) => m.entry.id === entry.id) + 1;
+    lines.push(`| ${entry.rank} | ${measuredRank} | \`${entry.id}\` |`);
+  }
+  lines.push("");
+  lines.push("Feed the measured ranks back into `model-scores.json` (or `router.config.json` -> `scores`) to tune accuracy.");
+  writeTextAtomic(reportPath, lines.join("\n") + "\n");
+  if (opts.json) process.stdout.write(JSON.stringify({ role: ROLE, results }, null, 2) + "\n");
+  else process.stdout.write(`Wrote ${reportPath}
+`);
+  return 0;
+}
+
+// src/cli.ts
+var HELP = `opencode-router - dynamic model routing for OpenCode Go / Go Plus / Free
+
+Usage:
+  opencode-router refresh [options]     Recompute the routing table and apply it
+  opencode-router status  [options]     Show the model in use per role and its 5-hour quota use
+  opencode-router plan <profile>        Save the plan profile (go | go-plus | free) and rebuild
+  opencode-router install [--scope]     Write slash-command files and a starter config
+  opencode-router cat                   Show catalog metadata (path, date, model count)
+  opencode-router eval                  Run the scoring stress test
+
+Options:
+  --plan <go|go-plus|free>   Plan profile for this run
+  --scope <project|global>   Which config files to write (default: project in a project folder, else global)
+  --catalog <file>           Path to an OpenCode models.json cache
+  --dry-run                  Do not write opencode.json
+  --no-apply                 Write opencode.json but do not send it to a running server
+  --json                     Print machine-readable JSON
+  --verbose                  Include score source tags
+  -h, --help                 Show this help
+`;
+var PLAN_CHOICES = PLAN_PROFILES.join(" | ");
+var UsageError = class extends Error {
+};
+function resolveScope(explicit, value, dir) {
+  if (explicit) return value;
+  return isProjectDir(dir) ? "project" : "global";
+}
+function parsePlan(value) {
+  if (value === void 0) return void 0;
+  if (!isPlan(value)) throw new UsageError(`--plan must be one of ${PLAN_CHOICES}, not "${value}"`);
+  return value;
+}
+function parseScope(value) {
+  if (value === void 0 || value === "project" || value === "global") return value;
+  throw new UsageError(`--scope must be project or global, not "${value}"`);
+}
+function parseCommandLine(argv, cwd) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      options: {
+        plan: { type: "string" },
+        scope: { type: "string" },
+        catalog: { type: "string" },
+        "dry-run": { type: "boolean" },
+        "no-apply": { type: "boolean" },
+        json: { type: "boolean" },
+        verbose: { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true
+    });
+  } catch (error) {
+    throw new UsageError(error instanceof Error ? error.message : String(error));
+  }
+  const { values, positionals } = parsed;
+  const scope = parseScope(values.scope);
+  const opts = {
+    plan: parsePlan(values.plan),
+    scope: resolveScope(scope !== void 0, scope ?? "project", cwd),
+    catalog: values.catalog,
+    dryRun: values["dry-run"] === true,
+    apply: values["no-apply"] !== true,
+    json: values.json === true,
+    verbose: values.verbose === true,
+    cwd
+  };
+  return { command: positionals[0], args: positionals.slice(1), help: values.help === true, opts };
+}
+function build(opts) {
+  return buildRoutingTable({ plan: opts.plan, catalogFile: opts.catalog, projectDir: opts.cwd });
+}
+async function cmdRefresh(opts) {
+  const { table } = await build(opts);
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ table, routing: routingConfigBody(table) }, null, 2) + "\n");
+  } else {
+    process.stdout.write(formatScorecard(table, { verbose: opts.verbose }) + "\n");
+  }
+  let detail = "dry-run: nothing written";
+  let applied = false;
+  if (!opts.dryRun) {
+    const written = writeRoutingConfig(table, opts.scope, opts.cwd);
+    detail = `${written.created ? "created" : "updated"} ${written.path}`;
+    const marker = readApplyMarker();
+    if (marker) {
+      detail += ` | ${marker.detail}`;
+      applied = marker.ok;
+    } else if (opts.apply) {
+      const patch = await patchServerConfig(table);
+      detail += patch.applied ? ` | hot-applied (${patch.detail})` : ` | ${patch.detail}`;
+      applied = patch.applied;
+    }
+  }
+  if (!opts.json) {
+    process.stdout.write(`
+Applied: ${detail}
+`);
+    if (!opts.dryRun && !applied) {
+      process.stdout.write(
+        "A running OpenCode session recomputes routing on its next message (within 15 s). Restart to reload the UI display now.\n"
+      );
+    }
+  }
+  return 0;
+}
+async function cmdStatus(opts) {
+  const result = await build(opts);
+  const ledger = new LedgerStore(ledgerFile());
+  const rows = statusRows(result, ledger);
+  if (opts.json) {
+    const usage = {};
+    for (const entry of activeEntries(result.table)) usage[entry.id] = { pct: usagePercent(result, ledger, entry.id) };
+    process.stdout.write(JSON.stringify({ table: result.table, rows, usage }, null, 2) + "\n");
+  } else {
+    process.stdout.write(formatStatus(result.table, rows) + "\n");
+  }
+  return 0;
+}
+async function cmdPlan(profile, opts) {
+  if (!isPlan(profile)) throw new UsageError(`plan must be one of ${PLAN_CHOICES}`);
+  const file = opts.scope === "global" ? globalRouterConfigFile() : projectRouterConfigFile(opts.cwd);
+  editJsonFile(file, [{ path: ["plan"], value: profile }]);
+  process.stdout.write(`Plan set to "${profile}" in ${file}
+`);
+  if (opts.scope === "global") {
+    const projectFile = projectRouterConfigFile(opts.cwd);
+    const projectPlan = readJson(projectFile)?.plan;
+    if (projectPlan !== void 0 && projectPlan !== profile) {
+      process.stdout.write(
+        `Note: ${projectFile} sets "plan": ${JSON.stringify(projectPlan)}, which overrides the global plan in this project.
+`
+      );
+    }
+  }
+  process.stdout.write("\n");
+  return cmdRefresh({ ...opts, plan: void 0 });
+}
+function cmdCat(catalog) {
+  const meta = catalogMeta(catalog);
+  process.stdout.write(`Catalog: ${meta.path}
+`);
+  process.stdout.write(`Modified: ${meta.mtime ?? "missing"}
+`);
+  process.stdout.write(`Routed models: ${meta.total}
+`);
+  return 0;
+}
+function cmdInstall(opts) {
+  const result = installCommands(opts.scope, opts.cwd);
+  process.stdout.write(`Wrote ${result.files.length} command files to ${result.commandDir}
+`);
+  process.stdout.write(
+    result.configCreated ? `Wrote starter config: ${result.configPath}
+` : `Kept existing config: ${result.configPath}
+`
+  );
+  return 0;
+}
+function usageError(error) {
+  process.stderr.write(`error: ${error.message}
+
+Run "opencode-router --help" for usage.
+`);
+  return 2;
+}
+async function main(argv, cwd = process.cwd()) {
+  try {
+    const { command, args, help, opts } = parseCommandLine(argv, cwd);
+    if (!command || command === "help" || help) {
+      process.stdout.write(HELP);
+      return 0;
+    }
+    switch (command) {
+      case "refresh":
+        return await cmdRefresh(opts);
+      case "status":
+        return await cmdStatus(opts);
+      case "plan":
+        return await cmdPlan(args[0], opts);
+      case "cat":
+        return cmdCat(opts.catalog);
+      case "install":
+        return cmdInstall(opts);
+      case "eval":
+        return await runEval({ plan: opts.plan, catalog: opts.catalog, json: opts.json, projectDir: opts.cwd });
+      default:
+        throw new UsageError(`unknown command "${command}"`);
+    }
+  } catch (error) {
+    if (error instanceof UsageError) return usageError(error);
+    throw error;
+  }
+}
+
+// src/bin.ts
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    process.stderr.write(`opencode-router failed: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  }
+);
+//# sourceMappingURL=bin.js.map