@lawaty/lacode 1.1.0 → 1.2.0

package/docs/CONFIGURATION.md

@@ -23,12 +23,22 @@ allowlist anywhere in the package, and no cost check of any kind: only the
 structure is validated. The bundled preset is built from free models because
 that is a sensible default, not because the pool requires it.
 
+A slot's `weight` (default 1) is both its concurrency budget and its cap. The
+pool fills slots in declaration order in one pass; there is no slot cap, and a
+model may appear on more than one line — each line is its own slot with its own
+weight. A `tier` key is the deprecated spelling of `weight`.
+
+A slot may also declare a shared quota bucket with `b:<name>` on the line (or a
+`bucket` field in JSON). A limit on any member benches the whole bucket, because
+the sibling would spend the same exhausted window; without one, the model is its
+own bucket. `pool_status` shows each shared bucket's effective capacity.
+
 
 ## Which models run which agent
 
 Only the **pool** writes a model onto a pooled agent, from whichever source wins
 above. The pooled bases (`explore`, `implement`, `context`)
-and their hidden `-1`..`-4` variants therefore carry no model of their own: a
+and their hidden `<base>-<slot>` variants therefore carry no model of their own: a
 model written next to an agent would be a second source of truth that silently
 wins whenever routing falls through. Spawn a base and let the pool route it.
 
@@ -39,7 +49,7 @@ wins whenever routing falls through. Spawn a base and let the pool route it.
 work around by configuring it.** If you keep a global `"tools"` block in your
 config — for example `"tools": { "playwright_*": false }` — then the pooled
 exploration and implementation bases (`explore` and `implement`, plus their
-hidden `-1`..`-4` pool variants) lose browser access, and **nothing tells them why**: the tool call is simply
+hidden `<base>-<slot>` pool variants, one per resolved slot) lose browser access, and **nothing tells them why**: the tool call is simply
 refused mid-task. `context` gets no grant either, which is correct — it
 writes the context map and has no business in a browser.
 
@@ -89,11 +99,11 @@ mention/direct-session case cannot be detected before it runs.
 
 ## What gets injected
 
-**18 agent keys**: the 5 bases `build`, `plan`, `explore`, `implement`,
-`context`, plus one hidden
-`<base>-1`..`-4` pool variant for each of the 3 pooled bases, plus the hidden
-`instructions` agent — the one writer of the project's root `AGENTS.md`,
-reachable only from the `/agent-instructions` command.
+**One key per base, plus a variant per slot**: the 5 bases `build`, `plan`,
+`explore`, `implement`, `context`, one hidden `<base>-<slot>` pool variant per
+resolved slot for each of the 3 pooled bases, and the hidden `instructions`
+agent — the one writer of the project's root `AGENTS.md`, reachable only from
+the `/agent-instructions` command.
 
 `build` and `plan` exist in opencode as built-ins, so on a stock config those
 two keys are already taken and merge-without-clobber keeps the built-in — the

package/docs/USER-STORIES.md

@@ -15,7 +15,7 @@ line. Criteria that cannot be observed without a running server are not in this
 document; everything here is testable offline with a stub client and a
 `mkdtempSync` state directory.
 
-**Terminology.** A *slot* is one entry in `presets/free-tier.json`, carrying a model and a `weight`. A slot's `weight` is its active-session budget for one pass: the number of concurrent claims it may hold before the next slot is preferred. A *pass* is one declaration-order sweep of the slot list; the pool runs at most two passes, and a slot's absolute cap is twice its weight. Preference is by declaration order, never by weight. A *base* is a pooled agent type (`explore`), and its slot holders are `<base>-<slot>`, hidden in `opencode.jsonc`. A *claim* is a running spawn recorded in `claims.<pid>.json`. A *context map* is the five-file `.opencode/context/` codemap described in Epic G.
+**Terminology.** A *slot* is one entry in `presets/free-tier.json`, carrying a model and a `weight`. A slot's `weight` is its active-session budget for one pass: the number of concurrent claims it may hold before the next slot is preferred. A *pass* is one declaration-order sweep of the slot list; the pool runs one pass, and a slot's cap is its weight. There is no slot cap, and a model may appear on more than one line — each line is its own slot with its own weight. Preference is by declaration order, never by weight. A *base* is a pooled agent type (`explore`), and its slot holders are `<base>-<slot>`, hidden in `opencode.jsonc`. A *claim* is a running spawn recorded in `claims.<pid>.json`. A *context map* is the five-file `.opencode/context/` codemap described in Epic G.
 
 ---
 
