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

package/CHANGELOG.md

@@ -9,6 +9,26 @@ commit as the changelog entry it describes.
 
 ## [Unreleased]
 
+## [2.1.0-beta.0] — every provider counts, and the timer installs itself
+
+### Added
+
+- Pool: `npm run score` scans every configured provider in one `opencode models --verbose` call. `--min-context` (default 200000) and `--min-score` (default 60) exclude weak models, and both floors are recorded in `model-scores.json`.
+- Timer migration: plugin startup installs or refreshes the pool-refresh systemd user timer once per package version, from a stable copy at `~/.local/lib/lacode/refresh-pool.mjs`. Opt out with `LACODE_NO_TIMER_MIGRATION=1`.
+- `scripts/refresh-pool.mjs --install-timer --stable` installs that stable timer by hand.
+- Timeline: a root `task` part expands into the child session's title and outcome, and `NO_PROJECT_CHANGES` is the explicit success token for a summary that found no project changes.
+
+### Changed
+
+- Pool: `scripts/refresh-pool.mjs` rebuilds `~/.config/lacode/pool.txt` from the best scored models across all providers — every opencode-go model at weight 4, then the best `10 - n` others at weight 2. Unscored/paid lines are no longer preserved.
+- Pool: the refresh timer runs daily at 01:00 with no randomized delay; the 15-minute in-process cooldown probe is unchanged.
+- Timer units are written atomically, and the installer enables user linger best-effort.
+- Timeline: side-maintenance sessions and their tool parts are excluded from the summarizer prompt and the rendered timeline; an empty summarizer reply is now a failure instead of an empty success.
+
+### Fixed
+
+- Timeline: a `NO_PROJECT_CHANGES` slice still advances the durable cursor, and `/reprocess-timeline` no longer aborts on it.
+
 ## [2.0.0-beta.0] — The timeline remembers, and the map has one job
 
 ### Added
@@ -1132,7 +1152,8 @@ experimental; `latest` remains 0.4.2.
 
 - First published release: pooled subagents over a shared set of models.
 
-[Unreleased]: https://github.com/lawaty/lacode/compare/v2.0.0-beta.0...HEAD
+[Unreleased]: https://github.com/lawaty/lacode/compare/v2.1.0-beta.0...HEAD
+[2.1.0-beta.0]: https://github.com/lawaty/lacode/compare/v2.0.0-beta.0...v2.1.0-beta.0
 [2.0.0-beta.0]: https://github.com/lawaty/lacode/compare/v1.3.1...v2.0.0-beta.0
 [1.3.1]: https://github.com/lawaty/lacode/releases/tag/v1.3.1
 [1.3.0-beta.9]: https://github.com/lawaty/lacode/releases/tag/v1.3.0-beta.9

package/dist/index.js

@@ -6489,7 +6489,8 @@ async function selfUpdateHooks(input, options) {
 }
 
 // src/plugins/timeline.ts
-import { writeFileSync as writeFileSync10, renameSync as renameSync7, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync5, writeFileSync as writeFileSync10, renameSync as renameSync7, rmSync as rmSync3 } from "node:fs";
+import { join as join12 } from "node:path";
 import { tool as tool2 } from "@opencode-ai/plugin";
 
 // src/lib/timeline.ts
@@ -6761,6 +6762,49 @@ function summarizeToolResult(state2) {
   }
   return "";
 }
