@lawaty/lacode 2.1.0-beta.0 → 2.2.0-beta.0

package/CHANGELOG.md

@@ -9,6 +9,19 @@ commit as the changelog entry it describes.
 
 ## [Unreleased]
 
+## [2.2.0-beta.0] — context-aware pool routing
+
+### Added
+
+- Pool: context-aware routing. `pool.txt` lines carry a `c:<context>` token, and the router prefers the smallest model whose context fits the task prompt, so large-context models are reserved for large tasks.
+- Pool: `npm run score` probes providers with no direct HTTP endpoint (or an unexpanded `${...}` URL) through the local opencode session, and considers catalogue-priced models on providers other than `opencode`/`opencode-go`, whose credits cover them.
+- Pool: a rate-limit reset or a `402 out of credits` answer schedules a transient retry; a transient failure keeps the model's previous score until the retry.
+
+### Changed
+
+- Pool: the context floor is now 100k. Slots are ordered as `opencode-go` (weight 4), small-context providers (weight 2), large-context providers (weight 1), and at most one `opencode` model last.
+- Pool: small-context models are preferred for ordinary work; large-context models are used when the estimated task size needs them or when small slots are full.
+
 ## [2.1.0-beta.0] — every provider counts, and the timer installs itself
 
 ### Added

package/dist/index.js

@@ -109,7 +109,14 @@ function parseSlots(parsed, origin) {
       problems.push(`${at} (${model}): bucket must be a non-empty name; using the model id`);
     }
     const notify = coerceNotify(entry.notify, at, model, problems);
-    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify });
+    const rawContext = entry?.context;
+    let context;
+    if (rawContext !== void 0) {
+      const parsedContext = typeof rawContext === "number" ? rawContext : Number(rawContext);
+      if (Number.isFinite(parsedContext) && parsedContext > 0) context = parsedContext;
+      else problems.push(`${at} (${model}): context must be a positive number, got ${JSON.stringify(rawContext)}; ignoring it`);
+    }
+    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify, ...context === void 0 ? {} : { context } });
   });
   if (slots.length > SLOTS_WARN_AT) {
     problems.push(`${origin}: ${slots.length} slots is unusually large, but every entry is kept (the pool has no slot cap)`);
@@ -129,18 +136,26 @@ function parseTextSlots(text, origin) {
     let weight;
     let bucket;
     let notify;
+    let context;
     for (const token of rest) {
       if (token.startsWith("notify:")) {
         if (notify === void 0) notify = token.slice("notify:".length);
         continue;
       }
+      if (token.startsWith("c:")) {
+        if (context === void 0) {
+          const parsedContext = Number(token.slice(2));
+          if (Number.isFinite(parsedContext) && parsedContext > 0) context = parsedContext;
+        }
+        continue;
+      }
       if (token.startsWith("b:")) {
         if (bucket === void 0) bucket = token.slice(2);
       } else if (weight === void 0) {
         weight = token;
       }
     }
-    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify } });
+    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify }, ...context === void 0 ? {} : { context } });
   }
   return parseSlots({ slots: entries }, origin);
 }
@@ -713,20 +728,50 @@ function snapshot(s) {
 }
 var loadOf = (counts, slot) => counts.get(slot) ?? 0;
 var underCeiling = (slot, counts) => loadOf(counts, slot.index) < slotCeiling(slot);
-function pickSlot(s, snap) {
+function pickSlot(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
   const configured = slots.filter((slot) => providerReady(s, slot.model));
   const usable = configured.filter((slot) => isAvailable(s, slot.model, snap.cooling));
   const pool = usable.length > 0 ? usable : configured.length > 0 ? configured : slots;
-  for (const slot of usable) {
-    if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+  if (neededContext === void 0) {
+    for (const slot of usable) {
+      if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+    }
+    return pool.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, pool[0]);
+  }
+  const adequate = usable.filter((slot) => slot.context == null || slot.context >= neededContext);
+  const adequateKnown = adequate.filter((slot) => slot.context != null);
+  const candidates = adequate.length > 0 ? adequate : usable;
+  const fallbackPool = adequate.length > 0 ? adequate : pool;
+  if (adequateKnown.length === 0) {
+    const known = usable.filter((slot) => slot.context != null);
+    if (known.length > 0) {
+      const largest = Math.max(...known.map((slot) => slot.context));
+      const largestSlots = known.filter((slot) => slot.context === largest);
+      for (const slot of largestSlots) {
+        if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+      }
+      return largestSlots.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, largestSlots[0]);
+    }
+    for (const slot of candidates) {
+      if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+    }
+    return fallbackPool.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, fallbackPool[0]);
   }
-  return pool.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, pool[0]);
+  const underWeight = candidates.filter((slot) => loadOf(snap.counts, slot.index) < slot.weight);
+  if (underWeight.length > 0) {
+    const known = underWeight.filter((slot) => slot.context != null);
+    if (known.length === 0) return underWeight[0];
+    return known.reduce((best, slot) => slot.context < best.context ? slot : best, known[0]);
+  }
+  return candidates.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, candidates[0]);
 }