@@ -92,18 +92,18 @@ The reconciliation with US-7 is that **acceptance and endorsement are different
 - [ ] Given every model is cooling, When a spawn is routed, Then the least-loaded slot is chosen anyway (degrade, never block).
 - [ ] Given a limit error names a reset time, When the cooldown is recorded, Then the stated reset is used instead of a guessed backoff.
 
-### US-5: Slots fill in declaration order, in up to two passes
+### US-5: Slots fill in declaration order in one pass, with repeats
 **As a** user, **I want** work to prefer the first slot and spill to later slots only when the earlier ones are full, **so that** a healthy preferred model is used before fallbacks and no slot is used while an earlier usable slot has room.
 
 **Story ID(s) for tests:** US-5
 **Acceptance criteria:**
-- [ ] Given live claims, When the pool has room in the first pass, Then the lowest-index usable slot whose load is below its weight is chosen, and a slot declared later is not used until every earlier usable slot has reached its weight.
-- [ ] Given every usable slot has reached its weight, When another spawn is routed, Then the second pass begins at the lowest-index slot and fills each usable slot up to twice its weight.
-- [ ] Given a slot is cooling or unavailable, When its position in the pass comes up, Then it is skipped and the pass continues to the next slot.
+- [ ] Given live claims, When the pool has room, Then the lowest-index usable slot whose load is below its weight is chosen, and a slot declared later is not used until every earlier usable slot has reached its weight.
+- [ ] Given a model appears on more than one line, When the pool loads, Then each line is its own slot with its own weight, and the later line adds seats at its own position.
+- [ ] Given a slot is cooling or unavailable, When its position comes up, Then it is skipped and the pass continues to the next slot.
 - [ ] Given a claim is released, When the next spawn is routed, Then the slot that freed capacity is preferred again in declaration order; no stored position keeps it waiting.
-- [ ] Given every usable slot is at its absolute cap, When another spawn is routed, Then it goes to the least-loaded usable slot as overflow, and the pool never refuses work.
-- [ ] Given all slots carry equal weight, When spawns are routed, Then the same ordered two-pass fill applies.
-- [ ] Given per-slot load is read, When it is asserted, Then a slot's load never exceeds twice its weight except through overflow.
+- [ ] Given every usable slot is at its weight, When another spawn is routed, Then it goes to the least-loaded usable slot as overflow, and the pool never refuses work.
+- [ ] Given all slots carry equal weight, When spawns are routed, Then the same ordered one-pass fill applies.
+- [ ] Given per-slot load is read, When it is asserted, Then a slot's load never exceeds its weight except through overflow.
 
 ### US-6: Live pool visibility
 **As a** user, **I want** to see per-slot load and which model is cooling and why, **so that** I understand where my subagents are going.
@@ -113,8 +113,8 @@ The reconciliation with US-7 is that **acceptance and endorsement are different
 - [ ] Given claims are held by several processes, When the status view is requested, Then it shows every process's claims and the aggregate load per slot.
 - [ ] Given a model is cooling with a stated reason, When the status view is requested, Then the model is listed as cooling together with that reason.
 - [ ] Given a claim file is older than the dead-file threshold, When the status view is computed, Then the stale claim is pruned rather than counted.
-- [ ] Given a slot is at its absolute cap, When the status view is requested, Then it is not marked as the slot the next spawn would take while any usable slot is below its current pass target; when every usable slot is at its absolute cap, the least-loaded slot is marked next.
-- [ ] Given the pool is filling, When the status view is requested, Then it shows whether the next spawn belongs to the first pass, the second pass, or overflow.
+- [ ] Given a slot is at its weight, When the status view is requested, Then it is not marked as the slot the next spawn would take while any usable slot is below its weight; when every usable slot is at its weight, the least-loaded slot is marked next.
+- [ ] Given the pool is filling, When the status view is requested, Then it shows whether the next spawn is a normal pick or overflow.
 
 ### US-7: Non-free models still work
 **As a** user who wants a paid model in the pool, **I want** to supply any model list, **so that** the pool is not restricted to free tiers.
