@vizuh/sabi 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# @vizuh/sabi
+
+Adaptive inference scheduling for [Command Code](https://commandcode.ai): a mod that plans each
+continuing round — model and reasoning effort — from the trajectory's own state (tool calls and
+their results, failure evidence, context size). Round 1 always runs on your session model; from
+round 2 on, a read round goes cheap, edits and tests go mid, and a failing tool escalates.
+
+This package is the **mod only**. The local proxy (BYOK, for any harness that accepts a `baseURL`)
+lives in the [repository](https://github.com/vizuh/sabi).
+
+## Install
+
+```bash
+cmd mods add -g npm:@vizuh/sabi
+```
+
+## Update
+
+```bash
+cmd mods update
+```
+
+## Uninstall
+
+```bash
+cmd mods remove sabi
+```
+
+## Configuration
+
+The package ships a default `sabi.config.json` next to the bundle, so it works with no setup.
+To change tiers, policy or telemetry, put your own `sabi.config.json` in the project you run in,
+or at `~/.config/sabi/sabi.config.json` — both take precedence over the shipped default (or set
+`SABI_CONFIG` to point at one explicitly).
+
+`harness.tiers` defaults to the strongest Command Code ids available from the Go plan up. A model
+that is listed by `cmd --list-models` is not necessarily covered by your plan: an out-of-plan tier
+answers `403 MODEL_NOT_IN_PLAN` and fails that round, so check the ids against your plan.
+
+Docs, decisions and the full changelog: https://github.com/vizuh/sabi

package/mod/sabi.mjs

@@ -0,0 +1,881 @@
+// @vizuh/sabi 0.1.0 — generated by pack.mjs from packages/adapters/command-code/mod/sabi.ts.
+// Source and docs: https://github.com/vizuh/sabi
+
+// packages/core/src/state.ts
+var EXPLORE_TOOLS = /* @__PURE__ */ new Set([
+  "read",
+  // OpenCode/Kilo
+  "webfetch",
+  "websearch",
+  "read_file",
+  "read_directory",
+  "glob",
+  "grep",
+  "web_search",
+  "web_fetch",
+  "shell_output",
+  "shell_tasks",
+  "get_diagnostics",
+  "todo_write",
+  "task_create",
+  "task_update",
+  "task_list",
+  "task_get",
+  "task_output",
+  "task_stop",
+  "sleep",
+  "cron_create",
+  "cron_list",
+  "cron_delete",
+  "schedule_wakeup",
+  "activate_skill"
+]);
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["edit_file", "write_file", "edit", "write", "apply_patch"]);
+var SHELL_TOOLS = /* @__PURE__ */ new Set(["shell_command", "bash"]);
+var VERIFY_COMMAND = /\b(test|tests|vitest|jest|pytest|build|tsc|typecheck|type-check|lint|eslint|check)\b/i;
+var EXPLORE_COMMAND = /(^|\s)(ls|cat|head|tail|find|rg|grep|wc|pwd)\b|\bgit\s+(status|diff|log|show|branch)\b/i;
+var KIND_RANK = {
+  unclassified: 0,
+  exploration: 1,
+  implementation: 2,
+  verification: 3,
+  "first-turn": 4
+};
+var HARD_PATTERNS = [
+  { re: /^\s*(?:Error|ERROR|error):/m, label: "error-line" },
+  { re: /Traceback \(most recent call last\)/, label: "python-traceback" },
+  { re: /\bpanic:/, label: "panic" },
+  {
+    re: /AssertionError|TypeError|ReferenceError|SyntaxError|ImportError|ModuleNotFoundError|Cannot find module/,
+    label: "exception"
+  },
+  { re: /\berror TS\d+/, label: "typescript-error" },
+  { re: /\b(?:FAIL|FAILED|FAILURES|Failing)\b/, label: "fail-marker" },
+  { re: /\bcommand failed\b/i, label: "command-failed" },
+  { re: /exit (?:code|status)[:=\s]+([1-9]\d*)/i, label: "nonzero-exit" },
+  { re: /(\d+)\s+fail(?:ed|ing|ures)/i, label: "failure-count", numeric: true },
+  { re: /command not found/i, label: "command-not-found" },
+  { re: /permission denied/i, label: "permission-denied" },
+  { re: /no such file or directory/i, label: "missing-file" }
+];
+var SOFT_PATTERNS = [
+  { re: /warning/i, label: "soft-warning" },
+  { re: /deprecated/i, label: "soft-deprecated" },
+  { re: /retrying/i, label: "soft-retrying" },
+  { re: /timed out/i, label: "soft-timeout" }
+];
+var TRANSPORT_LIMIT_PATTERNS = [
+  { re: /rate[-_ ]?limit/i, label: "rate-limited" },
+  { re: /too many requests/i, label: "rate-limited" },
+  { re: /\b(?:session|usage|weekly|monthly|daily|hourly|subscription|plan)\s+limit\b/i, label: "quota-exceeded" },
+  { re: /quota[- ]?exceeded/i, label: "quota-exceeded" },
+  { re: /insufficient_quota|insufficient quota/i, label: "quota-exceeded" }
+];
+var TRANSPORT_PATTERNS = [
+  { re: /\b429\b/, label: "rate-limited" },
+  { re: /timed out|timeout/i, label: "timeout" }
+];
+var HARNESS_DENIAL = /\buser\b[^\n]{0,40}\b(?:denied|declined|rejected)\b|denied by (?:the )?user|\b(?:permission|tool call|request)[^\n]{0,30}\b(?:denied|declined|rejected)\b/i;
+function textOf(content) {
+  if (content === null || content === void 0) return "";
+  if (typeof content === "string") return content;
+  if (typeof content === "number" || typeof content === "boolean") return String(content);
+  if (Array.isArray(content)) return content.map((part) => textOf(part)).join("\n");
+  if (typeof content === "object") {
+    const obj = content;
+    if (typeof obj.text === "string") return obj.text;
+    if (obj.content !== void 0) return textOf(obj.content);
+    if (typeof obj.output === "string") return obj.output;
+  }
+  return "";
+}
+var CHARS_PER_TOKEN = 3.6;
+var MEDIA_TOKENS_PER_IMAGE = 1500;
+var MEDIA_PART_TYPES = {
+  image: "image",
+  image_url: "image",
+  input_image: "image",
+  input_audio: "audio",
+  audio_url: "audio",
+  video_url: "video",
+  file: "file"
+};
+function payloadCharsOf(part) {
+  try {
+    return JSON.stringify(part).length;
+  } catch {
+    return 0;
+  }
+}
+function tallyMedia(content, tally, depth = 0) {
+  if (depth > 3 || !Array.isArray(content)) return;
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const record = part;
+    const kind = typeof record.type === "string" ? MEDIA_PART_TYPES[record.type] : void 0;
+    if (kind) {
+      tally.counts[kind] = (tally.counts[kind] ?? 0) + 1;
+      if (kind !== "image") tally.payloadChars += payloadCharsOf(record);
+      continue;
+    }
+    if (record.content !== void 0) tallyMedia(record.content, tally, depth + 1);
+  }
+}
+function mediaTokens(tally) {
+  const images = tally.counts.image ?? 0;
+  return images * MEDIA_TOKENS_PER_IMAGE + Math.ceil(tally.payloadChars / CHARS_PER_TOKEN);
+}
+function modalitiesOf(counts) {
+  const kinds = Object.keys(counts).filter((kind) => (counts[kind] ?? 0) > 0).sort();
+  return ["text", ...kinds];
+}
+function isHarnessDenial(text) {
+  return HARNESS_DENIAL.test(text);
+}
+function detectFailure(texts) {
+  const evidence = [];
+  let hard = 0;
+  let soft = 0;
+  let transport = 0;
+  const note = (label) => {
+    if (evidence.length < 4) evidence.push(label);
+  };
+  for (const raw of texts) {
+    const text = String(raw ?? "");
+    if (!text.trim()) continue;
+    if (isHarnessDenial(text)) {
+      note("permission-denial");
+      continue;
+    }
+    const namedLimit = TRANSPORT_LIMIT_PATTERNS.find((pattern) => pattern.re.test(text));
+    if (namedLimit) {
+      transport += 1;
+      note(namedLimit.label);
+      continue;
+    }
+    let textHard = false;
+    for (const pattern of HARD_PATTERNS) {
+      const match = text.match(pattern.re);
+      if (!match) continue;
+      if (pattern.numeric) {
+        const count = Number((match[1] ?? "").replace(/\D/g, ""));
+        if (!(count > 0)) continue;
+      }
+      hard += 1;
+      textHard = true;
+      note(pattern.label);
+      break;
+    }
+    if (textHard) continue;
+    const statusSignal = TRANSPORT_PATTERNS.find((pattern) => pattern.re.test(text));
+    if (statusSignal) {
+      transport += 1;
+      note(statusSignal.label);
+      continue;
+    }
+    for (const pattern of SOFT_PATTERNS) {
+      if (pattern.re.test(text)) {
+        soft += 1;
+        note(pattern.label);
+        break;
+      }
+    }
+  }
+  const level = hard >= 1 ? "hard" : transport >= 1 ? "transport" : soft >= 2 ? "soft" : "none";
+  return { level, evidence };
+}
+var RTK_WRAPPERS = /* @__PURE__ */ new Set(["err", "test", "proxy", "summary"]);
+var RTK_READ_VERBS = /* @__PURE__ */ new Set(["read", "smart", "json", "env", "log", "deps", "session", "gain", "discover", "recall"]);
+function unwrapRtk(command) {
+  const parts = command.trim().split(/\s+/);
+  if ((parts[0] ?? "").toLowerCase() !== "rtk") return command.trim();
+  const rest = parts.slice(1);
+  if (rest.length > 1 && RTK_WRAPPERS.has((rest[0] ?? "").toLowerCase())) rest.shift();
+  return rest.join(" ");
+}
+function shellKind(command) {
+  if (!command) return "unclassified";
+  const wrapped = command.trim().toLowerCase().startsWith("rtk ");
+  const unwrapped = unwrapRtk(command);
+  const verb = (unwrapped.split(/\s+/)[0] ?? "").toLowerCase();
+  if (wrapped && RTK_READ_VERBS.has(verb)) return "exploration";
+  if (VERIFY_COMMAND.test(unwrapped)) return "verification";
+  if (EXPLORE_COMMAND.test(unwrapped)) return "exploration";
+  return "unclassified";
+}
+function callKind(name, args) {
+  if (EDIT_TOOLS.has(name)) return "implementation";
+  if (EXPLORE_TOOLS.has(name)) return "exploration";
+  if (SHELL_TOOLS.has(name)) {
+    let command;
+    if (args) {
+      try {
+        const parsed = JSON.parse(args);
+        if (typeof parsed.command === "string") command = parsed.command;
+      } catch {
+        command = void 0;
+      }
+    }
+    return shellKind(command);
+  }
+  return "unclassified";
+}
+function classifyRound(calls) {
+  if (!calls.length) return "unclassified";
+  let best = "unclassified";
+  for (const call of calls) {
+    const kind = callKind(call.name, call.args);
+    if (kind === "unclassified") return "unclassified";
+    if (KIND_RANK[kind] > KIND_RANK[best]) best = kind;
+  }
+  return best;
+}
+function transcriptStats(messages) {
+  let assistantTurns = 0;
+  let toolMessages = 0;
+  let contextChars = 0;
+  const media = { counts: {}, payloadChars: 0 };
+  const list = messages ?? [];
+  for (const raw of list) {
+    const message = raw;
+    const role = String(message?.role ?? "");
+    if (role === "assistant") assistantTurns += 1;
+    if (role === "tool") toolMessages += 1;
+    contextChars += textOf(message?.content).length;
+    if (message?.tool_calls) contextChars += JSON.stringify(message.tool_calls).length;
+    tallyMedia(message?.content, media);
+  }
+  return { messageCount: list.length, assistantTurns, toolMessages, contextChars, media };
+}
+function measuredContextTokens(usage) {
+  if (!usage) return void 0;
+  const total = usage.totalTokens ?? (usage.promptTokens ?? 0) + (usage.completionTokens ?? 0);
+  return Number.isFinite(total) && total > 0 ? Math.floor(total) : void 0;
+}
+
+// packages/core/src/policy.ts
+var POLICY_ORDER = [
+  "stuck",
+  "failure",
+  "context-pressure",
+  "transport",
+  "first-turn",
+  "verification",
+  "implementation",
+  "exploration",
+  "unclassified"
+];
+var REASONS = {
+  failure: (state) => `failure evidence: ${state.failureEvidence[0] ?? "unknown"}`,
+  stuck: (state) => `repeated failure (streak ${state.failureStreak ?? 2}); investigate instead of escalating more`,
+  "context-pressure": (state) => `context ${state.contextTokens ?? state.estimatedTokens} tokens vs window ${state.contextWindow ?? "unknown"}; prefer a big-window model`,
+  transport: (state) => `transport error (${state.failureEvidence[0] ?? "rate-limited"}), not a reasoning failure \u2014 retry, do not escalate`,
+  "first-turn": (state) => state.assistantTurns === 0 ? "new session, no prior turns" : "new user instruction",
+  verification: () => "verification round (tests/build/check)",
+  implementation: () => "implementation round (edits)",
+  exploration: () => "exploration round (read/search/bookkeeping)",
+  unclassified: () => "unclassified round"
+};
+function matches(condition, state) {
+  switch (condition) {
+    case "failure":
+      return state.failure === "hard";
+    case "stuck":
+      return state.repeatedFailure === true;
+    case "context-pressure":
+      return state.contextTokens !== void 0 && state.contextWindow !== void 0 && state.contextTokens > 0.9 * state.contextWindow;
+    case "transport":
+      return state.failure === "transport";
+    case "first-turn":
+      return state.roundKind === "first-turn";
+    case "verification":
+      return state.roundKind === "verification";
+    case "implementation":
+      return state.roundKind === "implementation";
+    case "exploration":
+      return state.roundKind === "exploration";
+    case "unclassified":
+      return state.roundKind === "unclassified";
+  }
+}
+function decideTier(state, policy, options = {}) {
+  const exclude = new Set(options.exclude ?? []);
+  for (const condition of POLICY_ORDER) {
+    if (exclude.has(condition)) continue;
+    if (condition === "stuck") {
+      if (state.repeatedFailure === true) {
+        const tier2 = options.stuckTier && options.stuckTier !== "off" ? options.stuckTier : policy.stuck;
+        if (tier2 && tier2 !== "off") {
+          return { rule: "stuck", tier: tier2, reason: REASONS.stuck(state) };
+        }
+      }
+      continue;
+    }
+    const tier = policy[condition];
+    if (!tier || tier === "off") continue;
+    if (matches(condition, state)) {
+      return { rule: condition, tier, reason: REASONS[condition](state) };
+    }
+  }
+  const fallback = policy.unclassified;
+  return {
+    rule: "fallback",
+    tier: fallback && fallback !== "off" ? fallback : "cheap",
+    reason: "no policy rule matched; fallback tier"
+  };
+}
+
+// packages/core/src/compatibility.ts
+function servesInputModalities(declared, required) {
+  if (!declared) return true;
+  return required.every((modality) => declared.includes(modality));
+}
+function firstServingTier(tiers, required, declared) {
+  for (const [name, tier] of Object.entries(tiers)) {
+    if (servesInputModalities(declared(tier), required)) return name;
+  }
+  return void 0;
+}
+
+// packages/core/src/config.ts
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var CONFIG_FILE = "sabi.config.json";
+var PACKAGE_ROOT = fileURLToPath(new URL("../", import.meta.url));
+function userConfigPath(env) {
+  const base = env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), ".config");
+  return path.join(base, "sabi", CONFIG_FILE);
+}
+function nearestConfigAbove(start) {
+  let dir = path.resolve(start);
+  for (; ; ) {
+    const candidate = path.join(dir, CONFIG_FILE);
+    if (existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function configSearchPaths(options = {}) {
+  const env = options.env ?? process.env;
+  const explicit = env.SABI_CONFIG?.trim();
+  if (explicit) return [explicit];
+  const candidates = [
+    path.join(options.cwd ?? process.cwd(), CONFIG_FILE),
+    userConfigPath(env)
+  ];
+  const above = nearestConfigAbove(options.packageRoot ?? PACKAGE_ROOT);
+  if (above) candidates.push(above);
+  return candidates;
+}
+function defaultConfigPath(options = {}) {
+  const candidates = configSearchPaths(options);
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+function loadConfig(configPath = defaultConfigPath()) {
+  let text;
+  try {
+    text = readFileSync(configPath, "utf8");
+  } catch {
+    const searched = configSearchPaths();
+    const hint = searched.length > 1 ? `searched: ${searched.join(", ")} \u2014 set SABI_CONFIG to point at one` : "set SABI_CONFIG to point at one";
+    throw new Error(`Sabi config not found at ${configPath} (${hint})`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Sabi config ${configPath} is not valid JSON: ${error.message}`);
+  }
+  return validateConfig(parsed, configPath);
+}
+var MODALITIES = ["text", "image", "audio", "video", "file"];
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateModelMetadata(value, label) {
+  if (!isObject(value)) throw new Error(`${label} must be an object`);
+  const fail = (field, expected) => {
+    throw new Error(`${label}.${field} ${expected}`);
+  };
+  const integer = (number, field, minimum = 1) => {
+    if (typeof number !== "number" || !Number.isSafeInteger(number) || number < minimum) {
+      fail(field, `must be a safe integer >= ${minimum}`);
+    }
+  };
+  for (const field of ["contextWindow", "maxOutputTokens"]) {
+    if (value[field] !== void 0) integer(value[field], field);
+  }
+  if (typeof value.contextWindow === "number" && typeof value.maxOutputTokens === "number" && value.maxOutputTokens > value.contextWindow) {
+    fail("maxOutputTokens", "cannot exceed contextWindow");
+  }
+  if (value.capabilities !== void 0) {
+    if (!isObject(value.capabilities)) fail("capabilities", "must be an object");
+    const capabilities = value.capabilities;
+    const fields = [
+      "tools",
+      "parallelTools",
+      "strictTools",
+      "inputModalities",
+      "outputModalities",
+      "structuredOutput",
+      "reasoningEfforts",
+      "supportedParameters"
+    ];
+    for (const field of Object.keys(capabilities)) {
+      if (!fields.includes(field)) fail(`capabilities.${field}`, "is not a supported metadata field");
+    }
+    for (const field of ["tools", "parallelTools", "strictTools"]) {
+      if (capabilities[field] !== void 0 && typeof capabilities[field] !== "boolean") {
+        fail(`capabilities.${field}`, "must be a boolean");
+      }
+    }
+    if (capabilities.tools === false && (capabilities.parallelTools === true || capabilities.strictTools === true)) {
+      fail("capabilities.tools", "cannot be false when parallelTools or strictTools is true");
+    }
+    for (const field of ["inputModalities", "outputModalities", "structuredOutput", "reasoningEfforts", "supportedParameters"]) {
+      const items = capabilities[field];
+      if (items === void 0) continue;
+      if (!Array.isArray(items) || items.some((item) => typeof item !== "string" || !item.trim())) {
+        fail(`capabilities.${field}`, "must be an array of nonempty strings");
+      }
+      const strings = items;
+      if (new Set(strings).size !== strings.length) fail(`capabilities.${field}`, "must not contain duplicates");
+      const allowed = field.endsWith("Modalities") ? MODALITIES : field === "structuredOutput" ? ["json_object", "json_schema"] : void 0;
+      if (allowed && strings.some((item) => !allowed.includes(item))) {
+        fail(`capabilities.${field}`, `must contain only: ${allowed.join(", ")}`);
+      }
+    }
+  }
+  if (value.contextAccounting !== void 0) {
+    if (!isObject(value.contextAccounting)) fail("contextAccounting", "must be an object");
+    const accounting = value.contextAccounting;
+    for (const field of Object.keys(accounting)) {
+      if (!["textTokensPerByte", "requestOverheadTokens", "perMessageOverheadTokens", "mediaTokens"].includes(field)) {
+        fail(`contextAccounting.${field}`, "is not a supported metadata field");
+      }
+    }
+    if (typeof accounting.textTokensPerByte !== "number" || !Number.isFinite(accounting.textTokensPerByte) || accounting.textTokensPerByte <= 0) {
+      fail("contextAccounting.textTokensPerByte", "must be a positive finite number");
+    }
+    integer(accounting.requestOverheadTokens, "contextAccounting.requestOverheadTokens", 0);
+    integer(accounting.perMessageOverheadTokens, "contextAccounting.perMessageOverheadTokens", 0);
+    if (accounting.mediaTokens !== void 0) {
+      if (!isObject(accounting.mediaTokens)) fail("contextAccounting.mediaTokens", "must be an object");
+      for (const [modality, tokens] of Object.entries(accounting.mediaTokens)) {
+        if (!MODALITIES.slice(1).includes(modality)) fail(`contextAccounting.mediaTokens.${modality}`, "is not a supported modality");
+        integer(tokens, `contextAccounting.mediaTokens.${modality}`);
+      }
+    }
+  }
+  if (value.cost !== void 0) {
+    if (!isObject(value.cost)) fail("cost", "must be an object");
+    const rates = value.cost;
+    for (const field of ["input", "output", ...rates.cacheRead !== void 0 ? ["cacheRead"] : []]) {
+      if (typeof rates[field] !== "number" || !Number.isFinite(rates[field]) || rates[field] < 0) {
+        fail(`cost.${field}`, "must be a nonnegative finite number");
+      }
+    }
+  }
+}
+function validateConfig(value, source = "<inline>") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Sabi config ${source}: expected a JSON object`);
+  }
+  const config = value;
+  const upstreams = config.upstreams ?? {};
+  const models = config.models ?? {};
+  const aliases = config.aliases ?? {};
+  const policy = config.policy ?? {};
+  for (const [name, entries] of Object.entries({ upstreams, models, aliases, policy })) {
+    if (!isObject(entries)) throw new Error(`Sabi config ${source}: ${name} must be an object`);
+  }
+  if (config.compatibility !== void 0) {
+    if (!isObject(config.compatibility) || !["legacy", "strict"].includes(config.compatibility.mode)) {
+      throw new Error(`Sabi config ${source}: compatibility.mode must be 'legacy' or 'strict'`);
+    }
+    if (Object.keys(config.compatibility).some((field) => field !== "mode")) {
+      throw new Error(`Sabi config ${source}: compatibility has an unknown field`);
+    }
+  }
+  if (!Object.keys(upstreams).length) throw new Error(`Sabi config ${source}: no upstreams declared`);
+  for (const [name, upstream] of Object.entries(upstreams)) {
+    if (!upstream || typeof upstream.baseURL !== "string" || !upstream.baseURL) {
+      throw new Error(`Sabi config ${source}: upstream '${name}' has no baseURL`);
+    }
+    try {
+      new URL(upstream.baseURL);
+    } catch {
+      throw new Error(`Sabi config ${source}: upstream '${name}' has an invalid baseURL`);
+    }
+    if (upstream.enabled !== void 0 && typeof upstream.enabled !== "boolean") {
+      throw new Error(`Sabi config ${source}: upstream '${name}'.enabled must be a boolean`);
+    }
+  }
+  if (!Object.keys(models).length) throw new Error(`Sabi config ${source}: no models declared`);
+  for (const [name, model] of Object.entries(models)) {
+    validateModelMetadata(model, `Sabi config ${source}: model tier '${name}'`);
+    if (!model || typeof model.model !== "string" || !model.model) {
+      throw new Error(`Sabi config ${source}: model tier '${name}' has no model id`);
+    }
+    if (typeof model.upstream !== "string" || !Object.hasOwn(upstreams, model.upstream)) {
+      throw new Error(`Sabi config ${source}: model tier '${name}' references unknown upstream '${model.upstream}'`);
+    }
+  }
+  if (!Object.keys(aliases).length) throw new Error(`Sabi config ${source}: no aliases declared`);
+  for (const [alias, target] of Object.entries(aliases)) {
+    if (typeof target !== "string" || target !== "auto" && !Object.hasOwn(models, target)) {
+      throw new Error(`Sabi config ${source}: alias '${alias}' targets unknown tier '${target}'`);
+    }
+  }
+  for (const [condition, tier] of Object.entries(policy)) {
+    if (typeof tier !== "string" || tier !== "off" && !Object.hasOwn(models, tier)) {
+      throw new Error(`Sabi config ${source}: policy rule '${condition}' targets unknown tier '${tier}'`);
+    }
+  }
+  const judge = config.judge;
+  if (judge !== void 0) {
+    if (typeof judge !== "object" || judge === null || typeof judge.enabled !== "boolean") {
+      throw new Error(`Sabi config ${source}: judge.enabled must be a boolean`);
+    }
+    if (judge.enabled) {
+      if (typeof judge.baseURL !== "string" || !judge.baseURL) {
+        throw new Error(`Sabi config ${source}: judge.baseURL is required when the judge is enabled`);
+      }
+      try {
+        new URL(judge.baseURL);
+      } catch {
+        throw new Error(`Sabi config ${source}: judge.baseURL is not a valid URL`);
+      }
+      if (judge.model !== void 0 && typeof judge.model !== "string") {
+        throw new Error(`Sabi config ${source}: judge.model must be a string`);
+      }
+      if (judge.callOn !== void 0) {
+        if (!Array.isArray(judge.callOn) || judge.callOn.some((rule) => typeof rule !== "string")) {
+          throw new Error(`Sabi config ${source}: judge.callOn must be an array of policy rule names`);
+        }
+      }
+      for (const [name, value2] of Object.entries(judge.thresholds ?? {})) {
+        if (typeof value2 !== "number" || value2 < 0 || value2 > 1) {
+          throw new Error(`Sabi config ${source}: judge.thresholds.${name} must be a number between 0 and 1`);
+        }
+      }
+      for (const [name, value2] of [
+        ["timeoutMs", judge.timeoutMs],
+        ["cacheTtlMs", judge.cacheTtlMs],
+        ["maxStateChars", judge.maxStateChars],
+        ["costPerMTokInput", judge.costPerMTokInput]
+      ]) {
+        if (value2 !== void 0 && (typeof value2 !== "number" || value2 <= 0)) {
+          throw new Error(`Sabi config ${source}: judge.${name} must be a positive number`);
+        }
+      }
+    }
+  }
+  const telemetry = config.telemetry;
+  if (telemetry !== void 0) {
+    if (typeof telemetry !== "object" || telemetry === null) {
+      throw new Error(`Sabi config ${source}: telemetry must be an object`);
+    }
+    if (telemetry.allowlistOnly !== void 0 && typeof telemetry.allowlistOnly !== "boolean") {
+      throw new Error(`Sabi config ${source}: telemetry.allowlistOnly must be a boolean`);
+    }
+    if (telemetry.captureSnippets !== void 0 && typeof telemetry.captureSnippets !== "boolean") {
+      throw new Error(`Sabi config ${source}: telemetry.captureSnippets must be a boolean`);
+    }
+    if (telemetry.captureChars !== void 0 && (typeof telemetry.captureChars !== "number" || telemetry.captureChars <= 0)) {
+      throw new Error(`Sabi config ${source}: telemetry.captureChars must be a positive number`);
+    }
+  }
+  const harness = config.harness;
+  if (harness !== void 0) {
+    if (typeof harness !== "object" || harness === null) {
+      throw new Error(`Sabi config ${source}: harness must be an object`);
+    }
+    if (!harness.tiers || typeof harness.tiers !== "object" || Array.isArray(harness.tiers)) {
+      throw new Error(`Sabi config ${source}: harness.tiers must be an object mapping tier names to models`);
+    }
+    for (const [tierName, tier] of Object.entries(harness.tiers)) {
+      if (!tier || typeof tier !== "object" || typeof tier.model !== "string" || !tier.model) {
+        throw new Error(`Sabi config ${source}: harness.tiers.${tierName} must declare a model id`);
+      }
+      if (tier.effort !== void 0 && typeof tier.effort !== "string") {
+        throw new Error(`Sabi config ${source}: harness.tiers.${tierName}.effort must be a string`);
+      }
+      if (tier.minPlan !== void 0 && typeof tier.minPlan !== "string") {
+        throw new Error(`Sabi config ${source}: harness.tiers.${tierName}.minPlan must be a string`);
+      }
+    }
+  }
+  return { ...config, upstreams, models, aliases, policy };
+}
+
+// packages/core/src/harness.ts
+function roundKindOf(round, calls) {
+  if (round.assistantTurns === 0 || round.lastRole === "user") return "first-turn";
+  if (round.lastRole === "tool") return classifyRound(calls);
+  return "unclassified";
+}
+function trajectoryFromRound(round, previous) {
+  const calls = round.calls.map((call) => ({ name: call.name, args: call.args }));
+  const outputs = round.calls.map((call) => call.output ?? "").filter((output) => output.trim().length > 0);
+  const detected = detectFailure(outputs);
+  const failed = round.calls.some((call) => call.failed === true);
+  const failure = failed ? detected.level === "transport" ? "transport" : "hard" : detected.level === "soft" ? "soft" : "none";
+  const failureEvidence = failed ? detected.evidence.length > 0 ? detected.evidence : ["tool-error"] : detected.evidence;
+  const contextTokens = round.contextTokens ?? Math.ceil(round.contextChars / CHARS_PER_TOKEN) + mediaTokens(roundMedia(round));
+  const sameFailure = previous?.failure === "hard" && failure === "hard";
+  const repeatedFailure = sameFailure === true;
+  const failureStreak = repeatedFailure ? 2 : failure === "hard" ? 1 : 0;
+  return {
+    messageCount: round.messageCount,
+    assistantTurns: round.assistantTurns,
+    toolMessages: round.calls.length,
+    lastRole: round.lastRole,
+    contextChars: round.contextChars,
+    estimatedTokens: Math.ceil(round.contextChars / CHARS_PER_TOKEN) + mediaTokens(roundMedia(round)),
+    contextTokens,
+    contextKnown: true,
+    hasTools: round.hasTools,
+    toolNames: round.toolNames,
+    lastToolNames: calls.map((call) => call.name),
+    roundKind: roundKindOf(round, calls),
+    failure,
+    failureEvidence,
+    repeatedFailure,
+    failureStreak,
+    ...round.contextGeneration ? { contextGeneration: round.contextGeneration } : {},
+    ...round.inputModalities ? { inputModalities: round.inputModalities } : {},
+    ...round.mediaCounts && Object.keys(round.mediaCounts).length ? { inputModalities: round.inputModalities ?? modalitiesOf(round.mediaCounts), mediaCounts: round.mediaCounts } : {}
+  };
+}
+function roundMedia(round) {
+  return { counts: round.mediaCounts ?? {}, payloadChars: 0 };
+}
+function planRound(state, policy, tiers, options = {}) {
+  const withWindow = options.contextWindow !== void 0 && state.contextWindow === void 0 ? { ...state, contextWindow: options.contextWindow } : state;
+  const decision = decideTier(withWindow, policy, { stuckTier: policy.stuck });
+  const required = withWindow.inputModalities ?? [];
+  let tier = decision.tier;
+  let rule = decision.rule;
+  let reason = decision.reason;
+  const planned = tiers[tier];
+  if (planned && !servesInputModalities(planned.inputModalities, required)) {
+    const alternate = firstServingTier(tiers, required, (entry) => entry.inputModalities);
+    if (!alternate) return void 0;
+    reason = `input needs ${required.join("+")}; '${tier}' (${planned.model}) cannot accept it, '${alternate}' can`;
+    rule = "capability";
+    tier = alternate;
+  }
+  const chosen = tiers[tier];
+  if (!chosen || !chosen.model) return void 0;
+  return {
+    tier,
+    model: chosen.model,
+    effort: chosen.effort,
+    rule,
+    reason,
+    state: withWindow
+  };
+}
+
+// packages/core/src/telemetry.ts
+var ALLOWLIST = /* @__PURE__ */ new Set([
+  "error-line",
+  "python-traceback",
+  "panic",
+  "exception",
+  "typescript-error",
+  "fail-marker",
+  "command-failed",
+  "nonzero-exit",
+  "failure-count",
+  "command-not-found",
+  "permission-denied",
+  "missing-file",
+  "soft-warning",
+  "soft-deprecated",
+  "soft-retrying",
+  "soft-timeout",
+  "tool-error",
+  "permission-denial",
+  "rate-limited",
+  "quota-exceeded",
+  "timeout"
+]);
+function allowlisted(value) {
+  const code = value.split(":")[0]?.trim();
+  return ALLOWLIST.has(code);
+}
+function telemetryPolicy(config) {
+  const captureSnippets = config?.captureSnippets === true;
+  const captureChars = config?.captureChars ?? 800;
+  return {
+    captureSnippets,
+    allowlisted: (value) => allowlisted(value),
+    snippet: (value) => captureSnippets ? String(value).slice(0, captureChars) : ""
+  };
+}
+function sanitizeReason(reason, policy) {
+  if (!policy.captureSnippets) {
+    if (!reason || allowlisted(reason)) return reason;
+    const segments = reason.split(":").map((segment) => segment.trim());
+    const last = segments[segments.length - 1] ?? "";
+    if (allowlisted(last)) return reason;
+    return "reason withheld (telemetry.allowlistOnly)";
+  }
+  return policy.snippet(reason);
+}
+
+// packages/core/src/prompt.ts
+import * as readline from "node:readline/promises";
+
+// packages/adapters/command-code/mod/sabi.ts
+var MOD_ID = "sabi";
+var DECISION_TYPE = "sabi/decision";
+function readLedger(state) {
+  const raw = state.modState?.[MOD_ID] ?? {};
+  return {
+    rounds: typeof raw.rounds === "number" ? raw.rounds : 0,
+    messageCount: typeof raw.messageCount === "number" ? raw.messageCount : 0,
+    contextChars: typeof raw.contextChars === "number" ? raw.contextChars : 0,
+    contextTokens: typeof raw.contextTokens === "number" ? raw.contextTokens : void 0,
+    generation: typeof raw.generation === "number" ? raw.generation : void 0,
+    toolNames: Array.isArray(raw.toolNames) ? raw.toolNames : [],
+    hasTools: raw.hasTools === true,
+    lastModel: raw.lastModel,
+    lastUsage: raw.lastUsage
+  };
+}
+function writeLedger(state, ledger) {
+  return { ...state, modState: { ...state.modState, [MOD_ID]: ledger } };
+}
+function compactedSince(ledger, stats) {
+  return ledger.messageCount > 0 && stats.messageCount > 0 && stats.messageCount < ledger.messageCount;
+}
+function sabi(cmd) {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (error) {
+    cmd.ui.notify(`Sabi disabled: ${error.message}`);
+    return;
+  }
+  const tiers = config.harness?.tiers ?? {};
+  if (Object.keys(tiers).length === 0) {
+    cmd.ui.notify("Sabi disabled: sabi.config.json declares no harness.tiers");
+    return;
+  }
+  const policy = config.policy ?? {};
+  const telemetry = telemetryPolicy(config.telemetry);
+  let calls = [];
+  let nextPlan;
+  let servingPlan;
+  let servedBy;
+  let previousFailure;
+  cmd.on("model_request_end", (event) => {
+    if (typeof event.model === "string") servedBy = event.model;
+  });
+  cmd.hooks({
+    onTurnStart: ({ state, turnNumber }) => {
+      calls = [];
+      servingPlan = nextPlan;
+      nextPlan = void 0;
+      servedBy = void 0;
+      const ledger = readLedger(state);
+      return writeLedger(state, { ...ledger, rounds: turnNumber });
+    },
+    // Sabi observes tool outcomes and never rewrites what the model sees.
+    afterToolCall: ({ toolName, input, isError, result }) => {
+      calls.push({
+        name: toolName,
+        args: JSON.stringify(input ?? {}),
+        failed: isError === true,
+        output: typeof result === "string" ? result : void 0
+      });
+      return void 0;
+    },
+    prepareNextTurn: ({ state }) => {
+      const ledger = readLedger(state);
+      const stats = transcriptStats(state.messages);
+      if (compactedSince(ledger, stats)) {
+        previousFailure = void 0;
+        ledger.generation = (ledger.generation ?? 0) + 1;
+        ledger.contextTokens = void 0;
+      }
+      const round = {
+        messageCount: stats.messageCount,
+        assistantTurns: ledger.rounds,
+        lastRole: calls.length > 0 ? "tool" : "assistant",
+        contextChars: stats.contextChars,
+        contextTokens: ledger.contextTokens,
+        hasTools: ledger.hasTools,
+        toolNames: ledger.toolNames,
+        calls,
+        ...ledger.generation ? { contextGeneration: ledger.generation } : {},
+        ...Object.keys(stats.media.counts).length ? { inputModalities: modalitiesOf(stats.media.counts), mediaCounts: stats.media.counts } : {}
+      };
+      const trajectory = trajectoryFromRound(round, previousFailure);
+      const plan = planRound(trajectory, policy, tiers, { contextWindow: config.harness?.contextWindow });
+      if (!plan) return void 0;
+      nextPlan = plan;
+      return plan.effort ? { model: plan.model, effort: plan.effort } : { model: plan.model };
+    },
+    onTurnEnd: ({ state, turnNumber, usage }, ctx) => {
+      const ledger = readLedger(state);
+      const stats = transcriptStats(state.messages);
+      const compacted = compactedSince(ledger, stats);
+      const usedThisTurn = usage !== void 0;
+      const measured = usedThisTurn ? measuredContextTokens({ promptTokens: usage.inputTokens, completionTokens: usage.outputTokens }) : void 0;
+      const generation = (ledger.generation ?? 0) + (compacted ? 1 : 0);
+      const adopted = servingPlan ?? nextPlan;
+      const next = {
+        ...ledger,
+        rounds: turnNumber,
+        messageCount: stats.messageCount,
+        contextChars: stats.contextChars,
+        // A billed total is measured, so it floors the next round. Without usage the previous
+        // floor stands — the transcript only grows — except across a rewrite, where the old
+        // size described a context the host has removed.
+        contextTokens: measured ?? (compacted ? void 0 : ledger.contextTokens),
+        ...generation > 0 ? { generation } : {},
+        // Only advance attribution when a fresh value actually arrived this turn. A missing
+        // usage or model event stays unknown rather than re-serializing an old round's value.
+        lastModel: servedBy,
+        lastUsage: usedThisTurn ? usage : void 0
+      };
+      previousFailure = adopted ? { failure: adopted.state.failure, failureEvidence: adopted.state.failureEvidence } : void 0;
+      recordDecision(ctx, {
+        turn: turnNumber,
+        planned: servingPlan ? {
+          tier: servingPlan.tier,
+          model: servingPlan.model,
+          effort: servingPlan.effort,
+          rule: servingPlan.rule,
+          reason: sanitizeReason(String(servingPlan.reason ?? ""), telemetry),
+          roundKind: servingPlan.state.roundKind,
+          failure: servingPlan.state.failure,
+          evidence: servingPlan.state.failureEvidence.slice(0, 3),
+          repeatedFailure: servingPlan.state.repeatedFailure,
+          failureStreak: servingPlan.state.failureStreak,
+          contextTokens: servingPlan.state.contextTokens,
+          contextGeneration: servingPlan.state.contextGeneration,
+          inputModalities: servingPlan.state.inputModalities
+        } : void 0,
+        servedBy: servedBy ?? void 0,
+        usage: usedThisTurn ? usage : void 0,
+        // Decision records never embed raw tool output by default; snippet capture is opt-in.
+        captureSnippets: telemetry.captureSnippets
+      });
+      return writeLedger(state, next);
+    }
+  });
+}
+function recordDecision(ctx, data) {
+  ctx?.session?.appendCustomEntry({ customType: DECISION_TYPE, data });
+}
+export {
+  sabi as default
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@vizuh/sabi",
+  "version": "0.1.0",
+  "description": "Adaptive inference scheduling for Command Code: one bundled mod that routes each continuing round by model, effort and trajectory state.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vizuh/sabi.git",
+    "directory": "packages/adapters/command-code"
+  },
+  "homepage": "https://github.com/vizuh/sabi#readme",
+  "keywords": [
+    "commandcode",
+    "command-code",
+    "mod",
+    "llm",
+    "routing"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "commandcode": {
+    "mods": [
+      "./mod/sabi.mjs"
+    ]
+  },
+  "files": [
+    "mod/sabi.mjs",
+    "sabi.config.json",
+    "README.md"
+  ]
+}

package/sabi.config.json

@@ -0,0 +1,109 @@
+{
+  "provenance": "Model ids, context windows and prices verified live from https://openrouter.ai/api/v1/models on 2026-09-18; input modalities for the same ids verified from the same endpoint the same day (`architecture.input_modalities`). Prices are USD per 1M tokens. Declared modalities are enforced: an undeclared capability is unknown, a declared one is binding.",
+  "server": { "host": "127.0.0.1", "port": 8787 },
+  "upstreams": {
+    "openrouter": {
+      "baseURL": "https://openrouter.ai/api/v1",
+      "apiKey": "$OPENROUTER_API_KEY",
+      "streamUsage": true,
+      "headers": {
+        "HTTP-Referer": "https://github.com/vizuh/sabi",
+        "X-Title": "Sabi"
+      }
+    },
+    "ollama": {
+      "baseURL": "http://127.0.0.1:11434/v1",
+      "apiKey": false,
+      "streamUsage": false
+    }
+  },
+  "models": {
+    "cheap": {
+      "upstream": "openrouter",
+      "model": "deepseek/deepseek-v4-flash-0731",
+      "contextWindow": 1310720,
+      "capabilities": { "inputModalities": ["text"] },
+      "cost": { "input": 0.06, "output": 0.12, "cacheRead": 0.012 }
+    },
+    "mid": {
+      "upstream": "openrouter",
+      "model": "openai/gpt-5.6-luna",
+      "contextWindow": 1050000,
+      "capabilities": { "inputModalities": ["text", "image", "file"] },
+      "cost": { "input": 0.2, "output": 1.2, "cacheRead": 0.02 }
+    },
+    "strong": {
+      "upstream": "openrouter",
+      "model": "anthropic/claude-sonnet-5",
+      "contextWindow": 1000000,
+      "capabilities": { "inputModalities": ["text", "image", "file"] },
+      "cost": { "input": 2, "output": 10, "cacheRead": 0.2 }
+    },
+    "local": {
+      "upstream": "ollama",
+      "model": "qwen2.5-coder:7b",
+      "contextWindow": 32768,
+      "capabilities": { "inputModalities": ["text"] },
+      "cost": { "input": 0, "output": 0 }
+    }
+  },
+  "aliases": {
+    "sabi-code": "auto",
+    "sabi-cheap": "cheap",
+    "sabi-mid": "mid",
+    "sabi-strong": "strong",
+    "sabi-local": "local"
+  },
+  "policy": {
+    "failure": "strong",
+    "stuck": "mid",
+    "context-pressure": "mid",
+    "transport": "mid",
+    "first-turn": "mid",
+    "verification": "mid",
+    "implementation": "mid",
+    "exploration": "cheap",
+    "unclassified": "cheap"
+  },
+  "telemetry": {
+    "allowlistOnly": true,
+    "captureSnippets": false,
+    "captureChars": 800
+  },
+  "judge": {
+    "enabled": true,
+    "baseURL": "https://api.typesafe.ai/v1",
+    "apiKey": "$TYPESAFE_API_KEY",
+    "model": "jev-latest",
+    "timeoutMs": 2500,
+    "cacheTtlMs": 600000,
+    "callOn": ["failure", "unclassified"],
+    "thresholds": { "realProblem": 0.6, "veto": 0.25, "difficultyConfidence": 0.6 },
+    "maxStateChars": 6000,
+    "costPerMTokInput": 0.042
+  },
+  "harness": {
+    "provenance": "Command Code catalog ids, efforts and min plans verified 2026-09-18 against `cmd --list-models` and the bundled reference models.md. Used by the in-process mod adapter (harness keeps its own loop, no proxy, no key). The `models` tiers above are the separate BYOK proxy path and are unused while the mod is active. A tier must be a model the account can actually serve: `cmd --list-models` prints the whole catalog regardless of plan, and an out-of-plan model answers 403 MODEL_NOT_IN_PLAN and fails that round. The defaults are the strongest ids available from the Go plan up; docs/install.md lists Pro and Max presets. `contextWindow` is the largest verified window among the tiers (1M), used by the context-pressure rule. `inputModalities` mirror the CLI's own model registry, read from the shipped bundle on 2026-09-18: plain `deepseek-v4-flash` and `glm-5.3` are text-only while `gpt-5.6-luna` accepts images. The host strips images for a text-only model, so a tier that cannot read them is passed over for one that can.",
+    "tiers": {
+      "cheap": {
+        "model": "deepseek/deepseek-v4-flash",
+        "effort": "high",
+        "minPlan": "Go",
+        "inputModalities": ["text"]
+      },
+      "mid": {
+        "model": "gpt-5.6-luna",
+        "effort": "high",
+        "minPlan": "Go",
+        "inputModalities": ["text", "image"]
+      },
+      "strong": {
+        "model": "zai-org/glm-5.3",
+        "effort": "high",
+        "minPlan": "Go",
+        "inputModalities": ["text"]
+      }
+    },
+    "contextWindow": 1000000
+  }
+}