+function isSideTool(tool3, input) {
+  if (tool3 === "timeline_reprocess" || tool3 === "pool_status" || tool3 === "pool_recheck") return true;
+  if (tool3 === "task" && input !== null && input !== void 0 && typeof input === "object") {
+    return input.subagent_type === "context";
+  }
+  return false;
+}
+function mentionsSideMaintenance(text) {
+  return /\b(?:timeline_reprocess|pool_status|pool_recheck|reprocess-timeline|cartographer)\b/i.test(text);
+}
+function isSideMaintenanceTask(input, rootDirectory, projectOwnsTooling) {
+  if (projectOwnsTooling) return false;
+  let description = "";
+  let prompt = "";
+  if (input !== null && input !== void 0 && typeof input === "object") {
+    const rec = input;
+    if (typeof rec.description === "string") description = rec.description;
+    if (typeof rec.prompt === "string") prompt = rec.prompt;
+  }
+  const text = [description, prompt].filter((s) => typeof s === "string" && s.length > 0).join("\n");
+  if (text === "") return false;
+  if (/\.config\/(?:opencode|lacode)|\.local\/share\/opencode/i.test(text)) return true;
+  if (mentionsSideMaintenance(text)) return true;
+  const root = rootDirectory.replace(/\\/g, "/").replace(/\/+$/, "");
+  for (const match of text.matchAll(/\/(?:home|Users|root|opt|srv|mnt|workspace|workspaces)\/[^\s"'`),;]+/gi)) {
+    const cleaned = match[0].replace(/[.,:;!?]+$/, "");
+    if (!(cleaned.includes("/Projects/") || cleaned.includes("/projects/"))) continue;
+    if (cleaned === root || cleaned.startsWith(root + "/")) continue;
+    return true;
+  }
+  return false;
+}
+function taskChildSessionId(part) {
+  const sessionId = part.state?.metadata?.sessionId;
+  if (typeof sessionId === "string" && sessionId.length > 0) return sessionId;
+  const output = part.state?.output;
+  if (typeof output !== "string") return void 0;
+  const taskMatch = output.match(/task id="([A-Za-z0-9_.-]+)"/);
+  if (taskMatch) return taskMatch[1];
+  const sesMatch = output.match(/ses_[A-Za-z0-9]+/);
+  if (sesMatch) return sesMatch[0];
+  return void 0;
+}
 function renderMessage(m) {
   const role = m.info.role;
   const lines = [];
@@ -6774,18 +6818,29 @@ function renderMessage(m) {
     }
   } else if (role === "assistant") {
     for (const p of m.parts) {
+      if (p.side === true) continue;
       if (p.type === "text") {
         const text = collapse(p.text ?? "");
         lines.push(`[assistant] ${trunc(text, 1500)}`);
       } else if (p.type === "tool") {
+        if (p.side === true) continue;
         const tool3 = p.tool ?? "";
-        if (tool3 === "timeline_reprocess") continue;
+        if (isSideTool(tool3, p.state?.input)) continue;
         const status = p.state?.status;
         const summary = inputSummary(p.state?.input);
-        const result = summarizeToolResult(p.state);
+        let result = summarizeToolResult(p.state);
+        let suppressInput = false;
+        if (tool3 === "task" && typeof p.childTitle === "string" && collapse(p.childTitle) !== "") {
+          const title = trunc(collapse(p.childTitle), 160);
+          result = title;
+          if (typeof p.childOutcome === "string" && collapse(p.childOutcome) !== "") {
+            result = `${title}: ${trunc(collapse(p.childOutcome), 600)}`;
+          }
+          if (summary && title.startsWith(summary)) suppressInput = true;
+        }
         let line = `[tool] ${tool3}`;
         if (status) line += ` (${status})`;
-        const inputPart = summary ? trunc(summary, 220) : "";
+        const inputPart = summary && !suppressInput ? trunc(summary, 220) : "";
         let rest = "";
         if (inputPart) rest += ` ${inputPart}`;
         if (result) rest += ` -> ${result}`;
@@ -6910,12 +6965,17 @@ var DEFAULT_MAX_ENTRIES = 8;
 var MAX_ENTRIES = 10;
 var PROMPT_TIMEOUT_MS = 9e4;
 var SYSTEM = `You are the session timeline summarizer. You receive a slice of a coding session transcript.
-Write 1-8 timeline entries describing the work as tasks, features, fixes, or stages.
+Maintain a timeline of the project's own work: features, fixes, refactors, behavior changes, user-visible capabilities, architectural decisions, data/model changes, and documentation that defines project behavior.
+Write 1-8 timeline entries describing that project work.
 
 Rules:
 - One entry per line, each starting with "- ".
 - Each entry is 6-16 words, past tense, plain text.
-- Cover each distinct task in the slice. Do not drop a provider, feature, fix, config, docs, or test change; merge only exact duplicates.
+- Cover each distinct project task in the slice. Do not drop a feature, fix, refactor, behavior change, user-visible capability, architectural decision, data/model change, or documentation that defines project behavior; merge only exact duplicates.
+- Record project test changes at the capability level, not as housekeeping; do not report counts.
+- Ignore self-maintenance and infrastructure: the context map/cartographer, timeline rebuilding/summarization, model-pool status/rechecks, plugin install/update, agent/command configuration, formatting/lint/dependency churn, and build/dist artifacts.
+- Name modules, components, services, or capabilities when they are the subject. Do not list file paths, line numbers, counts, commit hashes, or build artifacts.
+- Record decisions or findings that changed the plan, not routine searches or reads.
 - Describe the TASK or OUTCOME, not the implementation. "Pool: added bucket-based routing" is right; "added b:<name> to pool.ts and agent-pool.ts" is too detailed.
 - Never describe the mechanism: no flags, aliases, overrides, endpoints, probes, config keys, declarations, tags, or file changes. State what changed for the system: which capability now works, which bug is fixed, which behavior changed.
 - Never use these words in an entry: tag, alias, override, flag, probe, endpoint, config key, catalog, file, line, count.
@@ -6923,13 +6983,12 @@ Rules:
 - Use a short area prefix when it clarifies: "Pool:", "Providers:", "Config:", "Docs:", "Tests:", "Fix:", "Feature:".
 - Name the capability, behavior, feature, bug, or decision. Do not name files, paths, functions, commands, environment variables, API keys, raw model IDs, test file names, or build artifacts. Provider and product names are allowed when they identify the task.
 - Do not include counts of slots, providers, tests, lines, or files.
-- Omit internal housekeeping: builds, dist rebuilds, test-file additions, formatting, and dependency churn. If the slice only contains housekeeping, output nothing.
 - Describe what was DONE or DECIDED. Never write "User asked...", "Assistant said...", "Discussed...", "Reviewed...", "Explained...", or "Considered...".
 - Merge related changes into one stage; do not repeat the same task in different words.
 - No markdown: no bold, italics, backticks, or code blocks.
 - If a technical detail is the essence of the task, name it at the capability level: "Added Cloudflare Workers AI as a provider", not its account-id variables.
-- If the slice contains no substantive work or decision, output nothing.
-- Output only the entries. No headings, no preamble, no closing sentence.
+- If the slice contains no project work, output exactly NO_PROJECT_CHANGES and nothing else. Otherwise output only the bullets.
+- Output only the entries or NO_PROJECT_CHANGES. No headings, no preamble, no closing sentence.
 
 Example output:
 - Pool: added bucket-based routing for model groups.
@@ -6957,7 +7016,7 @@ This:
 - Pool: moved shared-window models to the end.
 - Providers: replaced the retired Gemini 2.5 Flash with Gemini 3.5 Flash.
 
-Your entire response must consist only of lines beginning with "- ".`;
+Your entire response must consist only of lines beginning with "- ", or exactly NO_PROJECT_CHANGES.`;
 function errorText(value) {
   if (value instanceof Error) return value.message;
   if (typeof value === "string") return value;
@@ -6972,6 +7031,85 @@ function errorText(value) {
   }
   return String(value);
 }
+var MAX_TASK_CHILDREN_EXPANDED = 40;
+async function expandTaskSessions(client, messages, directory, owned, onError, cursor) {
+  const projectOwnsTooling = existsSync5(join12(directory, "src/plugins/timeline.ts"));
+  let attempts = 0;
+  const expandedMessages = [];
+  let startIndex = 0;
+  if (cursor) {
+    const cursorIndex = messages.findIndex((m) => m.info.id === cursor);
+    if (cursorIndex >= 0) startIndex = cursorIndex + 1;
+  }
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = messages[messageIndex];
+    if (messageIndex < startIndex) {
+      expandedMessages.push(message);
+      continue;
+    }
+    const parts = message.parts ?? [];
+    let changed = false;
+    const nextParts = [];
+    for (const part of parts) {
+      if (message.info.role === "assistant" && part.type === "text" && !projectOwnsTooling && mentionsSideMaintenance(part.text ?? "")) {
+        nextParts.push({ ...part, side: true });
+        changed = true;
+        continue;
+      }
+      if (part.type !== "tool" || part.tool !== "task" || attempts >= MAX_TASK_CHILDREN_EXPANDED) {
+        nextParts.push(part);
+        continue;
+      }
+      if (isSideMaintenanceTask(part.state?.input, directory, projectOwnsTooling)) {
+        nextParts.push({ ...part, side: true });
+        continue;
+      }
+      if (isSideTool("task", part.state?.input)) {
+        nextParts.push({ ...part, side: true });
+        continue;
+      }
+      if (typeof part.childTitle === "string" && part.childTitle.trim() !== "") {
+        nextParts.push(part);
+        continue;
+      }
+      const childId = taskChildSessionId(part);
+      if (!childId || owned.has(childId)) {
+        nextParts.push(part);
+        continue;
+      }
+      attempts++;
+      try {
+        const fetched = await client.session.get({ path: { id: childId }, query: { directory } });
+        const info = fetched?.data;
+        const rawTitle = typeof info?.title === "string" ? info.title.trim() : "";
+        if (!rawTitle || isInternalTitle(info?.title)) {
+          nextParts.push(part);
+          continue;
+        }
+        const childRes = await client.session.messages({ path: { id: childId }, query: { directory } });
+        const childMessages = childRes?.data ?? [];
+        let childOutcome;
+        for (let i = childMessages.length - 1; i >= 0; i--) {
+          const childMessage = childMessages[i];
+          if (childMessage?.info?.role !== "assistant") continue;
+          const textParts = (childMessage.parts ?? []).filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text ?? "");
+          const joined = textParts.join("\n").replace(/\s+/g, " ").trim();
+          if (!joined) continue;
+          childOutcome = joined.length > 800 ? joined.slice(0, 800) : joined;
+          break;
+        }
+        const cloned = childOutcome ? { ...part, childTitle: rawTitle, childOutcome } : { ...part, childTitle: rawTitle };
+        nextParts.push(cloned);
+        changed = true;
+      } catch (error) {
+        if (onError) onError("expand-task-session failed", { childId, error });
+        nextParts.push(part);
+      }
+    }
+    expandedMessages.push(changed ? { ...message, parts: nextParts } : message);
+  }
+  return expandedMessages;
+}
 function timelineHooks(input, options) {
   const { client, directory } = input;
   const opts = options ?? {};
@@ -7179,13 +7317,17 @@ function timelineHooks(input, options) {
       const textParts = parts.filter((part) => part.type === "text").map((part) => part.text ?? "").join("\n").trim();
       const reasoningParts = parts.filter((part) => part.type === "reasoning").map((part) => part.text ?? "").join("\n").trim();
       const text = textParts || reasoningParts;
+      const trimmed = text.trim();
+      if (trimmed === "NO_PROJECT_CHANGES") {
+        return { ok: true, bullets: [] };
+      }
+      if (trimmed === "") {
+        return { ok: false, bullets: [], error: "empty summarizer output" };
+      }
       const bullets = parseBullets(text, maxEntries);
       if (bullets.length > 0) {
         return { ok: true, bullets };
       }
-      if (text.trim() === "") {
-        return { ok: true, bullets: [] };
-      }
       const salvaged = salvageBullets(text, maxEntries);
       if (salvaged.length > 0) {
         log("warn", "timeline: salvaged non-bulleted output", { sessionID: id, text: text.slice(0, 300) });
@@ -7228,7 +7370,8 @@ function timelineHooks(input, options) {
       }
       const response = await client.session.messages({ path: { id }, query: { directory } });
       const messages = response?.data ?? [];
-      const excerpt = buildExcerpt(messages, state2.cursor);
+      const expanded = await expandTaskSessions(client, messages, directory, owned, debug, state2.cursor?.messageID);
+      const excerpt = buildExcerpt(expanded, state2.cursor);
       if (!excerpt.text) {
         state2.pending = false;
         state2.failures = 0;
@@ -7286,7 +7429,7 @@ function timelineHooks(input, options) {
       const info = infoRes?.data;
       if (!info) return "Session not found.";
       const msgRes = await client.session.messages({ path: { id: rootId }, query: { directory } });
-      const messages = msgRes?.data ?? [];
+      let messages = msgRes?.data ?? [];
       writeFileSync10(temp, "");
       for (let i = 0; i < MAX_REPROCESS_SLICES; i++) {
         if (abort?.aborted) {
@@ -7296,6 +7439,7 @@ function timelineHooks(input, options) {
           }
           return `Aborted after ${calls} summarizer calls; previous timeline kept.`;
         }
+        messages = await expandTaskSessions(client, messages, directory, owned, debug, cursor?.messageID);
         const excerpt = buildExcerpt(messages, cursor);
         if (!excerpt.text) break;
         const prior = readEntriesAt(temp, 4);
@@ -7449,6 +7593,96 @@ function timelineHooks(input, options) {
   };
 }
 
+// src/lib/timer-migration.ts
+import { execFile } from "node:child_process";
+import { existsSync as existsSync6, mkdirSync as mkdirSync9, readFileSync as readFileSync10, renameSync as renameSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname6, join as join13 } from "node:path";
+var TIMER_MIGRATION_ENV = "LACODE_NO_TIMER_MIGRATION";
+var TIMER_MIGRATION_STATE_VERSION = 1;
+var defaultRun2 = (file, args, options) => new Promise((resolve5, reject) => {
+  execFile(file, args, { stdio: options?.stdio ?? "ignore" }, (error) => {
+    if (error) reject(error);
+    else resolve5();
+  });
+});
+function timerMigrationStatePath(home = homedir8()) {
+  return join13(home, ".local", "share", "opencode", "lacode", "migrations.json");
+}
+function timerMigrationUnitPath(home = homedir8()) {
+  return join13(home, ".config", "systemd", "user", "lacode-refresh-pool.timer");
+}
+function readState2(path4) {
+  try {
+    return JSON.parse(readFileSync10(path4, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeState2(path4, state2) {
+  mkdirSync9(dirname6(path4), { recursive: true });
+  const tmp = `${path4}.${process.pid}.tmp`;
+  writeFileSync11(tmp, JSON.stringify(state2) + "\n");
+  renameSync8(tmp, path4);
+}
+async function runTimerMigration(options = {}) {
+  const env = options.env ?? process.env;
+  if (env[TIMER_MIGRATION_ENV] === "1" || env.NODE_TEST_CONTEXT !== void 0) return { action: "disabled" };
+  const platform = options.platform ?? process.platform;
+  if (platform !== "linux") return { action: "skipped", reason: "not-linux" };
+  const packageRoot = options.packageRoot ?? PACKAGE_ROOT;
+  const version = options.version ?? readInstalledVersion(packageRoot);
+  if (!version) return { action: "skipped", reason: "no-version" };
+  const home = options.home ?? homedir8();
+  const statePath = options.statePath ?? timerMigrationStatePath(home);
+  const state2 = readState2(statePath);
+  if (state2.timersVersion === version && existsSync6(timerMigrationUnitPath(home))) {
+    return { action: "up-to-date", version };
+  }
+  const run = options.run ?? defaultRun2;
+  try {
+    await run("systemctl", ["--user", "show-environment"], { stdio: "ignore" });
+  } catch {
+    return { action: "skipped", reason: "no-systemd" };
+  }
+  const script = join13(packageRoot, "scripts", "refresh-pool.mjs");
+  if (!existsSync6(script)) return { action: "failed", version, error: `timer script not found: ${script}` };
+  try {
+    await run(process.execPath, [script, "--install-timer", "--stable"], { stdio: "ignore" });
+  } catch (error) {
+    return { action: "failed", version, error: String(error?.message ?? error) };
+  }
+  try {
+    writeState2(statePath, {
+      version: TIMER_MIGRATION_STATE_VERSION,
+      timersVersion: version,
+      installedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    options.log?.("warn", `timer migration state not written: ${String(error?.message ?? error)}`);
+  }
+  return { action: "installed", version };
+}
+
+// src/plugins/timer-migration.ts
+function timerMigrationHooks(input, options) {
+  if (options?.enabled === false) return {};
+  const log = (level, message, extra) => {
+    void input.client.app.log({ body: { service: "lacode", level, message, extra } }).catch(() => {
+    });
+  };
+  void runTimerMigration({
+    packageRoot: PACKAGE_ROOT,
+    version: readInstalledVersion(PACKAGE_ROOT),
+    log
+  }).then((result) => {
+    if (result.action === "installed") log("info", `timer migration installed for ${result.version}`);
+    else if (result.action === "failed") log("warn", `timer migration failed: ${result.error}`);
+    else log("debug", `timer migration: ${result.action}`);
+  }).catch((error) => log("error", `timer migration threw: ${String(error)}`));
+  return {};
+}
+
 // src/index.ts
 var inertHooks = {
   config: async () => {
@@ -7489,6 +7723,7 @@ var LaCode = (async (input, options) => {
   const autoupdate = await settled("context-autoupdate", () => contextAutoUpdateHooks(input, options)) ?? inertHooks;
   const notifier = await settled("notify", () => notifyHooks(input, options)) ?? inertHooks;
   const selfupdate = await settled("self-update", () => selfUpdateHooks(input, options)) ?? inertHooks;
+  void timerMigrationHooks(input, options);
   const feedback = await settled("feedback", () => feedbackHooks(input, options)) ?? inertHooks;
   const omniroute = await settled("omniroute", () => omniRouteHooks(input, options)) ?? inertHooks;
   const compat = await settled("provider-compat", () => providerCompatHooks(input)) ?? inertHooks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawaty/lacode",
-  "version": "2.0.0-beta.0",
+  "version": "2.1.0-beta.0",
   "description": "Ultimate opencode setup for Go users — cost-controlled pooled subagents, hang recovery, and notifications for opencode.",
   "license": "MIT",
   "type": "module",

package/scripts/refresh-pool.mjs

@@ -6,20 +6,19 @@
 // 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 other provider, sorted by score
+//      descending, weight 2; opencode models get 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 +26,8 @@ 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 REFRESH_SERVICE_NAME = "lacode-refresh-pool.service"
 export const REFRESH_TIMER_NAME = "lacode-refresh-pool.timer"
 
@@ -42,17 +43,12 @@ const providerOf = (modelOrLine) => {
   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))
-}
+// 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/)
@@ -70,7 +66,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), then the best others (weight 2).`
 }
 
 function withRefreshComment(headerLines, comment) {
@@ -88,7 +84,7 @@ 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: { opencodeGo: string[], others: string[] } }}
  */
 export function buildPool(input) {
   const warnings = []
@@ -97,33 +93,34 @@ export function buildPool(input) {
     throw new Error("score file is missing or invalid (expected { providers: [...] })")
   }
 
-  const providerEntries = scores.providers
-  const scoredProviders = new Set(
-    providerEntries.map((p) => String(p?.provider ?? "").trim()).filter(Boolean),
-  )
-
-  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")
+  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")
   }
-
-  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")
+  if (goRows.length + otherRows.length < POOL_SIZE) {
+    warnings.push(`only ${goRows.length + otherRows.length} scorable model(s) available, wanted ${POOL_SIZE}`)
   }
-  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 { 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 comment = refreshComment(input?.now ?? new Date(), scores.generatedAt)
   const outHeader = withRefreshComment(header, comment)
@@ -135,8 +132,7 @@ export function buildPool(input) {
     warnings,
     chosen: {
       opencodeGo: goRows.map((r) => r.model),
-      opencode: bestOp,
-      preserved: preserved.map((l) => String(l).split("#")[0].trim().split(/\s+/)[0]),
+      others: otherRows.map((r) => r.model),
     },
   }
 }
@@ -163,6 +159,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")
@@ -192,8 +194,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 +204,23 @@ 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)
+    }
+    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 +232,7 @@ function installTimerUnits() {
     process.exitCode = 1
     return false
   }
+  if (stable) console.log(`copied ${live} to ${scriptPath}`)
   console.log(`installed ${units.servicePath}`)
   console.log(`installed ${units.timerPath}`)
   console.log(`enabled ${REFRESH_TIMER_NAME}`)
@@ -237,6 +244,8 @@ function usage() {
 
   --from-scores     skip scoring, use the existing ~/.config/lacode/model-scores.json
   --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)
@@ -248,10 +257,10 @@ 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 value = (flag, fallback) => {
@@ -294,10 +303,12 @@ 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}]`,
+    `others [${built.chosen.others.join(", ")}]`,
+    ...(dropped.length ? [`dropped [${dropped.map((x) => x.model).join(", ")}]`] : []),
+    ...(built.warnings.length ? [`warnings [${built.warnings.join("; ")}]`] : []),
   ].join(" | ")
 
   if (printOnly) {

package/scripts/score-models.mjs

@@ -12,7 +12,8 @@
 //   npm run score -- --no-write         print only, touch nothing
 //
 // WHAT IT MEASURES
-//   context      limit.context from `opencode models --verbose`
+//   context      limit.context from `opencode models --verbose`; a known limit
+//                below --min-context is excluded from ranking, not scored low
 //   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
@@ -21,6 +22,8 @@
 // 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 ranks a model whose known context is below --min-context, or whose
+//     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
@@ -38,7 +41,8 @@ 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"]
+// 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"])
 
 // ── scoring weights ─────────────────────────────────────────────────────────
@@ -46,6 +50,8 @@ const SESSION_PROVIDERS = new Set(["opencode", "opencode-go"])
 // 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"
@@ -63,8 +69,10 @@ const value = (flag, fallback) => {
   if (has("--help") || has("-h")) {
     console.log(`Usage: npm run score -- [options]
 