-function poolPass(s, snap) {
+function poolPass(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
   const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
-  if (usable.some((slot) => loadOf(snap.counts, slot.index) < slot.weight)) return 1;
+  const candidates = neededContext === void 0 ? usable : usable.filter((slot) => slot.context == null || slot.context >= neededContext);
+  const pool = candidates.length > 0 ? candidates : usable;
+  if (pool.some((slot) => loadOf(snap.counts, slot.index) < slot.weight)) return 1;
   return "overflow";
 }
 function agentFor(base, slot) {
@@ -2964,6 +3009,11 @@ var reportText = (report) => {
     `summary: ${answered} answered, ${benched} benched, ${cooling} still cooling`
   ].join("\n");
 };
+var CONTEXT_HEADROOM_TOKENS = 2e4;
+function estimateContextTokens(prompt) {
+  if (typeof prompt !== "string" || prompt.length === 0) return void 0;
+  return Math.ceil(prompt.length / 4) + CONTEXT_HEADROOM_TOKENS;
+}
 var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
   const opts = options ?? {};
   const notify = opts.notify ?? ((title, message) => void notifyDesktop(title, message));
@@ -3887,7 +3937,8 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         refreshCatalog(s, serverUrl);
         const snap = snapshot(s);
         if (BASES.includes(requested)) {
-          const slot = pickSlot(s, snap);
+          const neededContext = estimateContextTokens(output.args?.prompt);
+          const slot = pickSlot(s, snap, neededContext);
           const variant = agentFor(requested, slot.index);
           if (s.known.size > 0 && !s.known.has(variant)) {
             await warnOnce(`variant ${variant} missing from config; spawn left unchanged`);

package/dist/pool.js

@@ -109,7 +109,14 @@ function parseSlots(parsed, origin) {
       problems.push(`${at} (${model}): bucket must be a non-empty name; using the model id`);
     }
     const notify = coerceNotify(entry.notify, at, model, problems);
-    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify });
+    const rawContext = entry?.context;
+    let context;
+    if (rawContext !== void 0) {
+      const parsedContext = typeof rawContext === "number" ? rawContext : Number(rawContext);
+      if (Number.isFinite(parsedContext) && parsedContext > 0) context = parsedContext;
+      else problems.push(`${at} (${model}): context must be a positive number, got ${JSON.stringify(rawContext)}; ignoring it`);
+    }
+    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify, ...context === void 0 ? {} : { context } });
   });
   if (slots.length > SLOTS_WARN_AT) {
     problems.push(`${origin}: ${slots.length} slots is unusually large, but every entry is kept (the pool has no slot cap)`);
@@ -129,18 +136,26 @@ function parseTextSlots(text, origin) {
     let weight;
     let bucket;
     let notify;
+    let context;
     for (const token of rest) {
       if (token.startsWith("notify:")) {
         if (notify === void 0) notify = token.slice("notify:".length);
         continue;
       }
+      if (token.startsWith("c:")) {
+        if (context === void 0) {
+          const parsedContext = Number(token.slice(2));
+          if (Number.isFinite(parsedContext) && parsedContext > 0) context = parsedContext;
+        }
+        continue;
+      }
       if (token.startsWith("b:")) {
         if (bucket === void 0) bucket = token.slice(2);
       } else if (weight === void 0) {
         weight = token;
       }
     }
-    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify } });
+    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify }, ...context === void 0 ? {} : { context } });
   }
   return parseSlots({ slots: entries }, origin);
 }
@@ -713,20 +728,50 @@ function snapshot(s) {
 }
 var loadOf = (counts, slot) => counts.get(slot) ?? 0;
 var underCeiling = (slot, counts) => loadOf(counts, slot.index) < slotCeiling(slot);
-function pickSlot(s, snap) {
+function pickSlot(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
   const configured = slots.filter((slot) => providerReady(s, slot.model));
   const usable = configured.filter((slot) => isAvailable(s, slot.model, snap.cooling));
   const pool = usable.length > 0 ? usable : configured.length > 0 ? configured : slots;
-  for (const slot of usable) {
-    if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+  if (neededContext === void 0) {
+    for (const slot of usable) {
+      if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+    }
+    return pool.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, pool[0]);
+  }
+  const adequate = usable.filter((slot) => slot.context == null || slot.context >= neededContext);
+  const adequateKnown = adequate.filter((slot) => slot.context != null);
+  const candidates = adequate.length > 0 ? adequate : usable;
+  const fallbackPool = adequate.length > 0 ? adequate : pool;
+  if (adequateKnown.length === 0) {
+    const known = usable.filter((slot) => slot.context != null);
+    if (known.length > 0) {
+      const largest = Math.max(...known.map((slot) => slot.context));
+      const largestSlots = known.filter((slot) => slot.context === largest);
+      for (const slot of largestSlots) {
+        if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+      }
+      return largestSlots.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, largestSlots[0]);
+    }
+    for (const slot of candidates) {
+      if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+    }
+    return fallbackPool.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, fallbackPool[0]);
+  }
+  const underWeight = candidates.filter((slot) => loadOf(snap.counts, slot.index) < slot.weight);
+  if (underWeight.length > 0) {
+    const known = underWeight.filter((slot) => slot.context != null);
+    if (known.length === 0) return underWeight[0];
+    return known.reduce((best, slot) => slot.context < best.context ? slot : best, known[0]);
   }
-  return pool.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, pool[0]);
+  return candidates.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, candidates[0]);
 }
