trantor 0.18.91 → 0.18.92

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.91",
+  "version": "0.18.92",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {

package/bin/crew/models.mjs

@@ -10,21 +10,26 @@ function routeModel(ctx, provider, candidates, task, difficulty) {
     ? [script, "route", "--candidates", candidates, "-t", task, "-d", difficulty, "--json"]
     : [script, "route", "--provider", provider, "-t", task, "-d", difficulty, "--json"];
   const result = call("python3", args, { env: ctx.env });
-  if (!result.ok || !result.stdout) return "";
-  try { return JSON.parse(result.stdout).qualified || ""; }
-  catch { return ""; }
+  try {
+    const decision = JSON.parse(result.stdout);
+    if (decision.error) throw new Error(`[crew] router refused ${provider}: ${decision.error}`);
+    return result.ok ? decision.qualified || "" : "";
+  } catch (error) {
+    if (error instanceof SyntaxError) return "";
+    throw error;
+  }
 }
 
 export function resolveModel(ctx, agent, provider, task, difficulty) {
   const result = call("opencode", ["models", provider], { env: ctx.env });
   const candidates = result.ok ? result.stdout.split(/\s+/).filter(Boolean).join(" ") : "";
   let model = routeModel(ctx, provider, candidates, task, difficulty);
-  if (!model && candidates) {
-    const first = candidates.split(" ")[0];
-    model = first.startsWith(`${provider}/`) ? first : `${provider}/${first}`;
-    console.error(`[crew] router unavailable for ${agent}:${provider} — using the provider's own catalog head (${model})`);
+  // An unavailable router must not erase seats from a layout preview. Never launch an unresolved model.
+  if (!model && ctx.dry && candidates) {
+    model = `${provider}/<unresolved>`;
+    console.error(`[crew] dry run only for ${agent}:${provider} — router unavailable; model unresolved, live launch would be refused`);
   }
-  if (!model) throw new Error(`[crew] live model selection failed for ${agent}:${provider} — no router and no catalog; refusing opencode global default`);
+  if (!model) throw new Error(`[crew] live model selection failed for ${agent}:${provider} — no priced model matching provider preference; refusing opencode global default`);
   if (model.split("/")[0] !== provider) throw new Error(`[crew] router selected ${model} outside ${provider} — refusing cross-provider fallback`);
   return model;
 }
@@ -50,7 +55,7 @@ export function resolveSpec(ctx, spec, task, difficulty, skipped) {
     const model = resolveModel(ctx, agent, field, task, difficulty);
     // #7777: the live model is known — attach the catalog's per-difficulty effort parameters here
     // so the runner applies them where the CLI accepts them (CREW_EFFORT, below).
-    console.log(`  → ${agent}: live model ${model} (${field} · ${task}/${difficulty})`);
+    console.log(`  → ${agent}: ${model.endsWith("/<unresolved>") ? "preview" : "live"} model ${model} (${field} · ${task}/${difficulty})`);
     return { agent, model, effort: resolveEffort(agent, model, difficulty) };
   } catch (error) {
     console.error(error.message);

package/bin/models.mjs

@@ -1,10 +1,6 @@
 #!/usr/bin/env node
-// trantor models — browse the live models behind your crew seats (opencode is the adapter).
-//
-//   trantor models                # every opencode-driven seat + how many live models it serves
-//   trantor models <provider>     # list that provider's live models + what the router picks per
-//                                 # difficulty (so you can see hard→strong, easy→cheap at a glance)
-import { execSync } from "node:child_process";
+// Browse live crew models and preview the same routing used at launch.
+import { execSync, spawnSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { existsSync, statSync } from "node:fs";
@@ -25,16 +21,11 @@ const liveModels = (providerOc) => {
   catch { return []; }
 };
 
-const FLASH_TIER = /(flash|turbo|lite|mini|highspeed|small)/i;
-
 function routePick(candList, diff) {
-  try {
-    const hard = diff === "hard";
-    const strong = hard ? candList.filter(id => !FLASH_TIER.test(id)) : candList;
-    const pool = strong.length > 0 ? strong : candList;
-    const out = execSync(`python3 ${SCROOGE} route --candidates ${JSON.stringify(pool.join(" "))} -t code -d ${diff} --json 2>/dev/null`, { encoding: "utf8" });
-    return JSON.parse(out).qualified || "?";
-  } catch { return "?"; }
+  const result = spawnSync("python3", [SCROOGE, "route", "--candidates", candList.join(" "),
+    "-t", "code", "-d", diff, "--json"], { encoding: "utf8" });
+  try { return JSON.parse(result.stdout); }
+  catch { return { error: "router unavailable", unpriced: [] }; }
 }
 
 function listAll() {
@@ -57,12 +48,14 @@ function detail(name) {
   const models = liveModels(providerOc);
   if (!models.length) { console.log(`No live models for '${providerOc}' (opencode offline / no key / unknown provider).`); return; }
   console.log(`${C.gold}${providerOc}${C.off} — ${models.length} live models\n`);
-  for (const m of models.slice(0, 60)) console.log(`  ${m}`);
+  const picks = Object.fromEntries(["easy", "medium", "hard"].map(d => [d, routePick(models, d)]));
+  const unpriced = new Set(Object.values(picks).flatMap(p => p.unpriced || []));
+  for (const m of models.slice(0, 60)) console.log(`  ${m}${unpriced.has(m.split("/").at(-1)) ? " (unpriced)" : ""}`);
   if (models.length > 60) console.log(`  ${C.dim}… +${models.length - 60} more${C.off}`);
   if (existsSync(SCROOGE) || has("scrooge")) {
     console.log(`\n${C.gold}router picks (code task):${C.off}`);
-    for (const d of ["easy", "medium", "hard"]) console.log(`  ${d.padEnd(7)} → ${routePick(models, d)}`);
-    const caps = join(H, ".token-scrooge", "capabilities.json");
+    for (const d of ["easy", "medium", "hard"]) console.log(`  ${d.padEnd(7)} → ${picks[d].qualified || picks[d].error}`);
+    const caps = join(process.env.SCROOGE_HOME || join(H, ".token-scrooge"), "capabilities.json");
     // only nag when the scores are missing or older than the weekly refresh allows for
     const ageDays = existsSync(caps) ? (Date.now() - statSync(caps).mtimeMs) / 86400e3 : Infinity;
     if (ageDays > 9) console.log(`${C.dim}(scores ${ageDays === Infinity ? "missing" : `${Math.floor(ageDays)}d old`} — run scrooge-capabilities to (re)score the catalog for accurate difficulty routing)${C.off}`);

package/engine/bin/scrooge

@@ -37,7 +37,7 @@ Config:  $SCROOGE_HOME (default ~/.token-scrooge) holds registry.json + calls.js
 Keys:    read from the environment; optionally also from $SCROOGE_ENV_FILE (KEY=VALUE)
 Exit: 0 ok, non-zero on error (message to stderr).
 """
-import sys, os, json, time, argparse, urllib.request, urllib.error, re, shutil, hashlib
+import sys, os, json, time, argparse, urllib.request, urllib.error, re, shutil, hashlib, math
 
 HOME = os.path.expanduser("~")
 SCROOGE_DIR = os.environ.get("SCROOGE_HOME", os.path.join(HOME, ".token-scrooge"))
@@ -171,18 +171,26 @@ def model_quality(caps, mid, metric):
         v = c.get("intelligence")          # fall back to the general index
     return float(v) if isinstance(v, (int, float)) else 0.0
 
-def blended_cost(reg, caps, mid):
+def model_prices(reg, caps, mid):
     # The curated registry carries cost for its own models; for CATALOG models (OpenRouter's
     # hundreds, brought via --candidates) the per-model price rides on the capability entry
     # instead — so a brought model is ranked on its real price without bloating the registry.
-    m = reg["models"].get(mid) or (caps.get(mid) if isinstance(caps, dict) else None) or {}
-    return max(1e-6, 0.3 * m.get("cost_in", 0) + 0.7 * m.get("cost_out", 0))
+    for m in (reg["models"].get(mid) or {}, (caps or {}).get(mid) or {}):
+        prices = [m.get("cost_in"), m.get("cost_out")]
+        if all(type(v) in (int, float) and math.isfinite(v) and v >= 0 for v in prices):
+            return prices
+    return None
+
+def blended_cost(reg, caps, mid):
+    prices = model_prices(reg, caps, mid)
+    return max(1e-6, 0.3 * prices[0] + 0.7 * prices[1]) if prices is not None else None
 
 def weigh_candidates(reg, caps, cand_ids, task, difficulty):
     """Apply the difficulty floor, then rank survivors by quality^qw / cost^cw.
     Returns [(model_id, score)] best-first."""
     metric = task_metric(task)
-    quals = [(mid, model_quality(caps, mid, metric)) for mid in cand_ids]
+    quals = [(mid, model_quality(caps, mid, metric)) for mid in cand_ids
+             if blended_cost(reg, caps, mid) is not None]
     scored_q = sorted(q for _, q in quals if q > 0)
     pct = DIFF_PCTL.get(difficulty, 0.5)
     floor = 0.0
@@ -218,6 +226,9 @@ def route_task(reg, caps, task, difficulty, prompt, spread=0):
     live = [m for m in cands if provider_key(reg, reg["models"][m]["provider"])]
     if not live:
         raise SystemExit("No live API key for any model serving task '%s'." % task)
+    live = [m for m in live if blended_cost(reg, caps, m) is not None]
+    if not live:
+        raise SystemExit("No priced candidate models; enrich pricing before routing.")
     if not caps:                                   # no quality data → legacy cheapest-first
         return live[0], reg["models"][live[0]]["provider"], {"difficulty": None, "weighed": False}
     diff = difficulty or infer_difficulty(task, prompt)
@@ -659,7 +670,19 @@ def cmd_route(reg, args):
     by_bare = {}
     for r in raw:
         by_bare.setdefault(r.split("/")[-1], r)
-    bare_ids = list(by_bare.keys())
+    unpriced = [b for b in by_bare if blended_cost(reg, caps, b) is None]
+    bare_ids = [b for b in by_bare if b not in unpriced]
+    if not provider:
+        providers = {r.split("/")[0] for r in raw if "/" in r}
+        if len(providers) == 1:
+            provider = next(iter(providers))
+    if provider == "qwen":
+        preferred = "qwen3.8-max" if args.difficulty == "hard" else "qwen3.8-flash"
+        bare_ids = [b for b in bare_ids if b == preferred]
+    if not bare_ids:
+        print(json.dumps({"error": "no priced candidate models matching provider preference",
+                          "unpriced": unpriced}))
+        raise SystemExit(2)
     task = args.task or "code"
     difficulty = args.difficulty or "medium"
     metric = task_metric(task)
@@ -681,11 +704,13 @@ def cmd_route(reg, args):
     original = by_bare[pick_bare]
     qualified = original if "/" in original else (("%s/%s" % (provider, pick_bare)) if provider else pick_bare)
     result = {"provider": provider, "model": pick_bare, "qualified": qualified,
-              "weighed": weighed, "task": task, "difficulty": difficulty, "why": why, "candidates": cand_out}
+              "weighed": weighed, "task": task, "difficulty": difficulty, "why": why, "candidates": cand_out, "unpriced": unpriced}
     if getattr(args, "json", False):
         print(json.dumps(result))
     else:
         err(DIM("[scrooge route] %s → %s (%s)" % (provider or "?", qualified, "weighed" if weighed else "heuristic")))
+        if unpriced:
+            err("[scrooge route] unpriced (excluded): " + ", ".join(unpriced))
         print(qualified)
     return 0
 
@@ -704,7 +729,9 @@ def cmd_list(reg, args):
             q = caps.get(m) or {}
             fmt = lambda v: ("%2.0f" % v) if isinstance(v, (int, float)) else " -"
             cap = "%s/%s/%s " % (fmt(q.get("intelligence")), fmt(q.get("coding")), fmt(q.get("reasoning")))
-        print("  %s %-24s %5.2f/%-5.2f %s%-9s %s" % (live, m, c.get("cost_in",0), c.get("cost_out",0),
+        prices = model_prices(reg, caps, m)
+        price = "unpriced" if prices is None else "%5.2f/%-5.2f" % tuple(prices)
+        print("  %s %-24s %s %s%-9s %s" % (live, m, price,
               cap, c.get("trust",""), ",".join(c.get("good_for", []))))
     print("\nTASKS (weighed by capability×cost, gated by difficulty):")
     for t, ms in reg.get("tasks", {}).items():

package/engine/test-routing.py

@@ -36,8 +36,16 @@ def ok(name, cond):
 # 1. catalog cost via caps fallback (model absent from registry)
 ok("blended_cost falls back to the capability entry for catalog models",
    abs(g["blended_cost"](reg, caps, "frontier") - (0.3 * 5.0 + 0.7 * 22.5)) < 1e-6)
-ok("blended_cost is 1e-6 for an entirely unknown model (no crash)",
-   g["blended_cost"](reg, caps, "does-not-exist") == 1e-6)
+ok("unknown model is unpriced", g["blended_cost"](reg, caps, "does-not-exist") is None)
+for bad in ({}, {"cost_in": 1}, {"cost_in": None, "cost_out": 1},
+            {"cost_in": -1, "cost_out": 1}, {"cost_in": float("nan"), "cost_out": 1}):
+    ok("invalid or incomplete prices are unpriced", g["blended_cost"](reg, {"bad": bad}, "bad") is None)
+ok("explicit zero prices are free", g["blended_cost"](reg, {"free": {"cost_in": 0, "cost_out": 0}}, "free") == 1e-6)
+for diff in ("easy", "medium", "hard"):
+    mixed = {"priced": {"coding": 50, "cost_in": 2, "cost_out": 6}, "unpriced": {"coding": 99}}
+    ranked = g["weigh_candidates"](reg, mixed, list(mixed), "code", diff)
+    ok("priced beats stronger unpriced at " + diff, [m for m, _ in ranked] == ["priced"])
+ok("all unpriced yields no pick", g["weigh_candidates"](reg, {}, ["unknown"], "code", "easy") == [])
 
 def winner(diff):
     return g["weigh_candidates"](reg, caps, cands, "code", diff)[0][0]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.91",
+  "version": "0.18.92",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"