@@ -123,7 +123,7 @@ The reconciliation with US-7 is that **acceptance and endorsement are different
 **Acceptance criteria:**
 - [ ] Given a slot names a paid model, When the pool loads, Then the slot is accepted and routed to without a free-tier filter rejecting it.
 - [ ] Given a model id contains a vendor prefix with slashes (e.g. `openrouter/nvidia/model:free`), When it is split into provider and model id, Then the split is on the first slash only and the id tail is preserved.
-- [ ] Given more slots are declared than the pool allows, When the pool loads, Then the surplus entries are dropped with a warning naming the cap.
+- [ ] Given a pool file declares more slots than the built-in warning threshold, When the pool loads, Then every entry is kept and a warning names the count; there is no slot cap.
 - [ ] Given a provider configured with **no** `whitelist` key, When the config hook binds a slot on that provider, Then no `whitelist` is written for it, because an absent whitelist already allows every model the provider offers.
 - [ ] Given a provider the pool never names a slot on, When the config hook runs, Then that provider entry is left exactly as it was, with no `whitelist` key added.
 - [ ] Given a provider that already carries a `whitelist`, When the config hook binds a slot model on it, Then the model id is appended and every entry the user wrote is preserved in order.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawaty/lacode",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Ultimate opencode setup for Go users — cost-controlled pooled subagents, hang recovery, and notifications for opencode.",
   "license": "MIT",
   "type": "module",
@@ -34,11 +34,13 @@
     "./pool": "./dist/pool.js",
     "./agents": "./dist/agents.js",
     "./commands": "./dist/commands.js",