-  --providers a,b   providers to scan (default: ${DEFAULT_PROVIDERS.join(",")})
+  --providers a,b   restrict the scan to these providers (default: all configured)
   --max N           probe at most N free models per provider (default: 12)
+  --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)
   --delay MS        pause between requests in ms (default: 300)
   --no-write        do not write ~/.config/lacode/model-scores.json
@@ -79,8 +87,11 @@ opencode/opencode-go models are probed through a temporary local opencode serve
     process.exit(0)
   }
 
-const providers = String(value("--providers", DEFAULT_PROVIDERS.join(","))).split(",").map((s) => s.trim()).filter(Boolean)
+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 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 delayMs = Math.max(0, Number(value("--delay", "300")) || 300)
 const writeResults = !has("--no-write")
@@ -136,18 +147,7 @@ function isChatModel(model) {
   return true
 }
 
-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)
+function buildProviderEntry(provider, rows) {
   const models = rows
     .filter(({ model }) => model?.api?.url && model?.api?.id)
     .filter(({ model }) => (model.cost?.input ?? 1) === 0 && (model.cost?.output ?? 1) === 0)
@@ -161,7 +161,57 @@ function freeModels(provider) {
       output: model.limit?.output ?? null,
       name: model.name ?? id,
     }))
-  return { provider, error: null, models }
+  const excluded = models
+    .filter((m) => m.context != null && m.context < minContext)
+    .map((m) => ({
+      model: m.model,
+      context: m.context,
+      output: m.output,
+      reason: `context ${m.context} < minimum ${minContext}`,
+    }))
+  return {
+    provider,
+    error: null,
+    models: models.filter((m) => m.context == null || m.context >= minContext),
+    excluded,
+  }
+}
+
+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: [], excluded: [] }
+  }
+  return buildProviderEntry(provider, parseVerbose(text))
+}
+
+function freeModelsAll() {
+  let text
+  try {
+    text = execFileSync("opencode", ["models", "--verbose"], {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+  } catch (error) {
+    return [{ provider: "all", error: `opencode models failed: ${String(error?.message ?? error)}`, models: [], excluded: [] }]
+  }
+  const groups = new Map()
+  for (const row of parseVerbose(text)) {
+    const provider = String(row.model?.providerID ?? row.id.split("/")[0] ?? "")
+    if (!provider) continue
+    if (!groups.has(provider)) groups.set(provider, [])
+    groups.get(provider).push(row)
+  }
+  return [...groups.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([provider, rows]) => buildProviderEntry(provider, rows))
 }
 
 // ── credentials ─────────────────────────────────────────────────────────────
@@ -436,19 +486,24 @@ 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 scanned = providers ? providers.map((provider) => freeModels(provider)) : freeModelsAll()
   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: [] })