-function poolPass(s, snap) {
+function poolPass(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
   const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
-  if (usable.some((slot) => loadOf(snap.counts, slot.index) < slot.weight)) return 1;
+  const candidates = neededContext === void 0 ? usable : usable.filter((slot) => slot.context == null || slot.context >= neededContext);
+  const pool = candidates.length > 0 ? candidates : usable;
+  if (pool.some((slot) => loadOf(snap.counts, slot.index) < slot.weight)) return 1;
   return "overflow";
 }
 function agentFor(base, slot) {

package/docs/CONFIGURATION.md

@@ -7,7 +7,7 @@ The plugin options, where the model pool gets its slots, and exactly what LaCode
 The slot list is the first of these that yields usable slots:
 
 1. plugin options — `models` in the [tuple](../README.md#configure)
-2. `~/.config/lacode/pool.txt` — flat `model [weight] [b:<bucket>] [notify:on|off]` per line, preferred
+2. `~/.config/lacode/pool.txt` — flat `model [weight] [b:<bucket>] [c:<context>] [notify:on|off]` per line, preferred
 3. `~/.config/lacode/pool.json` (its parent directory is created for you)
 4. the bundled `presets/free-tier.json`
 5. a built-in fallback, so routing always works
@@ -33,6 +33,8 @@ A slot may also declare a shared quota bucket with `b:<name>` on the line (or a
 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.
 
+`c:<context>` is the model's context window in tokens; the router uses it to prefer the smallest model that fits the task, and it is optional for hand-written lines.
+
 Each slot gets a `notify` flag that controls the desktop "rate-limit reset"
 notice raised when a slot that was cooling for a quota/rate-limit reason becomes
 usable again. The default is **provider-based**: on for `opencode` and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawaty/lacode",
-  "version": "2.1.0-beta.0",
+  "version": "2.2.0-beta.0",
   "description": "Ultimate opencode setup for Go users — cost-controlled pooled subagents, hang recovery, and notifications for opencode.",
   "license": "MIT",
   "type": "module",
@@ -51,6 +51,7 @@
     "README.md",
     "docs",
     "scripts/score-models.mjs",
+    "scripts/pool-selection.mjs",
     "scripts/refresh-pool.mjs"
   ],
   "scripts": {

package/presets/README.md

@@ -36,15 +36,15 @@ change here takes effect without a restart. Plugin CODE still needs one.
 in place, no JSON and no objects:
 
 ```text
-# provider/model-id                       weight
-opencode/big-pickle                       3
-opencode-go/beam-free       2
-opencode/deepseek-v4.1-flash-free         1
-opencode/glm-5.3-flash-free               1
+# provider/model-id                       weight  c:<context>
+opencode/big-pickle                       3       c:200000
+opencode-go/beam-free       2       c:200000
+opencode/deepseek-v4.1-flash-free         1       c:200000
+opencode/glm-5.3-flash-free               1       c:200000
 ```
 
 `#` 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
+weight is optional (default 1). `c:<context>` is the model's context window in tokens; the router uses it to prefer the smallest model that fits the task, and it is optional for hand-written lines. The rules are exactly the same as the JSON 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.

package/scripts/pool-selection.mjs

@@ -0,0 +1,187 @@
+// Pure pool selection: which scored models become slots, and when a limited
+// model is worth retrying. Imported by scripts/score-models.mjs; refresh-pool
+// consumes the resulting `selection` and does not repeat this policy.
+
+export const MIN_CONTEXT = 100_000
+export const SMALL_CONTEXT_MAX = 200_000
+export const MIN_SCORE = 60
+export const POOL_SIZE = 10
+export const MAX_ZEN = 1
+export const LARGE_RESERVE = 3
+export const MAX_PER_PROVIDER = 2
+export const MAX_PER_PROVIDER_LARGE = 1
+export const DEFAULT_QUOTA_RETRY_MS = 15 * 60 * 1000
+export const CREDIT_RETRY_MS = 6 * 60 * 60 * 1000
+export const MAX_RETRY_DELAY_MS = 24 * 60 * 60 * 1000
+export const STATED_COOLDOWN_MAX_MS = 6 * 60 * 60 * 1000
+
+export const isTransientFailure = (row) =>
+  row?.ok === false &&
+  /timeout|timed out|rate-limit|no answer|no response|unreachable|ECONN|ETIMEDOUT|fetch failed|socket hang up|credit|402/i.test(
+    String(row.reason ?? ""),
+  )
+
+const isLimitText = (text) =>
+  /rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded|limits?[\s_-]?(?:reached|exceeded)|\b429\b/i.test(
+    String(text ?? ""),
+  )
+
+const isDailyLimit = (text) => /per[\s-]?day|daily|free-models-per-day|requests?\s+per\s+day/i.test(String(text ?? ""))
+
+const isCreditText = /out of credits|insufficient credits|credit balance|requires more credits|\b402\b/i
+
+const bounded = (ms) => (Number.isFinite(ms) && ms > 0 && ms <= STATED_COOLDOWN_MAX_MS ? ms : undefined)
+
+export const statedCooldownMs = (text) => {
+  const value = String(text ?? "")
+  const hm = /resets?\s+in\s+(\d+)\s*(?:hour|hr|h)s?\s*(\d+)?\s*(?:minute|min|m)?s?/i.exec(value)
+  if (hm) return bounded((Number(hm[1]) * 60 + (hm[2] ? Number(hm[2]) : 0)) * 60 * 1000)
+  const m = /resets?\s+in\s+(\d+)\s*(?:minute|min|m)s?/i.exec(value)
+  if (m) return bounded(Number(m[1]) * 60 * 1000)
+  const s = /retry[\s-]?in\s+(\d+)\s*(?:second|sec|s)s?/i.exec(value)
+  if (s) return bounded(Number(s[1]) * 1000)
+  return undefined
+}
+
+const retryAfterHeaderMs = (value) => {
+  if (!value) return undefined
+  const text = String(value).trim()
+  if (/^\d+$/.test(text)) return bounded(Number(text) * 1000)
+  const at = Date.parse(text)
+  return Number.isFinite(at) ? bounded(at - Date.now()) : undefined
+}
+
+export function retryAfterMs(text, header, now = Date.now()) {
+  const headerMs = retryAfterHeaderMs(header)
+  if (headerMs) return now + headerMs
+  const stated = statedCooldownMs(text)
+  if (stated) return now + stated
+  const normalized = String(text ?? "")
+  if (isDailyLimit(text)) {
+    const d = new Date(now)
+    const next = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + 1, 0, 0, 0, 0)
+    return next > now ? next : now + MAX_RETRY_DELAY_MS
+  }
+  if (isCreditText.test(normalized)) return now + CREDIT_RETRY_MS
+  if (isLimitText(text)) return now + DEFAULT_QUOTA_RETRY_MS
+  return undefined
+}
+
+const rowsOf = (providers) =>
+  Array.isArray(providers)
+    ? providers.flatMap((entry) => (Array.isArray(entry?.rows) ? entry.rows : []))
+    : []
+
+const providerOf = (model) => String(model ?? "").split("/")[0]
+
+export function selectPool({
+  providers,
+  previousProviders,
+  minContext = MIN_CONTEXT,
+  minScore = MIN_SCORE,
+  poolSize = POOL_SIZE,
+  maxZen = MAX_ZEN,
+} = {}) {
+  const rankable = (row) =>
+    row?.ok === true &&
+    typeof row.score === "number" &&
+    Number.isFinite(row.score) &&
+    row.score >= minScore &&
+    (row.context == null || row.context >= minContext)
+  const byScore = (a, b) => b.score - a.score || String(a.model).localeCompare(String(b.model))
+
+  const rows = rowsOf(providers)
+  const previousRows = rowsOf(previousProviders)
+  const currentByModel = new Map(rows.map((row) => [row.model, row]))
+  const erroredProviders = new Set(
+    (Array.isArray(providers) ? providers : [])
+      .filter((entry) => entry?.error)
+      .map((entry) => String(entry.provider ?? "")),
+  )
+
+  // A model the previous run scored is kept when this run could not reach it
+  // for a transient reason. A model the provider says is gone is not kept.
+  const fallback = previousRows.filter((row) => {
+    if (!rankable(row)) return false
+    const current = currentByModel.get(row.model)
+    if (current) return isTransientFailure(current)
+    return erroredProviders.has(providerOf(row.model))
+  })
+
+  const merge = (pick) => {
+    const seen = new Set()
+    const out = []
+    for (const row of [...rows, ...fallback]) {
+      if (!pick(row) || !rankable(row) || seen.has(row.model)) continue
+      seen.add(row.model)
+      out.push(row)
+    }
+    return out.sort(byScore)
+  }
+
+  const go = merge((row) => providerOf(row.model) === "opencode-go")
+  const other = merge((row) => providerOf(row.model) !== "opencode-go" && providerOf(row.model) !== "opencode")
+  const zen = merge((row) => providerOf(row.model) === "opencode")
+
+  const small = other
+    .filter((row) => row.context != null && row.context < SMALL_CONTEXT_MAX)
+    .sort(byScore)
+  const large = other
+    .filter((row) => row.context == null || row.context >= SMALL_CONTEXT_MAX)
+    .sort(byScore)
+
+  const capPerProvider = (rows, max) => {
+    const counts = new Map()
+    const out = []
+    for (const row of rows) {
+      const provider = providerOf(row.model)
+      const count = counts.get(provider) ?? 0
+      if (count >= max) continue
+      counts.set(provider, count + 1)
+      out.push(row)
+    }
+    return out
+  }
+
+  const cappedSmall = capPerProvider(small, MAX_PER_PROVIDER)
+  const cappedLarge = capPerProvider(large, MAX_PER_PROVIDER_LARGE)
+
+  const remaining = Math.max(0, poolSize - go.length)
+  const pickedLarge = cappedLarge.slice(0, Math.min(LARGE_RESERVE, remaining))
+  const pickedSmall = cappedSmall.slice(0, Math.max(0, remaining - pickedLarge.length))
+
+  if (pickedLarge.length + pickedSmall.length < remaining) {
+    const need = remaining - pickedLarge.length - pickedSmall.length
+    pickedLarge.push(...cappedLarge.slice(pickedLarge.length, pickedLarge.length + need))
+  }
+  if (pickedLarge.length + pickedSmall.length < remaining) {
+    const need = remaining - pickedLarge.length - pickedSmall.length
+    pickedSmall.push(...cappedSmall.slice(pickedSmall.length, pickedSmall.length + need))
+  }
+
+  const zenSlots = Math.max(0, Math.min(maxZen, poolSize - go.length - pickedSmall.length - pickedLarge.length))
+  const pickedZen = zen.slice(0, zenSlots)
+
+  const selection = [
+    ...go.map((row) => ({ model: row.model, weight: 4, context: row.context ?? null })),
+    ...pickedSmall.map((row) => ({ model: row.model, weight: 2, context: row.context ?? null })),
+    ...pickedLarge.map((row) => ({ model: row.model, weight: 1, context: row.context ?? null })),
+    ...pickedZen.map((row) => ({ model: row.model, weight: 1, bucket: "opencode", context: row.context ?? null })),
+  ]
+
+  const warnings = []
+  const total = selection.length
+  if (total === 0) warnings.push("no scorable model at or above the minimum score is available")
+  else if (total < poolSize) warnings.push(`only ${total} scorable model(s) available, wanted ${poolSize}`)
+
+  const limited = rows.filter((row) => row?.ok === false && Number.isFinite(row.retryAfter))
+  const retry =
+    limited.length > 0
+      ? {
+          after: new Date(Math.min(...limited.map((row) => row.retryAfter))).toISOString(),
+          models: limited.map((row) => row.model),
+        }
+      : undefined
+
+  return { selection, warnings, retry }
+}

package/scripts/refresh-pool.mjs

@@ -9,8 +9,9 @@
 //   1. every opencode-go model with ok:true, a numeric score at or above the
 //      score floor and a context at or above the context floor, sorted by score
 //      descending, weight 4
-//   2. the best (10 - n) models from every other provider, sorted by score
-//      descending, weight 2; opencode models get b:opencode
+//   2. the best (10 - n) models from every provider other than opencode,
+//      sorted by score descending, weight 2
+//   3. at most one opencode model as a last resort, weight 2, with b:opencode
 //
 // Total = n + min(10 - n, #others), where n = #1.
 //
@@ -28,6 +29,8 @@ export const DEFAULT_POOL_PATH = join(HOME, ".config", "lacode", "pool.txt")
 export const SYSTEMD_USER_DIR = (home = HOME) => join(home, ".config", "systemd", "user")
 export const STABLE_LIB_DIR = (home = HOME) => join(home, ".local", "lib", "lacode")
 export const STABLE_SCRIPT = (home = HOME) => join(STABLE_LIB_DIR(home), "refresh-pool.mjs")
+export const STABLE_SCORER = (home = HOME) => join(STABLE_LIB_DIR(home), "score-models.mjs")
+export const STABLE_SELECTION = (home = HOME) => join(STABLE_LIB_DIR(home), "pool-selection.mjs")
 export const REFRESH_SERVICE_NAME = "lacode-refresh-pool.service"
 export const REFRESH_TIMER_NAME = "lacode-refresh-pool.timer"
 
@@ -36,20 +39,6 @@ const isSlotLine = (line) => {
   return stripped.length > 0 && stripped.includes("/")
 }
 
-const providerOf = (modelOrLine) => {
-  const stripped = String(modelOrLine).split("#")[0].trim()
-  const token = stripped.split(/\s+/)[0] || ""
-  const slash = token.indexOf("/")
-  return slash < 0 ? token : token.slice(0, slash)
-}
-
-const numericScore = (row) => typeof row?.score === "number" && Number.isFinite(row.score)
-
-// Fallbacks for score files written before the floors were recorded there.
-const MIN_CONTEXT = 200_000
-const MIN_SCORE = 60
-const POOL_SIZE = 10
-
 function splitHeaderAndSlots(text) {
   const lines = String(text ?? "").split(/\r?\n/)
   // Drop a single trailing empty element produced by a final newline so we can
@@ -66,7 +55,7 @@ function splitHeaderAndSlots(text) {
 function refreshComment(now, scoresGeneratedAt) {
   const when = now instanceof Date ? now.toISOString() : String(now)
   const gen = scoresGeneratedAt ? ` (scores generated ${scoresGeneratedAt})` : ""
-  return `# Refreshed ${when} from model-scores.json${gen}: opencode-go first (weight 4), then the best others (weight 2).`
+  return `# Refreshed ${when} from model-scores.json${gen}: opencode-go first (weight 4), small-context providers (weight 2), large-context providers (weight 1), opencode last (max 1).`
 }
 
 function withRefreshComment(headerLines, comment) {
@@ -74,8 +63,9 @@ function withRefreshComment(headerLines, comment) {
   return [...kept, comment]
 }
 
-function formatGeneratedLine(model, weight, bucket) {
+function formatGeneratedLine(model, weight, bucket, context) {
   const parts = [String(model), String(weight)]
+  if (context != null && Number.isFinite(Number(context))) parts.push(`c:${Math.round(Number(context))}`)
   if (bucket) parts.push(`b:${bucket}`)
   return parts.join("  ")
 }
@@ -84,56 +74,36 @@ function formatGeneratedLine(model, weight, bucket) {
  * Pure builder. Throws on every fail-closed condition; never touches the filesystem.
  *
  * @param {{ scores: any, currentPoolText: string, now?: Date|string }} input
- * @returns {{ text: string, slots: string[], warnings: string[], chosen: { opencodeGo: string[], others: string[] } }}
+ * @returns {{ text: string, slots: string[], warnings: string[], chosen: { selected: string[] } }}
  */
 export function buildPool(input) {
-  const warnings = []
   const scores = input?.scores
-  if (!scores || typeof scores !== "object" || !Array.isArray(scores.providers)) {
-    throw new Error("score file is missing or invalid (expected { providers: [...] })")
-  }
-
-  const minScore = Number(scores.minScore) || MIN_SCORE
-  const minContext = Number(scores.minContext) || MIN_CONTEXT
-  const rankable = (row) =>
-    row?.ok === true &&
-    numericScore(row) &&
-    row.score >= minScore &&
-    (row.context == null || row.context >= minContext)
-  const byScore = (a, b) => b.score - a.score || String(a.model).localeCompare(String(b.model))
-
-  const rows = scores.providers.flatMap((entry) => (Array.isArray(entry?.rows) ? entry.rows : []))
-  const goRows = rows.filter((row) => providerOf(row.model) === "opencode-go" && rankable(row)).sort(byScore)
-  const others = rows.filter((row) => providerOf(row.model) !== "opencode-go" && rankable(row)).sort(byScore)
-  const otherRows = others.slice(0, Math.max(0, POOL_SIZE - goRows.length))
-
-  if (goRows.length + otherRows.length === 0) {
-    throw new Error("no scorable model at or above the minimum score is available; refusing to write pool.txt")
+  if (!scores || typeof scores !== "object" || !Array.isArray(scores.providers) || !Array.isArray(scores.selection)) {
+    throw new Error("score file is missing or invalid (expected { providers: [...], selection: [...] })")
   }
-  if (goRows.length + otherRows.length < POOL_SIZE) {
-    warnings.push(`only ${goRows.length + otherRows.length} scorable model(s) available, wanted ${POOL_SIZE}`)
+  const selection = scores.selection.filter(
+    (entry) =>
+      entry &&
+      typeof entry.model === "string" &&
+      entry.model.includes("/") &&
+      typeof entry.weight === "number" &&
+      Number.isFinite(entry.weight) &&
+      entry.weight > 0,
+  )
+  if (selection.length === 0) {
+    throw new Error("score file has no selected models; refusing to write pool.txt")
   }
-
+  const warnings = Array.isArray(scores.warnings) ? scores.warnings : []
   const { header } = splitHeaderAndSlots(input?.currentPoolText ?? "")
-  const outSlots = [
-    ...goRows.map((row) => formatGeneratedLine(row.model, 4)),
-    ...otherRows.map((row) =>
-      formatGeneratedLine(row.model, 2, providerOf(row.model) === "opencode" ? "opencode" : undefined),
-    ),
-  ]
-
+  const outSlots = selection.map((entry) => formatGeneratedLine(entry.model, entry.weight, entry.bucket, entry.context))
   const comment = refreshComment(input?.now ?? new Date(), scores.generatedAt)
   const outHeader = withRefreshComment(header, comment)
-
   const text = [...outHeader, "", ...outSlots, ""].join("\n")
   return {
     text,
     slots: outSlots,
     warnings,
-    chosen: {
-      opencodeGo: goRows.map((r) => r.model),
-      others: otherRows.map((r) => r.model),
-    },
+    chosen: { selected: selection.map((entry) => entry.model) },
   }
 }
 
@@ -173,6 +143,41 @@ function runScorer(max) {
   execFileSync(process.execPath, args, { stdio: "inherit" })
 }
 
+export function scheduleRetry(retry, options = {}) {
+  const at = Date.parse(retry?.after ?? "")
+  if (!Number.isFinite(at)) return { scheduled: false, reason: "no reset time" }
+  const now = options.now ?? Date.now
+  const nowMs = now()
+  const seconds = Math.ceil((at - nowMs) / 1000)
+  if (!Number.isFinite(seconds) || seconds <= 0) return { scheduled: false, reason: "reset is not in the future" }
+  if (seconds > 24 * 60 * 60) return { scheduled: false, reason: "reset is more than a day away" }
+  const exec = options.exec ?? execFileSync
+  const scriptPath = options.scriptPath ?? fileURLToPath(import.meta.url)
+  const nodePath = options.nodePath ?? process.execPath
+  const home = options.home ?? HOME
+  const path = `${home}/.opencode/bin:/usr/local/bin:/usr/bin:/bin`
+  const unit = `lacode-refresh-pool-retry-${Math.floor(nowMs / 1000).toString(36)}`
+  try {
+    exec(
+      "systemd-run",
+      [
+        "--user",
+        "--collect",
+        `--unit=${unit}`,
+        `--on-active=${seconds}`,
+        `--setenv=HOME=${home}`,
+        `--setenv=PATH=${path}`,
+        nodePath,
+        scriptPath,
+      ],
+      { stdio: "ignore" },
+    )
+    return { scheduled: true, seconds, after: retry.after }
+  } catch (error) {
+    return { scheduled: false, reason: String(error?.message ?? error) }
+  }
+}
+
 export function renderTimerUnits(input = {}) {
   const nodePath = input.nodePath || process.execPath
   const scriptPath = input.scriptPath || fileURLToPath(import.meta.url)
@@ -212,6 +217,8 @@ function installTimerUnits(stable = false) {
     if (stable) {
       mkdirSync(STABLE_LIB_DIR(HOME), { recursive: true })
       copyFileSync(live, scriptPath)
+      copyFileSync(resolve(dirname(live), "score-models.mjs"), STABLE_SCORER(HOME))
+      copyFileSync(resolve(dirname(live), "pool-selection.mjs"), STABLE_SELECTION(HOME))
     }
     mkdirSync(dirname(units.servicePath), { recursive: true })
     writeFileAtomic(units.servicePath, units.service)
@@ -232,7 +239,7 @@ function installTimerUnits(stable = false) {
     process.exitCode = 1
     return false
   }
-  if (stable) console.log(`copied ${live} to ${scriptPath}`)
+  if (stable) console.log(`copied ${live}, score-models.mjs and pool-selection.mjs to ${STABLE_LIB_DIR(HOME)}`)
   console.log(`installed ${units.servicePath}`)
   console.log(`installed ${units.timerPath}`)
   console.log(`enabled ${REFRESH_TIMER_NAME}`)
@@ -243,12 +250,13 @@ function usage() {
   console.log(`Usage: node scripts/refresh-pool.mjs [options]
 
   --from-scores     skip scoring, use the existing ~/.config/lacode/model-scores.json
+  --no-retry        do not schedule a transient retry after a rate-limited run
   --install-timer   install and enable a user systemd oneshot service + daily timer
                     (add --stable to copy the script to ~/.local/lib/lacode and
                     point ExecStart there, so plugin-cache updates do not break it)
   --print           print the proposed pool.txt and make no changes (alias: --dry-run)
   --dry-run         same as --print
-  --max N           models per provider passed to the scorer (default: 20)
+  --max N           models per provider passed to the scorer (default: 50)
   --scores PATH     scores file (default: ${DEFAULT_SCORES_PATH})
   --pool PATH       pool file to read/compare/write (default: ${DEFAULT_POOL_PATH})
   -h, --help        this message`)
@@ -263,12 +271,13 @@ async function main() {
     }
   const fromScores = argv.includes("--from-scores")
   const printOnly = argv.includes("--print") || argv.includes("--dry-run")
+  const noRetry = argv.includes("--no-retry")
   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]
   }
-  const max = Math.max(1, Number(value("--max", "20")) || 20)
+  const max = Math.max(1, Number(value("--max", "50")) || 50)
   const scoresPath = value("--scores", DEFAULT_SCORES_PATH)
   const poolPath = value("--pool", DEFAULT_POOL_PATH)
 
@@ -305,12 +314,20 @@ async function main() {
   const newSlotCount = built.slots.filter(isSlotLine).length
   const dropped = scores.providers.flatMap((entry) => (Array.isArray(entry?.excluded) ? entry.excluded : []))
   const summary = [
-    `opencode-go [${built.chosen.opencodeGo.join(", ")}]`,
-    `others [${built.chosen.others.join(", ")}]`,
-    ...(dropped.length ? [`dropped [${dropped.map((x) => x.model).join(", ")}]`] : []),
+    `selected [${built.chosen.selected.join(", ")}]`,
+    ...(dropped.length ? [`dropped ${dropped.length} model(s) below the context/score floor`] : []),
     ...(built.warnings.length ? [`warnings [${built.warnings.join("; ")}]`] : []),
   ].join(" | ")
 
+  if (!printOnly && !noRetry) {
+    const scheduled = scheduleRetry(scores.retry)
+    if (scheduled.scheduled) {
+      console.log(`scheduled retry in ${scheduled.seconds}s for ${scores.retry.models.length} model(s) at ${scheduled.after}`)
+    } else if (scores.retry) {
+      console.log(`retry not scheduled: ${scheduled.reason}`)
+    }
+  }
+
   if (printOnly) {
     process.stdout.write(built.text)
     console.error(`--print: proposed ${oldSlotCount} -> ${newSlotCount} slots; no changes written. ${summary}`)

package/scripts/score-models.mjs

@@ -26,8 +26,10 @@
 //     measured score is below --min-score: those are listed as excluded instead.
 //   * 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 (non-chat/media/safety/meta-router models are skipped).
+//   * opencode and opencode-go stay free-only. Every other provider is probed
+//     even when its catalogue lists a price, because provider credits cover it;
+//     --free-only restores the cost-0 rule everywhere. Non-chat/media/safety/
+//     meta-router models are always skipped.
 //
 // OUTPUT
 //   a per-provider ranked table, an overall ranking, a suggested pool.txt block,
@@ -38,24 +40,27 @@ import { execFileSync, spawn } from "node:child_process"
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { dirname, join } from "node:path"
+import { MIN_CONTEXT, MIN_SCORE, retryAfterMs, selectPool } from "./pool-selection.mjs"
 
 const AUTH = join(homedir(), ".local", "share", "opencode", "auth.json")
 const OUT = join(homedir(), ".config", "lacode", "model-scores.json")
 // No default provider list: `opencode models --verbose` with no argument returns
 // every provider opencode knows about, and that is what we scan by default.
 const SESSION_PROVIDERS = new Set(["opencode", "opencode-go"])
+const FREE_ONLY_PROVIDERS = new Set(["opencode", "opencode-go"])
 
 // ── 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 MIN_CONTEXT = 200_000 // below this, a model is excluded instead of ranked
-const MIN_SCORE = 60 // below this, a probed model is excluded from ranking
 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
+const PROBE_ATTEMPTS = 2 // one retry for a timeout or a dropped connection
+const isTransientProbe = (reason) =>
+  /timeout|timed out|ECONNRESET|ETIMEDOUT|fetch failed|socket hang up|no answer/i.test(String(reason ?? ""))
 
 // ── args ────────────────────────────────────────────────────────────────────
 const argv = process.argv.slice(2)
@@ -70,31 +75,36 @@ const value = (flag, fallback) => {
     console.log(`Usage: npm run score -- [options]
 
   --providers a,b   restrict the scan to these providers (default: all configured)
-  --max N           probe at most N free models per provider (default: 12)
+  --max N           probe at most N candidate models per provider (default: 50)
   --min-context N   exclude models whose context limit is below N (default: ${MIN_CONTEXT})
   --min-score N     do not rank models scoring below N (default: ${MIN_SCORE})
-  --timeout MS      per-request deadline in ms (default: 20000)
+  --free-only        only probe catalogue cost 0/0 models on every provider
+  --timeout MS      per-request deadline in ms (default: 45000)
   --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 concrete text chat/completion models are candidates
-(non-chat/media generators, safety classifiers, and OpenRouter meta-routers are skipped).
+opencode and opencode-go stay free-only; every other provider is probed even
+when its catalogue lists a price, because provider credits cover it. Use
+--free-only to apply the cost-0 rule everywhere. Non-chat/media generators,
+safety classifiers, and OpenRouter meta-routers are always skipped.
 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).
-opencode/opencode-go models are probed through a temporary local opencode serve --pure session, while the other providers are probed directly.`)
+opencode/opencode-go models are probed through a temporary local opencode serve --pure session, while the other providers are probed directly.
+Providers with no direct HTTP endpoint (or an unexpanded \${...} URL) are probed through the same local opencode session as opencode/opencode-go.`)
     process.exit(0)
   }
 
 const providerArg = value("--providers", null)
 const providers = providerArg ? String(providerArg).split(",").map((s) => s.trim()).filter(Boolean) : null
-const maxPerProvider = Math.max(1, Number(value("--max", "12")) || 12)
+const maxPerProvider = Math.max(1, Number(value("--max", "50")) || 50)
 const minContext = Math.max(0, Number(value("--min-context", String(MIN_CONTEXT))) || MIN_CONTEXT)
 const minScore = Math.max(0, Number(value("--min-score", String(MIN_SCORE))) || MIN_SCORE)
-const timeoutMs = Math.max(1_000, Number(value("--timeout", "20000")) || 20_000)
+const timeoutMs = Math.max(1_000, Number(value("--timeout", "45000")) || 45_000)
 const delayMs = Math.max(0, Number(value("--delay", "300")) || 300)
 const writeResults = !has("--no-write")
+const freeOnlyFlag = has("--free-only")
 
 // ── discovery ───────────────────────────────────────────────────────────────
 /** Parse `opencode models --verbose <provider>`: alternating id line + JSON block. */
@@ -148,9 +158,10 @@ function isChatModel(model) {
 }
 
 function buildProviderEntry(provider, rows) {
+  const freeOnly = freeOnlyFlag || FREE_ONLY_PROVIDERS.has(provider)
   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?.api?.id)
+    .filter(({ model }) => !freeOnly || ((model.cost?.input ?? 1) === 0 && (model.cost?.output ?? 1) === 0))
     .filter(({ model }) => !model.status || model.status === "active")
     .filter(({ model }) => isChatModel(model))
     .map(({ id, model }) => ({
@@ -372,10 +383,17 @@ async function probeDirect(candidate, provider) {
             : response.status === 404
               ? "not served"
               : `http ${response.status}`
-      return { ok: false, ms, reason: `${kind}: ${detail}` }
+      const retryAfter =
+        kind === "rate-limited" || /credit|402/i.test(detail)
+          ? retryAfterMs(body, response.headers.get("retry-after"))
+          : undefined
+      return { ok: false, ms, reason: `${kind}: ${detail}`, retryAfter }
     }
     // 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 (parsed?.error) {
+      const reason = `${parsed.error.message ?? "error"} `.trim()
+      return { ok: false, ms, reason, retryAfter: retryAfterMs(reason) }
+    }
     if (!Array.isArray(parsed?.choices) || parsed.choices.length === 0) {
       return { ok: false, ms, reason: "no choices in response" }
     }
@@ -409,7 +427,7 @@ async function probeViaSession(candidate, provider) {
     if (!createRes.ok) {
       const detail = createdJson?.error?.message ?? createdJson?.message ?? createText.slice(0, 160)
       const ms = Math.round(performance.now() - started)
-      return { ok: false, ms, reason: `session create http ${createRes.status}: ${detail}` }
+      return { ok: false, ms, reason: `session create http ${createRes.status}: ${detail}`, retryAfter: retryAfterMs(detail) }
     }
     id = createdJson?.id ?? createdJson?.data?.id ?? null
     if (!id) {
@@ -435,11 +453,12 @@ async function probeViaSession(candidate, provider) {
     const ms = Math.round(performance.now() - (promptStarted ?? started))
     if (!msgRes.ok) {
       const detail = parsed?.error?.message ?? parsed?.message ?? msgText.slice(0, 160)
-      return { ok: false, ms, reason: `http ${msgRes.status}: ${detail}` }
+      return { ok: false, ms, reason: `http ${msgRes.status}: ${detail}`, retryAfter: retryAfterMs(detail) }
     }
     const failure = parsed?.error ?? parsed?.info?.error
     if (failure) {
-      return { ok: false, ms, reason: failureText(failure).slice(0, 240) }
+      const reason = failureText(failure).slice(0, 240)
+      return { ok: false, ms, reason, retryAfter: retryAfterMs(reason) }
     }
     if (!parsed?.info) {
       return { ok: false, ms, reason: "no response" }
@@ -450,7 +469,8 @@ async function probeViaSession(candidate, provider) {
     if (error?.name === "TimeoutError") {
       return { ok: false, ms, reason: `timeout after ${timeoutMs}ms` }
     }
-    return { ok: false, ms, reason: failureText(error).slice(0, 240) }
+    const reason = failureText(error).slice(0, 240)
+    return { ok: false, ms, reason, retryAfter: retryAfterMs(reason) }
   } finally {
     if (id && server) {
       try {
@@ -460,9 +480,22 @@ async function probeViaSession(candidate, provider) {
   }
 }
 
+function usesSession(provider, candidate) {
+  if (SESSION_PROVIDERS.has(provider)) return true
+  const url = String(candidate.url ?? "")
+  return url.length === 0 || url.includes("${")
+}
+
 async function probe(candidate, provider) {
-  if (SESSION_PROVIDERS.has(provider)) return probeViaSession(candidate, provider)
-  return probeDirect(candidate, provider)
+  if (usesSession(provider, candidate)) return probeViaSession(candidate, provider)
+  const outcome = await probeDirect(candidate, provider)
+  if (outcome.ok) return outcome
+  // A provider whose direct URL is misconfigured can still be reachable
+  // through opencode's own provider resolution.
+  if (/credential|no credential|not served|invalid request path|could not route/i.test(String(outcome.reason ?? ""))) {
+    return probeViaSession(candidate, provider)
+  }
+  return outcome
 }
 
 // ── scoring ─────────────────────────────────────────────────────────────────
@@ -497,7 +530,7 @@ async function main() {
     }
     const candidates = entry.models.slice(0, maxPerProvider)
     const excludedNote = entry.excluded.length ? `, ${entry.excluded.length} excluded (context < ${minContext})` : ""
-    console.log(`\n${entry.provider}: probing ${candidates.length} free model(s)${entry.models.length > candidates.length ? ` of ${entry.models.length}` : ""}${excludedNote}`)
+    console.log(`\n${entry.provider}: probing ${candidates.length} candidate model(s)${entry.models.length > candidates.length ? ` of ${entry.models.length}` : ""}${excludedNote}`)
     if (entry.excluded.length) {
       console.log(`  excluded — context below ${minContext}:`)
       for (const x of entry.excluded) console.log(`    ${pad(x.model.replace(`${entry.provider}/`, ""), 52)} ${padL(x.context, 9)}`)
@@ -508,7 +541,12 @@ async function main() {
     }
     const rows = []
     for (const candidate of candidates) {
-      const outcome = await probe(candidate, entry.provider)
+      let outcome = await probe(candidate, entry.provider)
+      for (let attempt = 1; attempt < PROBE_ATTEMPTS && !outcome.ok && isTransientProbe(outcome.reason); attempt++) {
+        console.log(`  retrying ${candidate.model.replace(`${entry.provider}/`, "")} after ${String(outcome.reason).slice(0, 60)}`)
+        await sleep(delayMs)
+        outcome = await probe(candidate, entry.provider)
+      }
       const row = { provider: entry.provider, ...candidate, ...outcome, score: null }
       row.score = score(row)
       if (row.score && row.score.value < minScore) {
@@ -556,28 +594,41 @@ async function main() {
   const all = results.flatMap((e) => e.rows).filter((r) => r.score && r.score.value >= minScore)
   all.sort((a, b) => b.score.value - a.score.value)
   if (all.length) {
-    console.log(`\noverall — best free models right now`)
+    console.log(`\noverall — best candidate 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: every opencode-go model (weight 4), then the best
-  // (10 - n) models from the other providers (weight 2), by measured score.
-  // Printed, never written — pool.txt stays the user's decision.
-  const poolSize = 10
-  const goRows = all.filter((r) => r.model.startsWith("opencode-go/"))
-  const otherRows = all.filter((r) => !r.model.startsWith("opencode-go/"))
-  const pickedOthers = otherRows.slice(0, Math.max(0, poolSize - goRows.length))
-  const suggested = [
-    ...goRows.map((r) => ({ row: r, weight: 4 })),
-    ...pickedOthers.map((r) => ({ row: r, weight: 2 })),
-  ]
-  if (suggested.length) {
+  // Previous scores let a transient outage keep the pool it had.
+  const previousScores = (() => {
+    try {
+      return JSON.parse(readFileSync(OUT, "utf8"))
+    } catch {
+      return null
+    }
+  })()
+  const { selection, warnings, retry } = selectPool({
+    providers: results.map((entry) => ({
+      provider: entry.provider,
+      error: entry.error,
+      rows: entry.rows.map((row) => ({ ...row, score: row.score?.value ?? null })),
+      excluded: entry.excluded,
+    })),
+    previousProviders: previousScores?.providers,
+    minContext,
+    minScore,
+  })
+
+  if (selection.length) {
     console.log(`\nsuggested pool.txt (paste if it matches your judgement — nothing was changed)`)
-    console.log(`# scored ${new Date().toISOString()} — opencode-go first (weight 4), then the best others (weight 2)`)
-    for (const { row, weight } of suggested) console.log(`${pad(row.model, 60)}${weight}`)
+    console.log(`# scored ${new Date().toISOString()} — opencode-go first (weight 4), small-context providers (weight 2), large-context providers (weight 1), opencode last (max 1)`)
+    for (const entry of selection) {
+      const bucket = entry.bucket ? `  b:${entry.bucket}` : ""
+      console.log(`${pad(entry.model, 60)}${entry.weight}${bucket}`)
+    }
   }
+  if (retry) console.log(`\nlimited: ${retry.models.length} model(s); retry after ${retry.after}`)
 
   if (writeResults) {
     try {
@@ -587,6 +638,9 @@ async function main() {
         weights: W,
         minContext,
         minScore,
+        selection,
+        warnings,
+        retry,
         providers: results.map((e) => ({
           provider: e.provider,
           error: e.error,
@@ -599,6 +653,7 @@ async function main() {
             ms: r.ms,
             reason: r.reason,
             score: r.score?.value ?? null,
+            retryAfter: r.retryAfter ?? null,
           })),
         })),
       }