+    "./tui": "./dist/tui.js",
     "./tunnel": "./dist/tunnel.js",
     "./package.json": "./package.json"
   },
   "bin": {
-    "lacode": "./dist/lacode.js"
+    "lacode": "dist/lacode.js",
+    "lacode-voice": "dist/lacode-voice.js"
   },
   "files": [
     "dist",
@@ -47,14 +49,16 @@
     "LICENSE",
     "CHANGELOG.md",
     "README.md",
-    "docs"
+    "docs",
+    "scripts/score-models.mjs"
   ],
   "scripts": {
     "build": "node scripts/build.mjs",
     "prepack": "npm run build",
     "postpublish": "node scripts/sync-hosts.mjs",
     "test": "node --test tests/",
-    "benchmark": "node tests/benchmark/run.mjs"
+    "benchmark": "node tests/benchmark/run.mjs",
+    "score": "node scripts/score-models.mjs"
   },
   "devDependencies": {
     "esbuild": "^0.28.2"
@@ -62,6 +66,10 @@
   "peerDependencies": {
     "@opencode-ai/plugin": "1.18.34"
   },
+  "optionalDependencies": {
+    "@picovoice/porcupine-node": "^4.0.2",
+    "vosk": "^0.3.39"
+  },
   "publishConfig": {
     "tag": "latest"
   }

package/presets/README.md

@@ -45,9 +45,9 @@ opencode/glm-5.3-flash-free               1
 
 `#` starts a comment (whole-line or trailing), blank lines are ignored, and the
 weight is optional (default 1). The rules are exactly the same as the JSON form
-below: up to 4 slots, distinct models, split on the first slash only. The loader
-accepts either shape in the same file, so a leading `{` means JSON and anything
-else means the flat form.
+below: any number of slots, a model may repeat on another line, split on the
+first slash only. The loader accepts either shape in the same file, so a leading
+`{` means JSON and anything else means the flat form.
 
 ## Schema
 
@@ -63,7 +63,7 @@ else means the flat form.
 | Field | Required | Meaning |
 |-------|----------|---------|
 | `model` | yes | `provider/model-id`, split on the **first** slash only |
-| `weight` | no | active-session budget for one pass; its absolute cap is twice that. Absent = 1 |
+| `weight` | no | active-session budget; the pool's capacity is the sum of the weights. Absent = 1 |
 
 `$comment` is a JSON-legal array of strings and is ignored by the loader; the
 bundled preset uses it to explain itself in place.
@@ -74,13 +74,13 @@ The loader checks shape and nothing else:
 
 - `slots` must be a non-empty array
 - each `model` must contain a `/`
-- models must be distinct across slots
+- a model may appear on more than one line; each line is its own slot with its
+  own load counter and weight
 - `weight` must be a number in `(0, 100]`; a bad one **warns and uses 1** rather
   than dropping the slot, because losing a model to a typo in a count costs real
   capacity
-- at most `MAX_SLOTS` (4) slots; extra entries are **dropped with a warning**,
-  because one hidden variant agent per base per slot exists and a fifth slot
-  would route at an agent that does not exist
+- there is no slot cap: one hidden variant agent is declared per base per
+  resolved slot, and the watcher declares a variant if a reload grows the table
 - `tier` is accepted as an alias for `weight` (`primary` → 2,
   `overflow` → 1) and warns
 
@@ -92,20 +92,18 @@ because the pool requires it.
 
 ## Weight, precisely
 
-A weight is a slot's active-session budget for one pass: the number of
-concurrent claims it may hold before the next slot is preferred. Its absolute
-cap is **twice that weight** — a weight-3 slot may hold 6 concurrent sessions.
-Slots are filled in declaration order; preference is order, never weight.
+A weight is a slot's active-session budget: the number of concurrent claims it
+may hold before the next slot is preferred. The pool's capacity is the **sum of
+the weights**, so a weight-3 slot may hold 3 concurrent sessions and listing a
+model on two lines gives it two independent budgets.
 
-Routing runs in two passes:
+Routing is one pass:
 
-1. pass 1 fills each usable slot up to its weight, in declaration order
-2. once every usable slot has reached its weight, pass 2 repeats the order,
-   filling each usable slot up to twice its weight
+1. fill each usable slot up to its weight, in declaration order
 
-A slot is skipped when it is cooling, unavailable, or at its absolute cap.
-When every usable slot is at its absolute cap, overflow goes to the least
-loaded usable slot; the pool never refuses work.
+A slot is skipped when it is cooling or unavailable. When every usable slot is
+at its weight, the pool is at capacity and overflow goes to the least loaded
+usable slot; the pool never refuses work.
 
 Live claims decide the next slot: a released claim immediately reopens its
 slot, and there is no stored position.

package/presets/free-tier.json

@@ -9,25 +9,23 @@
     "Slot N is the same model for every base agent, which is what makes load shared.",
     "",
     "RULES, all validated at startup: models are written provider/model-id, split on the FIRST",
-    "slash only so openrouter's vendor-prefixed ids (nvidia/x:free) resolve; must be distinct.",
-    "AT MOST 4 SLOTS: one hidden variant per base per slot is declared, so a fifth entry would",
-    "route at an agent that does not exist. Extra entries are dropped with a warning.",
+    "slash only so openrouter's vendor-prefixed ids (nvidia/x:free) resolve. A model may",
+    "appear on more than one line: each line is its own slot with its own budget.",
+    "ANY NUMBER OF SLOTS: one hidden variant per base per slot is declared from the resolved",
+    "table, and the watcher declares a variant when a reload grows the table. There is no slot cap.",
     "",
     "WEIGHT IS THE ACTIVE-SESSION BUDGET FOR ONE PASS: a slot may hold up to its weight in",
     "concurrent claims before the next slot is preferred. Slots are filled in declaration",
     "order; preference is order, never weight.",
-    "Routing runs in two passes:",
-    "  1. pass 1 fills each usable slot up to its weight, in declaration order",
-    "  2. once every usable slot has reached its weight, pass 2 repeats the order, filling",
-    "     each usable slot up to twice its weight",
-    "A slot is skipped when it is cooling, unavailable, or at its absolute cap (twice its",
-    "weight). When every usable slot is at its absolute cap, overflow goes to the least",
-    "loaded usable slot; the pool never refuses work.",
+    "Routing is ONE ordered pass: each usable slot fills up to its weight, in declaration",
+    "order. A slot is skipped when it is cooling or unavailable. When every usable slot is at",
+    "its weight, the pool is at capacity (the sum of the weights) and overflow goes to the",
+    "least-loaded usable slot; the pool never refuses work.",
     "Live claims decide the next slot: a released claim immediately reopens its slot, and",
     "there is no stored position.",
     "",
-    "With this file: weights 3,2,1,1 give 7 active sessions in pass 1 and 14 total across",
-    "both passes.",
+    "With this file: weights 3,2,1,1 give 7 active sessions in total. To give a model more",
+    "capacity, list it again on another line with its own weight.",
     "Equal weights give a plain pass in list order.",
     "",
     "DECLARATION ORDER IS PREFERENCE. Slots are filled in declaration order, so the slot",
@@ -44,7 +42,7 @@
     "List order sets preference: earlier slots are preferred first, so put the slots you",
     "want worked first at the top of the list.",
     "",
-    "COST IS THE DEFAULT, NOT A CONSTRAINT. These four slots are free because that is what",
+    "COST IS THE DEFAULT, NOT A CONSTRAINT. These slots are free because that is what",
     "the pool is FOR: mechanical work -- reading files, grepping, mechanical edits, cartography.",
     "They are not here to be the smartest model in the system. The point of putting that work",
     "on a near-free model is that the mechanical tokens stop being spent by your expensive",

package/scripts/score-models.mjs

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+// LaCode free-model scorer — MEASURE, DO NOT FABRICATE.
+//
+// The pool is for mechanical work: reading files, grepping, mechanical edits,
+// cartography. What matters for that is not "the smartest model" but a model that
+// is (a) free, (b) awake, (c) fast, and (d) has enough context and output room.
+// This script measures those four things and ranks the candidates.
+//
+//   npm run score                       all configured free providers
+//   npm run score -- --providers opencode,openrouter
+//   npm run score -- --max 6            probe at most 6 models per provider
+//   npm run score -- --no-write         print only, touch nothing
+//
+// WHAT IT MEASURES
+//   context      limit.context from `opencode models --verbose`
+//   output       limit.output  (the token ceiling for one reply)
+//   speed        wall-clock ms for one tiny completion, one request per model
+//   reliability  did the model actually answer? A 429/401/404 is recorded as the
+//                named failure it is, never as a slow success.
+//
+// WHAT IT DOES NOT DO
+//   * It never invents a latency or a score. A model it could not reach is shown
+//     as unreachable with the reason and is NOT ranked.
+//   * It never writes pool.txt. It prints a SUGGESTED table for you to paste; the
+//     pool stays yours to decide.
+//   * It never probes a paid model. Only cost 0/0 models from the provider's
+//     catalog are candidates.
+//
+// OUTPUT
+//   a per-provider ranked table, an overall ranking, a suggested pool.txt block,
+//   and (unless --no-write) the raw rows in ~/.config/lacode/model-scores.json so
+//   a later run can compare.
+
+import { execFileSync } from "node:child_process"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+
+const AUTH = join(homedir(), ".local", "share", "opencode", "auth.json")
+const OUT = join(homedir(), ".config", "lacode", "model-scores.json")
+const DEFAULT_PROVIDERS = ["opencode", "opencode-go", "openrouter", "console-openrouter"]
+
+// ── scoring weights ─────────────────────────────────────────────────────────
+// Mechanical work prizes speed and availability over raw capability. Context is
+// scored on a log curve so 256k vs 1M is a difference, not a cliff.
+const W = { speed: 0.35, context: 0.3, output: 0.15, reliability: 0.2 }
+const MAX_CONTEXT = 1_000_000
+const FAST_MS = 300 // at or below this, speed scores 1.0
+const SLOW_MS = 8_000 // at or above this, speed scores 0
+const PROMPT = "Reply with the single word: ok"
+const MAX_TOKENS = 8
+
+// ── args ────────────────────────────────────────────────────────────────────
+const argv = process.argv.slice(2)
+const has = (flag) => argv.includes(flag)
+const value = (flag, fallback) => {
+  const hit = argv.find((a) => a === flag || a.startsWith(`${flag}=`))
+  if (!hit) return fallback
+  return hit.includes("=") ? hit.slice(hit.indexOf("=") + 1) : argv[argv.indexOf(hit) + 1]
+}
+
+if (has("--help") || has("-h")) {
+  console.log(`Usage: npm run score -- [options]
+
+  --providers a,b   providers to scan (default: ${DEFAULT_PROVIDERS.join(",")})
+  --max N           probe at most N free models per provider (default: 12)
+  --timeout MS      per-request deadline in ms (default: 20000)
+  --delay MS        pause between requests in ms (default: 300)
+  --no-write        do not write ~/.config/lacode/model-scores.json
+  -h, --help        this message
+
+Only cost 0/0 models are candidates. Credentials come from
+~/.local/share/opencode/auth.json; a provider with no entry falls back to the
+"opencode" key (which is how the console-openrouter connection authenticates).`)
+  process.exit(0)
+}
+
+const providers = String(value("--providers", DEFAULT_PROVIDERS.join(","))).split(",").map((s) => s.trim()).filter(Boolean)
+const maxPerProvider = Math.max(1, Number(value("--max", "12")) || 12)
+const timeoutMs = Math.max(1_000, Number(value("--timeout", "20000")) || 20_000)
+const delayMs = Math.max(0, Number(value("--delay", "300")) || 300)
+const writeResults = !has("--no-write")
+
+// ── discovery ───────────────────────────────────────────────────────────────
+/** Parse `opencode models --verbose <provider>`: alternating id line + JSON block. */
+function parseVerbose(text) {
+  const rows = []
+  let id = null
+  let buf = []
+  const flush = () => {
+    if (!id || buf.length === 0) return false
+    try {
+      const parsed = JSON.parse(buf.join("\n"))
+      rows.push({ id, model: parsed })
+      id = null
+      buf = []
+      return true
+    } catch {
+      return false
+    }
+  }
+  for (const line of text.split(/\r?\n/)) {
+    const isId = /^\S/.test(line) && !/^[{}]/.test(line)
+    if (isId) {
+      if (id) flush()
+      if (line.startsWith("provider/") || line.includes("/")) {
+        id = line.trim()
+        buf = []
+      }
+      continue
+    }
+    if (id) {
+      buf.push(line)
+      const trimmed = line.trim()
+      if (trimmed === "}" || trimmed === "},") flush()
+    }
+  }
+  flush()
+  return rows
+}
+
+function freeModels(provider) {
+  let text
+  try {
+    text = execFileSync("opencode", ["models", "--verbose", provider], {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+  } catch (error) {
+    return { provider, error: `opencode models failed: ${String(error?.message ?? error)}`, models: [] }
+  }
+  const rows = parseVerbose(text)
+  const models = rows
+    .filter(({ model }) => model?.api?.url && model?.api?.id)
+    .filter(({ model }) => (model.cost?.input ?? 1) === 0 && (model.cost?.output ?? 1) === 0)
+    .filter(({ model }) => !model.status || model.status === "active")
+    .map(({ id, model }) => ({
+      model: id,
+      url: model.api.url,
+      apiId: model.api.id,
+      context: model.limit?.context ?? null,
+      output: model.limit?.output ?? null,
+      name: model.name ?? id,
+    }))
+  return { provider, error: null, models }
+}
+
+// ── credentials ─────────────────────────────────────────────────────────────
+function loadAuth() {
+  if (!existsSync(AUTH)) return {}
+  try {
+    return JSON.parse(readFileSync(AUTH, "utf8"))
+  } catch {
+    return {}
+  }
+}
+const auth = loadAuth()
+const keyFor = (provider) => auth[provider]?.key ?? auth.opencode?.key ?? null
+// The Zen gateways reject a request that does not name a session; the value does
+// not need to be a real opencode session, it only has to be present.
+const runSession = `score-${Date.now().toString(36)}`
+const sessionHeader = (provider) =>
+  provider === "opencode" || provider === "opencode-go" ? { "x-opencode-session": runSession } : {}
+
+// ── probing ─────────────────────────────────────────────────────────────────
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+/**
+ * One real request. Returns {ok, ms, reason}. A failure is named, never rounded
+ * into a success, and `ms` is only reported for a request that actually ran.
+ */
+async function probe(candidate, provider) {
+  const key = keyFor(provider)
+  if (!key) return { ok: false, ms: null, reason: "no credential in auth.json" }
+
+  const url = `${String(candidate.url).replace(/\/+$/, "")}/chat/completions`
+  const started = performance.now()
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`,
+        ...sessionHeader(provider),
+        ...(provider === "openrouter" ? { "HTTP-Referer": "https://opencode.ai", "X-Title": "LaCode score" } : {}),
+      },
+      body: JSON.stringify({
+        model: candidate.apiId,
+        messages: [{ role: "user", content: PROMPT }],
+        max_tokens: MAX_TOKENS,
+        temperature: 0,
+        stream: false,
+      }),
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    const ms = Math.round(performance.now() - started)
+    const body = await response.text()
+    let parsed = null
+    try {
+      parsed = JSON.parse(body)
+    } catch {}
+
+    if (!response.ok) {
+      const detail = parsed?.error?.message ?? body.slice(0, 160)
+      const kind =
+        response.status === 429
+          ? "rate-limited"
+          : response.status === 401 || response.status === 403
+            ? "credential"
+            : response.status === 404
+              ? "not served"
+              : `http ${response.status}`
+      return { ok: false, ms, reason: `${kind}: ${detail}` }
+    }
+    // A 200 can still carry an error object (OpenRouter does this).
+    if (parsed?.error) return { ok: false, ms, reason: `${parsed.error.message ?? "error"} `.trim() }
+    if (!Array.isArray(parsed?.choices) || parsed.choices.length === 0) {
+      return { ok: false, ms, reason: "no choices in response" }
+    }
+    return { ok: true, ms, reason: "answered" }
+  } catch (error) {
+    const ms = Math.round(performance.now() - started)
+    const name = error?.name === "TimeoutError" ? "timeout" : String(error?.message ?? error)
+    return { ok: false, ms, reason: name }
+  }
+}
+
+// ── scoring ─────────────────────────────────────────────────────────────────
+const clamp01 = (n) => Math.max(0, Math.min(1, n))
+const logScore = (n, max) => (n && n > 0 ? clamp01(Math.log2(1 + n) / Math.log2(1 + max)) : 0)
+const speedScore = (ms) => (ms == null ? 0 : clamp01((SLOW_MS - ms) / (SLOW_MS - FAST_MS)))
+
+function score(row) {
+  if (!row.ok) return null
+  const parts = {
+    speed: speedScore(row.ms),
+    context: logScore(row.context, MAX_CONTEXT),
+    output: logScore(row.output, 262_144),
+    reliability: 1,
+  }
+  const value = 100 * (Object.entries(W).reduce((sum, [k, w]) => sum + w * parts[k], 0) / Object.values(W).reduce((a, b) => a + b, 0))
+  return { value: Math.round(value * 10) / 10, parts }
+}
+
+const pad = (s, n) => String(s).padEnd(n)
+const padL = (s, n) => String(s).padStart(n)
+
+async function main() {
+  const scanned = providers.map(freeModels)
+  const results = []
+
+  for (const entry of scanned) {
+    if (entry.error) {
+      console.log(`\n${entry.provider}: ${entry.error}`)
+      results.push({ provider: entry.provider, error: entry.error, rows: [] })
+      continue
+    }
+    const candidates = entry.models.slice(0, maxPerProvider)
+    console.log(`\n${entry.provider}: probing ${candidates.length} free model(s)${entry.models.length > candidates.length ? ` of ${entry.models.length}` : ""}`)
+    if (candidates.length === 0) {
+      results.push({ provider: entry.provider, error: null, rows: [] })
+      continue
+    }
+    const rows = []
+    for (const candidate of candidates) {
+      const outcome = await probe(candidate, entry.provider)
+      const row = { provider: entry.provider, ...candidate, ...outcome, score: null }
+      row.score = score(row)
+      rows.push(row)
+      const verdict = outcome.ok ? `${outcome.ms}ms` : outcome.reason.slice(0, 60)
+      console.log(`  ${pad(candidate.model.replace(`${entry.provider}/`, ""), 52)} ${padL(verdict, 16)}`)
+      await sleep(delayMs)
+    }
+    results.push({ provider: entry.provider, error: null, rows })
+  }
+
+  // Per-provider ranked tables.
+  for (const entry of results) {
+    if (entry.error || entry.rows.length === 0) continue
+    console.log(`\n${entry.provider} — ranked`)
+    console.log(`  ${pad("#", 3)}${pad("model", 52)}${padL("ctx", 9)}${padL("out", 9)}${padL("ms", 7)}${padL("score", 7)}`)
+    const ranked = [...entry.rows].filter((r) => r.score).sort((a, b) => b.score.value - a.score.value)
+    ranked.forEach((r, i) => {
+      console.log(`  ${pad(i + 1, 3)}${pad(r.model.replace(`${entry.provider}/`, ""), 52)}${padL(r.context ?? "?", 9)}${padL(r.output ?? "?", 9)}${padL(r.ms ?? "?", 7)}${padL(r.score.value, 7)}`)
+    })
+    const failed = entry.rows.filter((r) => !r.ok)
+    if (failed.length) {
+      console.log(`  unreachable (not ranked):`)
+      for (const r of failed) console.log(`    ${pad(r.model.replace(`${entry.provider}/`, ""), 52)} ${r.reason.slice(0, 90)}`)
+    }
+  }
+
+  // Overall ranking across providers.
+  const all = results.flatMap((e) => e.rows).filter((r) => r.score)
+  all.sort((a, b) => b.score.value - a.score.value)
+  if (all.length) {
+    console.log(`\noverall — best free models right now`)
+    all.slice(0, 12).forEach((r, i) => {
+      console.log(`  ${pad(i + 1, 3)}${pad(r.model, 58)}${padL(`${r.ms}ms`, 8)}${padL(r.score.value, 7)}`)
+    })
+  }
+
+  // A SUGGESTED pool: the best model from each provider, weights 4/3/2/1 by rank.
+  // Printed, never written — pool.txt stays the user's decision.
+  const bestPerProvider = []
+  for (const entry of results) {
+    const top = entry.rows.filter((r) => r.score).sort((a, b) => b.score.value - a.score.value)[0]
+    if (top) bestPerProvider.push(top)
+  }
+  bestPerProvider.sort((a, b) => b.score.value - a.score.value)
+  if (bestPerProvider.length) {
+    console.log(`\nsuggested pool.txt (paste if it matches your judgement — nothing was changed)`)
+    console.log(`# scored ${new Date().toISOString()} — one best free model per provider`)
+    bestPerProvider.forEach((r, i) => {
+      const weight = Math.max(1, 4 - i)
+      console.log(`${pad(r.model, 60)}${weight}`)
+    })
+  }
+
+  if (writeResults) {
+    try {
+      mkdirSync(dirname(OUT), { recursive: true })
+      const payload = {
+        generatedAt: new Date().toISOString(),
+        weights: W,
+        providers: results.map((e) => ({
+          provider: e.provider,
+          error: e.error,
+          rows: e.rows.map((r) => ({
+            model: r.model,
+            context: r.context,
+            output: r.output,
+            ok: r.ok,
+            ms: r.ms,
+            reason: r.reason,
+            score: r.score?.value ?? null,
+          })),
+        })),
+      }
+      writeFileSync(OUT, JSON.stringify(payload, null, 2) + "\n")
+      console.log(`\nwrote ${OUT}`)
+    } catch (error) {
+      console.error(`\ncould not write ${OUT}: ${String(error?.message ?? error)}`)
+      process.exitCode = 1
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(String(error?.stack ?? error))
+  process.exitCode = 1
+})