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

package/dist/index.js

@@ -0,0 +1,2010 @@
+// 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);
+    })
+  }
+};
+
+// 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 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;
+}
+
+// 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 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>";
+}
+
+// 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 ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+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 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");
+}
+
+// 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;
+}
+
+// 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 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);
+}
+
+// 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/apply.ts
+import path2 from "path";
+var INTERNAL_AGENTS = ["compaction", "title", "summary"];
+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 build = table.active.build?.[0];
+  const small = table.active.small_model?.[0];
+  if (build) body.model = build.id;
+  if (small) body.small_model = small.id;
+  return body;
+}
+
+// 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 isRouterCommandPrompt(parts) {
+  return parts.some((part) => part.type === "text" && part.text?.includes(OUTPUT_BEGIN) === true);
+}
+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/state.ts
+import fs4 from "fs";
+import path3 from "path";
+function stateDir() {
+  return path3.join(globalConfigDir(), "router");
+}
+function ledgerFile() {
+  return path3.join(stateDir(), "ledger.json");
+}
+function routingTableFile() {
+  return path3.join(stateDir(), "routing-table.json");
+}
+function applyMarkerFile() {
+  return path3.join(stateDir(), "last-apply.json");
+}
+function writeApplyMarker(marker) {
+  writeJson(applyMarkerFile(), { at: (/* @__PURE__ */ new Date()).toISOString(), ...marker });
+}
+function clearApplyMarker() {
+  fs4.rmSync(applyMarkerFile(), { force: true });
+}
+
+// src/index.ts
+var RATE_LIMIT_COOLDOWN_MS = 60 * 60 * 1e3;
+var AUTH_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
+var MAX_TRACKED_MESSAGES = 500;
+var TTL_MS = 15e3;
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRateLimitError(error) {
+  if (!error || typeof error !== "object") return false;
+  const rec = error;
+  const data = rec.data ?? {};
+  const status = Number(data.statusCode ?? data.status ?? 0);
+  const message = String(data.message ?? data.responseBody ?? "").toLowerCase();
+  if (status === 429 || status === 402) return true;
+  return /rate.?limit|quota|too many requests|insufficient|capacity|overloaded/.test(message);
+}
+function isAuthError(error) {
+  return typeof error === "object" && error !== null && String(error.name ?? "").includes("ProviderAuthError");
+}
+var OpencodeRouter = async (input) => {
+  const dir = input.directory ?? input.worktree ?? process.cwd();
+  const ledger = new LedgerStore(ledgerFile(), () => Date.now());
+  const recordedMessages = /* @__PURE__ */ new Set();
+  const sessionModels = /* @__PURE__ */ new Map();
+  let cached = null;
+  let cachedAt = 0;
+  let blendedById = /* @__PURE__ */ new Map();
+  async function ensure(force = false, plan) {
+    const now = Date.now();
+    if (!force && cached && now - cachedAt < TTL_MS) return cached;
+    const result = await buildRoutingTable({ projectDir: dir, plan });
+    cached = result;
+    cachedAt = now;
+    blendedById = new Map(result.catalog.map((m) => [m.id, blendedCost(m, result.cfg)]));
+    try {
+      writeJson(routingTableFile(), result.table);
+    } catch {
+    }
+    return result;
+  }
+  async function applyToSession(result) {
+    try {
+      await input.client.config.update({ body: routingConfigBody(result.table) });
+      writeApplyMarker({ ok: true, detail: "hot-applied to the running session by the opencode-router plugin" });
+    } catch (error) {
+      writeApplyMarker({ ok: false, detail: `hot-apply failed: ${errorMessage(error)}` });
+    }
+  }
+  function rememberMessage(id) {
+    recordedMessages.add(id);
+    if (recordedMessages.size > MAX_TRACKED_MESSAGES) {
+      const oldest = recordedMessages.values().next().value;
+      if (oldest !== void 0) recordedMessages.delete(oldest);
+    }
+  }
+  return {
+    config: async (cfg) => {
+      try {
+        const result = await ensure();
+        const body = routingConfigBody(result.table);
+        const agents = { ...cfg.agent };
+        for (const [role, spec] of Object.entries(body.agent)) agents[role] = { ...agents[role], ...spec };
+        cfg.agent = agents;
+        if (body.model) cfg.model = body.model;
+        if (body.small_model) cfg.small_model = body.small_model;
+        const commands = { ...cfg.command };
+        for (const command of SLASH_COMMANDS) {
+          commands[command.name] = {
+            description: command.description,
+            agent: "build",
+            model: body.small_model,
+            template: commandTemplate(command.args)
+          };
+        }
+        cfg.command = commands;
+      } catch {
+      }
+    },
+    // The CLI that the command template starts prints the result. This hook
+    // applies the same table to the running session.
+    "command.execute.before": async (cmd) => {
+      const name = cmd.command.replace(/^\//, "");
+      try {
+        if (name === "refresh-routing") {
+          clearApplyMarker();
+          await applyToSession(await ensure(true));
+        } else if (name === "routing-plan") {
+          const plan = cmd.arguments.trim().split(/\s+/)[0];
+          if (!isPlan(plan)) return;
+          clearApplyMarker();
+          await applyToSession(await ensure(true, plan));
+        }
+      } catch (error) {
+        writeApplyMarker({ ok: false, detail: `router command failed: ${errorMessage(error)}` });
+      }
+    },
+    "chat.message": async (msgInput, output) => {
+      try {
+        const agent = msgInput.agent ?? output.message.agent;
+        if (!isAgentRole(agent)) return;
+        if (isRouterCommandPrompt(output.parts)) return;
+        const result = await ensure();
+        const entry = pickForRole(result.table, agent, healthCheck(result, ledger));
+        if (!entry) return;
+        sessionModels.set(msgInput.sessionID, entry.id);
+        const current = output.message.model;
+        if (current?.providerID === entry.providerID && current.modelID === entry.modelID) return;
+        output.message.model = { providerID: entry.providerID, modelID: entry.modelID };
+      } catch {
+      }
+    },
+    event: async ({ event }) => {
+      try {
+        if (event.type === "message.updated") {
+          const info = event.properties.info;
+          if (info.role !== "assistant" || !info.time.completed || recordedMessages.has(info.id)) return;
+          rememberMessage(info.id);
+          const id = `${info.providerID}/${info.modelID}`;
+          sessionModels.set(info.sessionID, id);
+          const tokens = (info.tokens?.input ?? 0) + (info.tokens?.output ?? 0) + (info.tokens?.cache?.read ?? 0) + (info.tokens?.cache?.write ?? 0);
+          let cost = info.cost ?? 0;
+          if (cost === 0 && tokens > 0) {
+            await ensure();
+            const blended = blendedById.get(id) ?? 0;
+            if (blended > 0) cost = tokens / 1e6 * blended;
+          }
+          ledger.record(id, cost, tokens);
+          if (isRateLimitError(info.error)) ledger.cooldown(id, RATE_LIMIT_COOLDOWN_MS, "rate limit / quota");
+          else if (isAuthError(info.error)) ledger.cooldown(id, AUTH_COOLDOWN_MS, "auth error");
+        } else if (event.type === "session.error") {
+          const { sessionID, error } = event.properties;
+          const id = sessionID ? sessionModels.get(sessionID) : void 0;
+          if (id && isRateLimitError(error)) ledger.cooldown(id, RATE_LIMIT_COOLDOWN_MS, "session rate limit");
+        }
+      } catch {
+      }
+    }
+  };
+};
+var src_default = OpencodeRouter;
+export {
+  OpencodeRouter,
+  src_default as default
+};
+//# sourceMappingURL=index.js.map