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

package/CHANGELOG.md

@@ -9,6 +9,39 @@ 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
+
+- 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 +1165,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

@@ -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) {
@@ -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`);
@@ -6489,7 +6540,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 +6813,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 +6869,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 +7016,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 +7034,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 +7067,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 +7082,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 +7368,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 +7421,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 +7480,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 +7490,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 +7644,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 +7774,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/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) {