+      results.push({ provider: entry.provider, error: entry.error, rows: [], excluded: [] })
       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}` : ""}`)
+    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}`)
+    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)}`)
+    }
     if (candidates.length === 0) {
-      results.push({ provider: entry.provider, error: null, rows: [] })
+      results.push({ provider: entry.provider, error: null, rows: [], excluded: entry.excluded })
       continue
     }
     const rows = []
@@ -456,12 +511,21 @@ async function main() {
       const 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) {
+        entry.excluded.push({
+          model: row.model,
+          context: row.context,
+          output: row.output,
+          score: row.score.value,
+          reason: `score ${row.score.value} < minimum ${minScore}`,
+        })
+      }
       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 })
+    results.push({ provider: entry.provider, error: null, rows, excluded: entry.excluded })
   }
   stopSessionServer()
 
@@ -470,7 +534,7 @@ async function main() {
     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)
+    const ranked = [...entry.rows].filter((r) => r.score && r.score.value >= minScore).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)}`)
     })
@@ -481,8 +545,15 @@ async function main() {
     }
   }
 
+  // Models dropped for a too-small context or a too-low score are reported, never ranked.
+  const excluded = results.flatMap((e) => e.excluded ?? [])
+  if (excluded.length) {
+    console.log(`\nexcluded — below the context or score floor (not ranked)`)
+    for (const x of excluded) console.log(`  ${pad(x.model, 58)}${padL(x.context ?? "?", 9)}  ${x.reason}`)
+  }
+
   // Overall ranking across providers.
-  const all = results.flatMap((e) => e.rows).filter((r) => r.score)
+  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`)
@@ -491,21 +562,21 @@ async function main() {
     })
   }
 
-  // A SUGGESTED pool: the best model from each provider, weights 4/3/2/1 by rank.
+  // 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 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) {
+  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) {
     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}`)
-    })
+    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}`)
   }
 
   if (writeResults) {
@@ -514,9 +585,12 @@ async function main() {
       const payload = {
         generatedAt: new Date().toISOString(),
         weights: W,
+        minContext,
+        minScore,
         providers: results.map((e) => ({
           provider: e.provider,
           error: e.error,
+          excluded: e.excluded ?? [],
           rows: e.rows.map((r) => ({
             model: r.model,
             context: r.context,