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

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.0.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

@@ -6,20 +6,20 @@
 // writes on a fail-closed condition.
 //
 // Layout (exact, per spec):
-//   1. every free opencode-go model with ok:true and a numeric score, one slot
-//      each, sorted by score descending, weight 4
-//   2. every slot from the current pool whose provider is NOT present in the
-//      score file, preserved exactly (raw line text, weight/bucket/notify, order)
-//   3. exactly one free opencode model — the best ok:true numeric score —
-//      weight 2, with b:opencode
+//   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 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 = #opencode-go free + #preserved unscored + 1.
+// Total = n + min(10 - n, #others), where n = #1.
 //
 // This file ships as source and must run with plain `node` (ESM, no TS).
 
-import { mkdirSync, renameSync, writeFileSync, readFileSync, existsSync } from "node:fs"
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
 import { execFileSync } from "node:child_process"
-import { homedir } from "node:os"
+import { homedir, userInfo } from "node:os"
 import { dirname, join, resolve } from "node:path"
 import { fileURLToPath } from "node:url"
 
@@ -27,6 +27,10 @@ const HOME = homedir()
 export const DEFAULT_SCORES_PATH = join(HOME, ".config", "lacode", "model-scores.json")
 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"
 
@@ -35,25 +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 isFree = (modelId) => {
-  const id = String(modelId || "")
-  return id.endsWith(":free") || id.endsWith("-free")
-}
-
-const numericScore = (row) => typeof row?.score === "number" && Number.isFinite(row.score)
-
-const okFreeRows = (providerEntry) => {
-  const rows = Array.isArray(providerEntry?.rows) ? providerEntry.rows : []
-  return rows.filter((row) => row?.ok === true && numericScore(row) && isFree(row.model))
-}
-
 function splitHeaderAndSlots(text) {
   const lines = String(text ?? "").split(/\r?\n/)
   // Drop a single trailing empty element produced by a final newline so we can
@@ -70,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 free models first, best opencode last.`
+  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) {
@@ -78,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("  ")
 }
@@ -88,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[], opencode: string, preserved: 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: [...] })")
+  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: [...] })")
   }
-
-  const providerEntries = scores.providers
-  const scoredProviders = new Set(
-    providerEntries.map((p) => String(p?.provider ?? "").trim()).filter(Boolean),
+  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,
   )
-
-  const goEntry = providerEntries.find((p) => p?.provider === "opencode-go")
-  const goRows = okFreeRows(goEntry).sort((a, b) => b.score - a.score)
-  if (goRows.length === 0) {
-    throw new Error("no free opencode-go model with ok:true and a numeric score is available; refusing to write pool.txt")
+  if (selection.length === 0) {
+    throw new Error("score file has no selected models; refusing to write pool.txt")
   }
-
-  const opEntry = providerEntries.find((p) => p?.provider === "opencode")
-  const opRows = okFreeRows(opEntry).sort((a, b) => b.score - a.score)
-  if (opRows.length === 0) {
-    throw new Error("no free opencode model with ok:true and a numeric score is available; refusing to write pool.txt")
-  }
-  const bestOp = opRows[0].model
-
-  const { header, slots: currentSlots } = splitHeaderAndSlots(input?.currentPoolText ?? "")
-  const preserved = currentSlots.filter((line) => {
-    if (!isSlotLine(line)) return false
-    return !scoredProviders.has(providerOf(line))
-  })
-
-  const block1 = goRows.map((row) => formatGeneratedLine(row.model, 4))
-  const block3 = [formatGeneratedLine(bestOp, 2, "opencode")]
-  const outSlots = [...block1, ...preserved, ...block3]
-
+  const warnings = Array.isArray(scores.warnings) ? scores.warnings : []
+  const { header } = splitHeaderAndSlots(input?.currentPoolText ?? "")
+  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),
-      opencode: bestOp,
-      preserved: preserved.map((l) => String(l).split("#")[0].trim().split(/\s+/)[0]),
-    },
+    chosen: { selected: selection.map((entry) => entry.model) },
   }
 }
 
@@ -163,6 +129,12 @@ function atomicWriteSimple(path, text) {
   renameSync(tmp, path)
 }
 
+function writeFileAtomic(path, text) {
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`
+  writeFileSync(tmp, text, "utf8")
+  renameSync(tmp, path)
+}
+
 function runScorer(max) {
   const here = dirname(fileURLToPath(import.meta.url))
   const scorer = resolve(here, "score-models.mjs")
@@ -171,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)
@@ -192,8 +199,7 @@ Nice=10
 Description=Daily LaCode model pool refresh
 
 [Timer]
-OnCalendar=daily
-RandomizedDelaySec=2h
+OnCalendar=*-*-* 01:00:00
 Persistent=true
 Unit=${REFRESH_SERVICE_NAME}
 
@@ -203,18 +209,25 @@ WantedBy=timers.target
   return { service, timer, servicePath, timerPath }
 }
 
-function installTimerUnits() {
-  const units = renderTimerUnits({
-    nodePath: process.execPath,
-    scriptPath: fileURLToPath(import.meta.url),
-    home: HOME,
-  })
-  mkdirSync(dirname(units.servicePath), { recursive: true })
-  writeFileSync(units.servicePath, units.service, "utf8")
-  writeFileSync(units.timerPath, units.timer, "utf8")
+function installTimerUnits(stable = false) {
+  const live = fileURLToPath(import.meta.url)
+  const scriptPath = stable ? STABLE_SCRIPT(HOME) : live
+  const units = renderTimerUnits({ nodePath: process.execPath, scriptPath, home: HOME })
   try {
+    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)
+    writeFileAtomic(units.timerPath, units.timer)
     execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" })
     execFileSync("systemctl", ["--user", "enable", "--now", REFRESH_TIMER_NAME], { stdio: "inherit" })
+    try {
+      execFileSync("loginctl", ["enable-linger", userInfo().username], { stdio: "ignore" })
+    } catch {}
   } catch (error) {
     console.error(`failed to install systemd user timer: ${String(error?.message ?? error)}`)
     console.error(`unit files written:`)
@@ -226,6 +239,7 @@ function installTimerUnits() {
     process.exitCode = 1
     return false
   }
+  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}`)
@@ -236,10 +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`)
@@ -248,18 +265,19 @@ function usage() {
 async function main() {
   const argv = process.argv.slice(2)
   if (argv.includes("--help") || argv.includes("-h")) { usage(); return }
-  if (argv.includes("--install-timer")) {
-    installTimerUnits()
-    return
-  }
+    if (argv.includes("--install-timer")) {
+      installTimerUnits(argv.includes("--stable"))
+      return
+    }
   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)
 
@@ -294,12 +312,22 @@ async function main() {
 
   const oldSlotCount = splitHeaderAndSlots(currentPoolText).slots.filter(isSlotLine).length
   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(", ")}]`,
-    `preserved-unscored [${built.chosen.preserved.join(", ")}]`,
-    `opencode-last [${built.chosen.opencode}]`,
+    `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}`)