@lawaty/lacode 1.1.0 → 1.2.0

package/dist/index.js

@@ -35,9 +35,9 @@ var HANG_COOLDOWN_MS = 10 * 60 * 1e3;
 var UNAVAILABLE_COOLDOWN_MS = 60 * 1e3;
 var UNAVAILABLE_REASON = "endpoint-unavailable";
 var MAX_WEIGHT = 100;
-var SLOT_CEILING_FACTOR = 2;
-var slotCeiling = (slot) => slot.weight * SLOT_CEILING_FACTOR;
-var MAX_SLOTS = 4;
+var slotCeiling = (slot) => slot.weight;
+var slotBucket = (slot) => slot.bucket ?? slot.model;
+var SLOTS_WARN_AT = 64;
 var COOLDOWN_BASE_MS = 60 * 1e3;
 var COOLDOWN_MAX_MS = 15 * 60 * 1e3;
 var QUOTA_COOLDOWN_BASE_MS = 15 * 60 * 1e3;
@@ -47,8 +47,12 @@ var STATED_COOLDOWN_MAX_MS = QUOTA_COOLDOWN_MAX_MS;
 var isQuotaReason = (reason) => /quota|limit|rate|too-many|overloaded|429/i.test(reason);
 var MODEL_MISSING_REASON = "model-missing";
 var MODEL_MISSING_COOLDOWN_MS = QUOTA_COOLDOWN_MAX_MS;
+var AUTH_FAILURE_REASON = "auth-failed";
+var AUTH_FAILURE_COOLDOWN_MS = QUOTA_COOLDOWN_MAX_MS;
 var MODEL_MISSING_PATTERN = /model\s+(?:not\s+found|does\s+not\s+exist|is\s+not\s+available)|(?:unknown|no\s+such)\s+model/i;
 var isModelMissingText = (text) => MODEL_MISSING_PATTERN.test(text);
+var AUTH_FAILURE_PATTERN = /\b401\b|\b403\b|unauthori[sz]ed|not\s+authori[sz]ed|invalid[\s_-]+(?:api[\s_-]?(?:key|token)|token|credential|bearer)|api[\s_-]?key\s+(?:is\s+)?(?:invalid|missing|expired|not\s+valid)|authentication\s+(?:failed|error|required)|incorrect[\s_-]+api[\s_-]?key/i;
+var isAuthFailureText = (text) => AUTH_FAILURE_PATTERN.test(text);
 var BASES = ["explore", "implement", "context"];
 var PRESETS_DIR = join2(PACKAGE_ROOT, "presets");
 var DEFAULT_PRESET = join2(PRESETS_DIR, "free-tier.json");
@@ -71,15 +75,18 @@ function parseSlots(parsed, origin) {
   entries.forEach((entry, i) => {
     const model = typeof entry?.model === "string" ? entry.model.trim() : "";
     const at = `slot ${i + 1}`;
-    if (slots.length >= MAX_SLOTS) {
-      problems.push(`${at} (${model || "?"}): the pool is capped at ${MAX_SLOTS} slots (one variant agent per base per slot is declared); entry ignored`);
-      return;
-    }
     if (!model.includes("/")) return problems.push(`${at}: model must be written provider/model-id, got "${model}"`);
     const weight = readWeight(entry, at, model, problems);
-    if (slots.some((s) => s.model === model)) return problems.push(`${at}: ${model} is already used by another slot; slots must be distinct models`);
-    slots.push({ index: slots.length + 1, model, weight });
+    const rawBucket = entry?.bucket;
+    const bucket = typeof rawBucket === "string" ? rawBucket.trim() : void 0;
+    if (rawBucket !== void 0 && !bucket) {
+      problems.push(`${at} (${model}): bucket must be a non-empty name; using the model id`);
+    }
+    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {} });
   });
+  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)`);
+  }
   if (slots.length === 0) {
     problems.push(`${origin} yielded no usable slot; using built-in defaults`);
     return { slots: FALLBACK_SLOTS, problems };
@@ -91,8 +98,17 @@ function parseTextSlots(text, origin) {
   for (const raw of text.split(/\r?\n/)) {
     const line = raw.split("#")[0].trim();
     if (!line) continue;
-    const [model, weight] = line.split(/\s+/);
-    entries.push(weight === void 0 ? { model } : { model, weight });
+    const [model, ...rest] = line.split(/\s+/);
+    let weight;
+    let bucket;
+    for (const token of rest) {
+      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 } });
   }
   return parseSlots({ slots: entries }, origin);
 }
@@ -236,9 +252,17 @@ var retryAfterMs = (headers) => {
   for (const [key, value] of Object.entries(headers)) {
     if (key.toLowerCase() !== "retry-after") continue;
     const seconds = Number(value);
-    if (Number.isFinite(seconds) && seconds > 0) return Math.min(seconds * 1e3, COOLDOWN_MAX_MS);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      const ms = seconds * 1e3;
+      if (ms > STATED_COOLDOWN_MAX_MS) return void 0;
+      return ms;
+    }
     const when = Date.parse(value);
-    if (Number.isFinite(when)) return Math.min(Math.max(when - Date.now(), 1e3), COOLDOWN_MAX_MS);
+    if (Number.isFinite(when)) {
+      const delay = when - Date.now();
+      if (delay > STATED_COOLDOWN_MAX_MS) return void 0;
+      return Math.max(delay, 1e3);
+    }
   }
   return void 0;
 };
@@ -288,7 +312,7 @@ function ensureSlots(s, onWarn) {
   for (const problem of problems) onWarn(problem);
   return slots;
 }
-var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}`).join("|")}`;
+var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.bucket ?? ""}`).join("|")}`;
 function reloadSlots(s, onWarn) {
   const { slots, problems, origin } = resolveModels({ models: s.inlineModels, modelsFile: s.modelsFile });
   const changed = slotSignature(origin, slots) !== slotSignature(s.origin, s.slots);
@@ -466,7 +490,7 @@ function readSiblings(s) {
     try {
       const parsed = JSON.parse(readFileSync2(path5, "utf8"));
       const claims = Object.values(parsed).filter(
-        (c) => c && typeof c.v === "string" && typeof c.m === "string" && now - (c.hb ?? c.t) <= CLAIM_TTL_MS
+        (c) => c && typeof c.v === "string" && typeof c.m === "string" && typeof c.k === "number" && Number.isFinite(c.k) && now - (c.hb ?? c.t) <= CLAIM_TTL_MS
       );
       siblings.push({ id: match[1], claims });
     } catch {
@@ -516,20 +540,32 @@ function recordStrike(s, model, reason, stated) {
   if (!s.dirReady) return;
   if (reason === UNAVAILABLE_REASON) return coolUnavailable(s, model);
   const now = Date.now();
-  const prior = s.strikes.get(model);
+  const slotsForModel = s.slots.filter((candidate) => candidate.model === model);
+  const buckets = [...new Set(slotsForModel.map((slot) => slotBucket(slot)))];
+  const targets = buckets.length === 0 ? [model] : [...new Set(
+    s.slots.filter((candidate) => buckets.includes(slotBucket(candidate))).map((candidate) => candidate.model)
+  )];
+  if (targets.length === 0) targets.push(model);
+  const prior = targets.map((target) => s.strikes.get(target)).filter((candidate) => Boolean(candidate)).reduce((worst, candidate) => !worst || candidate.strikes > worst.strikes ? candidate : worst, void 0);
   const strikes = prior && now - prior.last < STRIKE_DECAY_MS ? prior.strikes + 1 : 1;
   const quota = isQuotaReason(reason);
   const base = quota ? QUOTA_COOLDOWN_BASE_MS : COOLDOWN_BASE_MS;
   const cap = quota ? QUOTA_COOLDOWN_MAX_MS : COOLDOWN_MAX_MS;
   const backoff = Math.min(cap, base * 2 ** (strikes - 1));
-  const strike = { model, until: now + (stated ?? backoff), strikes, reason, last: now };
-  s.cooling.set(model, strike);
-  s.strikes.set(model, strike);
-  const path5 = join2(s.dir, limitFile(model));
-  try {
-    writeFileSync(`${path5}.tmp`, JSON.stringify(strike));
-    renameSync(`${path5}.tmp`, path5);
-  } catch {
+  const statedOk = typeof stated === "number" && Number.isFinite(stated) && stated > 0 && stated <= STATED_COOLDOWN_MAX_MS;
+  const until = now + (statedOk ? stated : backoff);
+  let strike;
+  for (const target of targets) {
+    const record = { model: target, until, strikes, reason, last: now };
+    s.cooling.set(target, record);
+    s.strikes.set(target, record);
+    const path5 = join2(s.dir, limitFile(target));
+    try {
+      writeFileSync(`${path5}.tmp`, JSON.stringify(record));
+      renameSync(`${path5}.tmp`, path5);
+    } catch {
+    }
+    if (target === model) strike = record;
   }
   return strike;
 }
@@ -619,30 +655,26 @@ function snapshot(s) {
   const siblings = readSiblings(s);
   const cooling = readLimits(s);
   const counts = /* @__PURE__ */ new Map();
-  const bump = (m) => counts.set(m, (counts.get(m) ?? 0) + 1);
-  for (const claim of s.own.values()) bump(claim.m);
-  for (const sibling of siblings) for (const claim of sibling.claims) bump(claim.m);
+  const bump = (k) => counts.set(k, (counts.get(k) ?? 0) + 1);
+  for (const claim of s.own.values()) bump(claim.k);
+  for (const sibling of siblings) for (const claim of sibling.claims) bump(claim.k);
   return { counts, cooling, siblings, own: s.own, dirReady: s.dirReady };
 }
-var loadOf = (counts, model) => counts.get(model) ?? 0;
-var underCeiling = (slot, counts) => loadOf(counts, slot.model) < slotCeiling(slot);
+var loadOf = (counts, slot) => counts.get(slot) ?? 0;
+var underCeiling = (slot, counts) => loadOf(counts, slot.index) < slotCeiling(slot);
 function pickSlot(s, snap) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
   const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
   const pool = usable.length > 0 ? usable : slots;
   for (const slot of usable) {
-    if (loadOf(snap.counts, slot.model) < slot.weight) return slot;
-  }
-  for (const slot of usable) {
-    if (loadOf(snap.counts, slot.model) < slotCeiling(slot)) return slot;
+    if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
   }
-  return pool.reduce((best, slot) => loadOf(snap.counts, slot.model) < loadOf(snap.counts, best.model) ? slot : best, pool[0]);
+  return pool.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, pool[0]);
 }
 function poolPass(s, snap) {
   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.model) < slot.weight)) return 1;
-  if (usable.some((slot) => loadOf(snap.counts, slot.model) < slotCeiling(slot))) return 2;
+  if (usable.some((slot) => loadOf(snap.counts, slot.index) < slot.weight)) return 1;
   return "overflow";
 }
 function agentFor(base, slot) {
@@ -1677,12 +1709,12 @@ Report briefly what you changed and where. Do not edit any other file.`,
     }
   }
 };
-function buildAgentSet() {
+function buildAgentSet(slotCount = FALLBACK_SLOTS.length) {
   const set = { ...AGENTS };
   for (const base of POOLED_BASES) {
     const def = AGENTS[base];
     if (!def) continue;
-    for (let slot = 1; slot <= MAX_SLOTS; slot++) {
+    for (let slot = 1; slot <= Math.max(1, slotCount); slot++) {
       const variant = {
         ...def,
         description: `Hidden pool slot ${slot} for ${base}. Its model is NOT set here -- LaCode injects it from the resolved pool preset at config time, so the preset is the only place a pool model is written down. Spawn '${base}' and let the pool route.`,
@@ -1839,7 +1871,7 @@ Follow the rules for the file in your system prompt, then report what you change
 Print one PASS/FAIL line per check below, with the exact fix for any FAIL.
 
 1. Pool status \u2014 call the \`pool_status\` tool. Report the slot list, each
-   slot's load against its ceiling (twice the slot's weight), and which models
+   slot's load against its budget (its weight), and which models
    are cooling.
 
 2. OmniRoute configured \u2014 inspect the \`@lawaty/lacode\` plugin options in the
@@ -1876,10 +1908,10 @@ The pool is ONE global slot table shared by every pooled base (explore, implemen
 
 2. Resolve the instruction above into a target slot table. These are the rules the loader enforces \u2014 never write a file that breaks one:
    - one slot per line: \`<provider>/<model-id>  [weight]\`
-   - at most ${MAX_SLOTS} slots, and a model may appear only once
-   - weight is optional (default 1) and must be a number in (0, ${MAX_WEIGHT}]. It is the slot's active-session budget for one pass \u2014 how many turns it takes per cycle \u2014 and its concurrency ceiling is twice that. NOT a priority; pick order follows line order.
+   - any number of slots; a model may appear on more than one line, and each line is its own slot with its own budget
+   - weight is optional (default 1) and must be a number in (0, ${MAX_WEIGHT}]. It is the slot's active-session budget \u2014 how many concurrent sessions it may hold. The pool's total capacity is the sum of the weights. NOT a priority; pick order follows line order.
    - \`#\` starts a comment (whole-line or trailing); blank lines are ignored.
-   If the instruction names a model ambiguously, or would need more than ${MAX_SLOTS} slots, stop and ask rather than guessing.
+   If the instruction names a model ambiguously, stop and ask rather than guessing.
 
 3. Write the WHOLE file, not a patch. This file is an override, not an edit target: any slot you drop disappears, and slot numbers are line positions, so a partial write silently renumbers slots. Keep the existing comment header. If the write fails on a missing directory, create \`~/.config/lacode\` first and retry.
 
@@ -1905,6 +1937,11 @@ $ARGUMENTS
 
 Report the tool's output as it came back, then add one short line naming what changed: re-admitted, still limited, or benched because the provider does not serve the model. If a model was benched as \`model-missing\`, say so and name the replacement in \`~/.config/lacode/pool.txt\` \u2014 but change nothing yourself.`
   },
+  "reprocess-timeline": {
+    description: "Rebuild this session's timeline from its full transcript",
+    agent: "implement",
+    template: "Call the `timeline_reprocess` tool exactly once with no arguments. Then reply with only its output."
+  },
   "image-in-cb": {
     description: "Attach the clipboard image to this message \u2014 macOS needs pngpaste, Linux needs wl-paste or xclip.",
     template: "$ARGUMENTS"
@@ -2198,6 +2235,7 @@ import { tool } from "@opencode-ai/plugin";
 var PROBE_SYSTEM = "You are a connection health check. Reply with the single word: ok";
 var PROBE_PROMPT = "ok";
 var PROBE_TIMEOUT_MS = 45e3;
+var REASON_UNRESPONSIVE = "no answer";
 var failureText = (error) => {
   if (error === void 0 || error === null) return "";
   if (typeof error === "string") return error;
@@ -2210,32 +2248,35 @@ var failureText = (error) => {
 var shortReason = (text) => {
   if (!text) return "failed";
   if (isModelMissingText(text)) return MODEL_MISSING_REASON;
+  if (isAuthFailureText(text)) return AUTH_FAILURE_REASON;
   return limitReason(text) ?? (isLimitText(text) ? "limit" : "failed");
 };
 var probeOne = async (client, opts, model, leftSeconds) => {
   const { state: s, directory } = opts;
   const { provider, id: modelID } = splitModel(model);
-  const settle = (ok, reason, left) => ({
+  const settle = (ok, reason, left, kind, strikes) => ({
     model,
     ok,
     reason,
     hadSeconds: leftSeconds,
-    leftSeconds: left
+    leftSeconds: left,
+    kind,
+    strikes
   });
   const created = await client.session.create({ body: { title: `pool probe (${model})` }, query: { directory } }).then((r) => r?.data?.id).catch(() => void 0);
-  if (!created) return settle(false, "no probe session", leftSeconds);
+  if (!created) return settle(false, "no probe session", leftSeconds, "cooling");
   markProbe(s, created);
   let timer;
   try {
     const timeoutMs = opts.timeoutMs ?? PROBE_TIMEOUT_MS;
     const clock = opts.now ?? Date.now;
     let timedOut = false;
-    const deadline = new Promise((resolve4) => {
+    const deadline = new Promise((resolve5) => {
       timer = setTimeout(() => {
         timedOut = true;
         void client.session.abort({ path: { id: created }, query: { directory } }).catch(() => {
         });
-        resolve4(void 0);
+        resolve5(void 0);
       }, timeoutMs);
     });
     const answer = client.session.prompt({
@@ -2254,20 +2295,37 @@ var probeOne = async (client, opts, model, leftSeconds) => {
     const failure = result?.error ?? result?.data?.info?.error;
     if (!timedOut && failure === void 0 && result?.data?.info !== void 0) {
       clearCooldowns(s, [model]);
-      return settle(true, "answered", 0);
+      return settle(true, "answered", 0, "answered");
     }
     const text = failureText(failure);
+    let kind = "cooling";
+    let strikes;
     if (isModelMissingText(text)) {
-      recordStrike(s, model, MODEL_MISSING_REASON, MODEL_MISSING_COOLDOWN_MS);
+      const recorded = recordStrike(s, model, MODEL_MISSING_REASON, MODEL_MISSING_COOLDOWN_MS);
+      strikes = recorded?.strikes;
+      kind = "benched";
+    } else if (isAuthFailureText(text)) {
+      const recorded = recordStrike(s, model, AUTH_FAILURE_REASON, AUTH_FAILURE_COOLDOWN_MS);
+      strikes = recorded?.strikes;
+      kind = "benched";
+    } else if (timedOut || text === "") {
+      const recorded = recordStrike(s, model, REASON_UNRESPONSIVE, 0);
+      strikes = recorded?.strikes;
+      kind = "benched";
     } else {
       const stated = statedCooldown(text);
-      if (stated !== void 0) recordStrike(s, model, shortReason(text), stated);
+      if (stated !== void 0) {
+        const recorded = recordStrike(s, model, shortReason(text), stated);
+        strikes = recorded?.strikes;
+      }
     }
     const still = readLimits(s).get(model);
     return settle(
       false,
       timedOut ? `no answer in ${Math.round(timeoutMs / 1e3)}s` : shortReason(text),
-      still && still.until > clock() ? Math.ceil((still.until - clock()) / 1e3) : 0
+      still && still.until > clock() ? Math.ceil((still.until - clock()) / 1e3) : 0,
+      kind,
+      strikes
     );
   } finally {
     if (timer) clearTimeout(timer);
@@ -2352,6 +2410,24 @@ var SLOT_WATCH_MS = 1e3;
 var SLOT_WATCH_DEBOUNCE_MS = 250;
 var ABORT_TIMEOUT_MS = 1e4;
 var formatWindow = (seconds) => seconds < 60 ? `${seconds}s` : `${Math.ceil(seconds / 60)}m`;
+var reportText = (report) => {
+  if (report.outcomes.length === 0) return "no models are cooling down, so there was nothing to probe.";
+  const answered = report.outcomes.filter((outcome) => outcome.ok).length;
+  const benched = report.outcomes.filter((outcome) => outcome.kind === "benched").length;
+  const cooling = report.outcomes.length - answered - benched;
+  return [
+    ...report.outcomes.map((outcome) => {
+      if (outcome.ok) return `${outcome.model}: answered, cooldown cleared`;
+      if (outcome.kind === "benched") {
+        const window = outcome.leftSeconds > 0 ? ` for ${Math.round(outcome.leftSeconds)}s` : "";
+        const strike = outcome.strikes !== void 0 ? ` (strike ${outcome.strikes})` : "";
+        return `${outcome.model}: ${outcome.reason} \u2014 benched${window}${strike}`;
+      }
+      return `${outcome.model}: still limited (${outcome.reason}) \u2014 cooldown kept${outcome.leftSeconds > 0 ? `, ${formatWindow(outcome.leftSeconds)} left` : ""}`;
+    }),
+    `summary: ${answered} answered, ${benched} benched, ${cooling} still cooling`
+  ].join("\n");
+};
 var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
   const opts = options ?? {};
   const s = state(opts);
@@ -2389,6 +2465,36 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
       return { ok: false, why: String(error) };
     }
   };
+  const abortReports = /* @__PURE__ */ new Map();
+  const abortKind = (reason) => isQuotaReason(reason) || isLimitText(reason) ? "rate-limit" : "provider error";
+  const abortLabel = (kind, elapsedMs) => {
+    const seconds = Math.max(1, Math.round(elapsedMs / 1e3));
+    if (kind === "no-answer") return `no answer in ${seconds}s`;
+    if (kind === "rate-limit") return `rate limited after ${seconds}s`;
+    if (kind === "empty response") return `empty response after ${seconds}s`;
+    if (kind === "permission") return `permission denied after ${seconds}s`;
+    return `provider error after ${seconds}s`;
+  };
+  const noteAbort = async (key, report) => {
+    abortReports.set(key, report);
+    if (abortReports.size > 32) {
+      const oldest = abortReports.keys().next().value;
+      if (oldest !== void 0) abortReports.delete(oldest);
+    }
+    await log("warn", report.message, {
+      slot: report.slot,
+      model: report.model,
+      elapsedMs: report.elapsedMs,
+      failure: report.kind,
+      released: report.released
+    });
+    try {
+      await client.tui?.showToast?.({
+        body: { title: "pool spawn", message: report.message, variant: "warning", duration: 8e3 }
+      });
+    } catch {
+    }
+  };
   const MAX_ABORT_ATTEMPTS = 3;
   const coolForHang = async (claim, log2) => {
     const now = Date.now();
@@ -2444,6 +2550,16 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
       const kill = await abortSession(sessionID);
       if (kill.ok) {
         release(s, key);
+        const elapsedMs = Date.now() - claim.t;
+        const kind = abortKind(reason);
+        await noteAbort(key, {
+          slot: claim.k,
+          model: claim.m,
+          elapsedMs,
+          kind,
+          released: true,
+          message: `slot ${claim.k} ${claim.m} \u2014 ${abortLabel(kind, elapsedMs)}; claim released`
+        });
         await log(
           "warn",
           `limit (${reason}) on ${model}; aborted in-flight ${claim.v} session ${sessionID} to fail over now`,
@@ -2512,6 +2628,15 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
               reason === "overran" ? `overran ${claim.v} on ${claim.m} after ${age}s; aborted session ${claim.g}` : `hung ${claim.v} on ${claim.m} after ${age}s with ${since}; aborted session ${claim.g}`,
               { base: claim.v, model: claim.m, slot: claim.k, session: claim.g, aborted: true }
             );
+            const elapsedMs = Date.now() - claim.t;
+            await noteAbort(key, {
+              slot: claim.k,
+              model: claim.m,
+              elapsedMs,
+              kind: "no-answer",
+              released: true,
+              message: `slot ${claim.k} ${claim.m} \u2014 ${reason === "overran" ? `overran after ${Math.max(1, Math.round(elapsedMs / 1e3))}s` : abortLabel("no-answer", elapsedMs)}; claim released`
+            });
             await coolForHang(claim, log);
             continue;
           }
@@ -2563,17 +2688,10 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     if (report.outcomes.length === 0) return "nothing cooling to probe";
     const parts = [`probed ${report.outcomes.length} model(s)`, `re-admitted ${report.cleared.length}`];
     if (report.missing.length > 0) parts.push(`benched ${report.missing.length} missing`);
+    const authBenched = report.outcomes.filter((outcome) => outcome.reason === AUTH_FAILURE_REASON).length;
+    if (authBenched > 0) parts.push(`benched ${authBenched} auth-failed`);
     return parts.join(", ");
   };
-  const reportText = (report) => {
-    if (report.outcomes.length === 0) return "no models are cooling down, so there was nothing to probe.";
-    return [
-      ...report.outcomes.map(
-        (outcome) => outcome.ok ? `${outcome.model}: answered \u2014 cooldown cleared (it had ${formatWindow(outcome.hadSeconds)} left), back in the pool` : outcome.reason === MODEL_MISSING_REASON ? `${outcome.model}: not served by the provider (${outcome.reason}) \u2014 benched${outcome.leftSeconds > 0 ? `, ${formatWindow(outcome.leftSeconds)} left` : ""}` : `${outcome.model}: still limited (${outcome.reason}) \u2014 cooldown kept${outcome.leftSeconds > 0 ? `, ${formatWindow(outcome.leftSeconds)} left` : ""}`
-      ),
-      report.cleared.length > 0 ? `re-admitted: ${report.cleared.join(", ")}. They route again on the next pooled spawn \u2014 nothing needs restarting or reloading.` : report.missing.length > 0 ? `benched: ${report.missing.join(", ")}. The provider does not serve them; replace them in the pool.` : report.outcomes.every((outcome) => outcome.ok) ? "every model that was asked answered; nothing needed re-admitting." : "nothing was re-admitted; the pool is short exactly as much as it was."
-    ].join("\n");
-  };
   const announce = async (report) => {
     if (!report.changed) return;
     const message = report.cleared.length > 0 ? `Re-admitted ${report.cleared.join(", ")} \u2014 they answer again.` : report.missing.length > 0 ? `Benched ${report.missing.join(", ")} \u2014 the provider does not serve them.` : `${report.kept.length} cooling model(s) re-checked, still limited.`;
@@ -2613,10 +2731,23 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     for (const slot of slots) {
       for (const base of BASES) {
         const name = agentFor(base, slot.index);
-        const def = agents?.[name];
+        let def = agents?.[name];
         if (!def) {
-          await warnOnce(`variant ${name} is missing from the config; spawns of ${base} that route to slot ${slot.index} would fail`);
-          continue;
+          const baseDef = agents?.[base];
+          if (!agents || !baseDef) {
+            await warnOnce(`variant ${name} is missing from the config; spawns of ${base} that route to slot ${slot.index} would fail`);
+            continue;
+          }
+          const created = {
+            ...baseDef,
+            description: `Hidden pool slot ${slot.index} for ${base}. Its model is set by the pool at config time. Spawn '${base}' and let the pool route.`,
+            hidden: true,
+            mode: "primary"
+          };
+          delete created.model;
+          agents[name] = created;
+          def = created;
+          await log("info", `declared variant ${name} for slot ${slot.index} (table grew after startup)`);
         }
         if (def.model && def.model !== slot.model) {
           await warnOnce(`${name} still hard-codes ${def.model}; the resolved pool preset wins (${slot.model}). Delete the line to keep one source of truth.`);
@@ -2698,7 +2829,8 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           const provider = typeof action?.provider === "string" ? action.provider : void 0;
           const reason2 = action?.reason ?? "";
           const message = typeof status2?.message === "string" ? status2.message : "";
-          const limited2 = reason2 === "free_tier_limit" || isLimitText(reason2) || isLimitText(message);
+          const auth2 = isAuthFailureText(reason2) || isAuthFailureText(message);
+          const limited2 = reason2 === "free_tier_limit" || isLimitText(reason2) || isLimitText(message) || auth2;
           if (status2?.type === "retry" && limited2) {
             if (sessionID && isProbe(s, sessionID)) {
               await log("debug", `probe on provider ${provider ?? "?"} was limited (${reason2 || "rate-limited"}); not cooling the provider`);
@@ -2706,9 +2838,9 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
             }
             const own = claimFor(sessionID);
             const outage = isUnavailableText(message) && !isQuotaReason(reason2);
-            const named = outage ? UNAVAILABLE_REASON : reason2 || limitReason(message) || "rate-limited";
+            const named = auth2 ? AUTH_FAILURE_REASON : outage ? UNAVAILABLE_REASON : reason2 || limitReason(message) || "rate-limited";
             if (provider) {
-              const until = outage ? Date.now() + UNAVAILABLE_COOLDOWN_MS : typeof status2.next === "number" && status2.next > Date.now() ? status2.next : Date.now() + HANG_FALLBACK_MS;
+              const until = auth2 ? Date.now() + AUTH_FAILURE_COOLDOWN_MS : outage ? Date.now() + UNAVAILABLE_COOLDOWN_MS : typeof status2.next === "number" && status2.next > Date.now() ? status2.next : Date.now() + HANG_FALLBACK_MS;
               const cooled = coolProvider(s, provider, until, named);
               if (cooled.length > 0) {
                 await log("warn", `limit on provider ${provider} (${named}); cooling ${cooled.length} slot(s) until ${new Date(until).toISOString().slice(11, 19)}Z`, {
@@ -2718,7 +2850,16 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
                 });
               }
             } else if (own) {
-              if (outage) {
+              if (auth2) {
+                const strike2 = recordStrike(s, own.claim.m, AUTH_FAILURE_REASON, AUTH_FAILURE_COOLDOWN_MS);
+                if (strike2) {
+                  await log("warn", `limit on ${own.claim.m} (${AUTH_FAILURE_REASON}); cooling it for ${Math.round((strike2.until - Date.now()) / 1e3)}s`, {
+                    model: own.claim.m,
+                    slot: own.claim.k,
+                    session: sessionID
+                  });
+                }
+              } else if (outage) {
                 const transient = coolUnavailable(s, own.claim.m);
                 if (transient) await log("warn", `cooling ${own.claim.m} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${transient.reason})`);
               } else {
@@ -2751,14 +2892,25 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
             return;
           }
           const status2 = typeof error?.data?.statusCode === "number" ? error.data.statusCode : void 0;
+          const auth2 = isAuthFailureText(haystack2) || status2 === 401 || status2 === 403;
           const limited2 = isLimitText(haystack2) || status2 === 429;
           const outage = isUnavailableText(haystack2);
-          if (!limited2 && !outage) return;
+          if (!limited2 && !outage && !auth2) return;
           const own = claimFor(sessionID);
-          const named = outage ? UNAVAILABLE_REASON : limitReason(haystack2) ?? "rate-limited";
+          const named = auth2 ? AUTH_FAILURE_REASON : outage ? UNAVAILABLE_REASON : limitReason(haystack2) ?? "rate-limited";
           let stated2;
           if (own) {
-            if (outage) {
+            if (auth2) {
+              stated2 = AUTH_FAILURE_COOLDOWN_MS;
+              const strike2 = recordStrike(s, own.claim.m, AUTH_FAILURE_REASON, stated2);
+              if (strike2) {
+                await log("warn", `limit on ${own.claim.m} (${AUTH_FAILURE_REASON}); cooling it for ${Math.round((strike2.until - Date.now()) / 1e3)}s from a terminal session.error`, {
+                  model: own.claim.m,
+                  slot: own.claim.k,
+                  session: sessionID
+                });
+              }
+            } else if (outage) {
               const transient = coolUnavailable(s, own.claim.m);
               if (transient) {
                 await log("warn", `cooling ${own.claim.m} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${transient.reason}) after a terminal error`);
@@ -2794,24 +2946,25 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         if (!info || info.role !== "assistant" || !info.error) return;
         const haystack = JSON.stringify(info.error) ?? "";
         const status = typeof info.error.data?.statusCode === "number" ? info.error.data.statusCode : void 0;
+        const auth = isAuthFailureText(haystack) || status === 401 || status === 403;
         const limited = isLimitText(haystack) || status === 429;
         const gateway5xx = status !== void 0 && status >= 500 && status <= 599;
         const transientGateway = gateway5xx || isTransientGatewayText(haystack);
-        if (!limited && !transientGateway) return;
+        if (!limited && !transientGateway && !auth) return;
         const model = `${info.providerID ?? "?"}/${info.modelID ?? "?"}`;
         if (info.sessionID && isProbe(s, info.sessionID)) {
           await log("debug", `probe of ${model} hit a limit (${isLimitText(haystack) ? "limit" : "transient"}); leaving the cooldown to the probe`);
           return;
         }
         const ownMsg = claimFor(info.sessionID);
-        if (isUnavailableText(haystack) || !limited && transientGateway) {
+        if (isUnavailableText(haystack) || !limited && !auth && transientGateway) {
           const transient = coolUnavailable(s, model);
           if (transient) await log("warn", `cooling ${model} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${transient.reason})`);
           await failOver(info.sessionID, model, transient?.reason ?? UNAVAILABLE_REASON, { cool: false });
           return;
         }
-        const stated = statedCooldown(haystack) ?? retryAfterMs(info.error.data?.responseHeaders);
-        const reason = limitReason(haystack);
+        const stated = auth ? AUTH_FAILURE_COOLDOWN_MS : statedCooldown(haystack) ?? retryAfterMs(info.error.data?.responseHeaders);
+        const reason = auth ? AUTH_FAILURE_REASON : limitReason(haystack);
         const strike = recordStrike(s, model, reason ?? "rate-limited", stated);
         if (strike) await log("warn", `cooling ${model} for ${Math.round((strike.until - Date.now()) / 1e3)}s (${reason ?? "rate-limited"}, strike ${strike.strikes})`);
         await failOver(info.sessionID, model, reason ?? "rate-limited", { stated, cool: !ownMsg });
@@ -2852,7 +3005,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
             weight: slot.weight,
             model: slot.model,
             ceiling: slotCeiling(slot),
-            load: (snap.counts.get(slot.model) ?? 0) + 1
+            load: (snap.counts.get(slot.index) ?? 0) + 1
           });
           output.args.subagent_type = variant;
           acquire(s, requested, slot, input.sessionID, claimKey(input.sessionID, input.callID));
@@ -2869,9 +3022,21 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         await log("error", `routing failed, spawn unchanged: ${String(error)}`);
       }
     },
-    "tool.execute.after": async (input) => {
+    "tool.execute.after": async (input, output) => {
       if (input.tool !== "task") return;
-      release(s, claimKey(input.sessionID, input.callID));
+      const key = claimKey(input.sessionID, input.callID);
+      release(s, key);
+      const report = abortReports.get(key);
+      if (!report) return;
+      abortReports.delete(key);
+      const detail = [
+        `pool spawn: ${report.message}`,
+        `slot ${report.slot}; model ${report.model}; elapsed ${report.elapsedMs}ms; failure ${report.kind}; claim ${report.released ? "released" : "held"}`
+      ].join("\n");
+      const text = typeof output.output === "string" ? output.output : "";
+      output.output = /task\s+cancel+ed/i.test(text) ? detail : text ? `${text}
+
+${detail}` : detail;
     },
     tool: {
       pool_recheck: tool({
@@ -2894,18 +3059,18 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           const snap = snapshot(s);
           const pass = poolPass(s, snap);
           const now = Date.now();
-          const byModel = /* @__PURE__ */ new Map();
-          const add = (model, base) => {
-            const entry = byModel.get(model) ?? { total: 0, bases: /* @__PURE__ */ new Map() };
+          const bySlot = /* @__PURE__ */ new Map();
+          const add = (k, base) => {
+            const entry = bySlot.get(k) ?? { total: 0, bases: /* @__PURE__ */ new Map() };
             entry.total++;
             entry.bases.set(base, (entry.bases.get(base) ?? 0) + 1);
-            byModel.set(model, entry);
+            bySlot.set(k, entry);
           };
-          for (const claim of snap.own.values()) add(claim.m, claim.v);
-          for (const sibling of snap.siblings) for (const claim of sibling.claims) add(claim.m, claim.v);
+          for (const claim of snap.own.values()) add(claim.k, claim.v);
+          for (const sibling of snap.siblings) for (const claim of sibling.claims) add(claim.k, claim.v);
           const next = pickSlot(s, snap);
           const line = (slot) => {
-            const entry = byModel.get(slot.model);
+            const entry = bySlot.get(slot.index);
             const users = entry && entry.bases.size > 0 ? [...entry.bases].map(([b, n]) => `${b}x${n}`).join(" ") : "idle";
             const strike = snap.cooling.get(slot.model);
             const status = s.catalog.get(slot.model);
@@ -2920,14 +3085,25 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           };
           const total = [...snap.counts.values()].reduce((sum, n) => sum + n, 0);
           const coolingNow = [...snap.cooling.entries()].filter(([, st]) => st.until > now);
+          const buckets = /* @__PURE__ */ new Map();
+          for (const slot of slots) {
+            const name = slotBucket(slot);
+            const entry = buckets.get(name) ?? { seats: 0, slots: 0, cooling: false };
+            entry.seats += slot.weight;
+            entry.slots++;
+            if (snap.cooling.has(slot.model)) entry.cooling = true;
+            buckets.set(name, entry);
+          }
+          const sharedBuckets = [...buckets].filter(([, entry]) => entry.slots > 1);
           const verdicts = [...snap.own.values()].map((claim) => condemnReason(s, claim, now));
           const hung = verdicts.filter((verdict) => verdict === "hung").length;
           const overran = verdicts.filter((verdict) => verdict === "overran").length;
           return {
             title: `agent-pool: ${total} task(s) in flight, ${coolingNow.length} model(s) cooling`,
             output: [
-              `shared pool over ${slots.length} model(s) from ${s.origin}; pass ${pass}; bases: ${BASES.join(", ")}
-two ordered passes in slot order: pass 1 fills each slot to its weight, pass 2 to its ceiling, then overflow goes to the least-loaded slot (FULL = at ceiling, used only when no other slot is available and under its ceiling)`,
+              `shared pool over ${slots.length} slot(s) from ${s.origin}; state ${pass}; bases: ${BASES.join(", ")}
+one ordered pass in slot order: each slot fills to its weight, then overflow goes to the least-loaded slot. Capacity is the sum of the weights; repeat a model on another line to give it more (FULL = at weight).`,
+              ...sharedBuckets.length ? [`buckets: ${sharedBuckets.map(([name, entry]) => `${name} ${entry.seats} seat(s)${entry.cooling ? " COOLING" : ""}`).join("; ")}`] : [],
               ...slots.map(line),
               "",
               "by process:",
@@ -3780,7 +3956,7 @@ var retireSession = async (client, directory, sessionID, mode, log) => {
     const gone = async () => await client.session.get({ path: { id: sessionID }, query: { directory } }).then((r) => r.data).catch(() => void 0) === void 0;
     await client.session.delete({ path: { id: sessionID }, query: { directory } }).catch(() => void 0);
     if (await gone()) return;
-    await new Promise((resolve4) => setTimeout(resolve4, 500));
+    await new Promise((resolve5) => setTimeout(resolve5, 500));
     await client.session.delete({ path: { id: sessionID }, query: { directory } }).catch(() => void 0);
     if (await gone()) return;
     await log?.("warn", "the cartographer's session could not be removed from the session list; it stays as an empty entry", {
@@ -4439,7 +4615,15 @@ var INTERNAL_TITLE_PREFIXES = [
   // context-autoupdate spawns the cartographer through the session API, with no
   // parentID, so it looks exactly like a root session going idle. Notifying for
   // it would announce the cartographer's own bookkeeping as a finished task.
-  "context (auto"
+  "context (auto",
+  // timeline spawns its summarizer through the session API with the same shape,
+  // so it would otherwise announce the summarizer's own bookkeeping as a task.
+  "timeline (auto",
+  // pool probe sessions are created as root sessions with no parentID and the
+  // title `pool probe (<model>)` (`src/lib/probe.ts`), so notification for
+  // their idle/error would announce Lacode's own health-check as finished user
+  // work.
+  "pool probe"
 ];
 var NOTIFY_OUTCOMES = ["done", "question", "permission", "error"];
 var notifyMessage = (outcome, detail) => {
@@ -4927,10 +5111,10 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
     const info = await client.session.get({ path: { id: sessionID }, query: { directory } }).then((result) => result.data).catch(() => void 0);
     return info;
   };
-  const deliverViaHelper = (title, message, urgency, sound, requestID, sessionID) => new Promise((resolve4) => {
+  const deliverViaHelper = (title, message, urgency, sound, requestID, sessionID) => new Promise((resolve5) => {
     if (inflight >= maxInflight) {
       void log("warn", `notification dropped: ${inflight} helpers already in flight`, { title });
-      resolve4({ ok: false, detail: `too many notification helpers in flight (${inflight})` });
+      resolve5({ ok: false, detail: `too many notification helpers in flight (${inflight})` });
       return;
     }
     const helper = findHelper();
@@ -4939,7 +5123,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
         warnedHelper = true;
         void log("warn", "no oc-notify helper found; run 'bin/oc-sync' to install one");
       }
-      resolve4({ ok: false, detail: "no oc-notify helper found" });
+      resolve5({ ok: false, detail: "no oc-notify helper found" });
       return;
     }
     const childEnv = { ...process.env, ...sessionID ? { [NOTIFY_SESSION_ENV]: sessionID } : {} };
@@ -4962,7 +5146,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       settled = true;
       inflight--;
       if (timer) clearTimeout(timer);
-      resolve4(result);
+      resolve5(result);
     };
     timer = setTimeout(() => {
       try {
@@ -5751,6 +5935,741 @@ async function selfUpdateHooks(input, options) {
   return {};
 }
 
+// src/plugins/timeline.ts
+import { writeFileSync as writeFileSync8, renameSync as renameSync6, rmSync as rmSync3 } from "node:fs";
+import { tool as tool2 } from "@opencode-ai/plugin";
+
+// src/lib/timeline.ts
+import { appendFileSync, mkdirSync as mkdirSync7, readFileSync as readFileSync10, rmSync as rmSync2 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname5, join as join11, resolve as resolve4 } from "node:path";
+function timelineDir() {
+  const env = process.env.LACODE_TIMELINE_DIR;
+  if (env) return resolve4(env);
+  return join11(homedir7(), ".local/share/opencode/lacode/timeline");
+}
+function timelineFile(sessionID) {
+  if (!/^[A-Za-z0-9_.-]+$/.test(sessionID)) throw new Error("invalid sessionID");
+  return join11(timelineDir(), sessionID + ".jsonl");
+}
+function normalizeThrough(through) {
+  if (!through || typeof through !== "object") return void 0;
+  const out = {};
+  if (typeof through.messageID === "string") out.messageID = through.messageID;
+  if (typeof through.time === "number") out.time = through.time;
+  if (out.messageID === void 0 && out.time === void 0) return void 0;
+  return out;
+}
+function appendEntriesAt(file, texts, now, through) {
+  mkdirSync7(dirname5(file), { recursive: true });
+  const cleaned = [];
+  for (const t of texts) {
+    if (typeof t !== "string" || t.length === 0) continue;
+    cleaned.push(t.slice(0, 320));
+  }
+  let recent = [];
+  try {
+    recent = readEntriesAt(file, 20);
+  } catch {
+    recent = [];
+  }
+  const recentSet = new Set(recent.map((e) => e.text.toLowerCase()));
+  const batchSeen = /* @__PURE__ */ new Set();
+  const toAppend = [];
+  for (const t of cleaned) {
+    const key = t.toLowerCase();
+    if (recentSet.has(key)) continue;
+    if (batchSeen.has(key)) continue;
+    batchSeen.add(key);
+    toAppend.push(t);
+  }
+  const validThrough = normalizeThrough(through);
+  let count = 0;
+  for (const t of toAppend) {
+    const ts = now ?? Date.now();
+    const line = { ts, text: t };
+    if (validThrough) line.through = validThrough;
+    appendFileSync(file, JSON.stringify(line) + "\n");
+    count++;
+  }
+  return count;
+}
+function readEntriesAt(file, limit) {
+  let raw = "";
+  try {
+    raw = readFileSync10(file, "utf8");
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    if (line.trim() === "") continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj && typeof obj.ts === "number" && typeof obj.text === "string") {
+        const entry = { ts: obj.ts, text: obj.text };
+        const t = normalizeThrough(obj.through);
+        if (t) entry.through = t;
+        entries.push(entry);
+      }
+    } catch {
+    }
+  }
+  if (limit != null && limit <= 0) return [];
+  const lim = limit == null ? 50 : limit;
+  return entries.slice(-lim);
+}
+function appendEntries(sessionID, texts, now, through) {
+  return appendEntriesAt(timelineFile(sessionID), texts, now, through);
+}
+function readEntries(sessionID, limit) {
+  return readEntriesAt(timelineFile(sessionID), limit);
+}
+function removeEntries(sessionID) {
+  try {
+    rmSync2(timelineFile(sessionID), { force: true });
+  } catch {
+  }
+}
+function collapse(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function trunc(s, n) {
+  return s.length > n ? s.slice(0, n) : s;
+}
+function stripAnsiAndControls(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code === 27) {
+      if (i + 1 < s.length && s[i + 1] === "[") {
+        i += 2;
+        while (i < s.length) {
+          const c = s.charCodeAt(i);
+          if (c >= 64 && c <= 126) {
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+      if (i + 1 < s.length && s[i + 1] === "]") {
+        i += 2;
+        while (i < s.length) {
+          const c = s.charCodeAt(i);
+          if (c === 7) break;
+          if (c === 27 && i + 1 < s.length && s[i + 1] === "\\") {
+            i += 1;
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+      if (i + 1 < s.length) {
+        i += 1;
+      }
+      continue;
+    }
+    if (code === 9 || code === 10) {
+      out += s[i];
+      continue;
+    }
+    if (code < 32 || code >= 127 && code <= 159) {
+      continue;
+    }
+    out += s[i];
+  }
+  return out;
+}
+function inputSummary(input) {
+  if (input === null || input === void 0) return "";
+  if (typeof input !== "object") {
+    try {
+      return trunc(collapse(JSON.stringify(input)), 160);
+    } catch {
+      return "";
+    }
+  }
+  const rec = input;
+  const keys = ["filePath", "path", "command", "description", "pattern", "query", "url", "name", "title"];
+  for (const k of keys) {
+    if (Object.prototype.hasOwnProperty.call(rec, k) && rec[k] != null) {
+      const v = rec[k];
+      const s = typeof v === "string" ? v : JSON.stringify(v);
+      return trunc(collapse(s), 160);
+    }
+  }
+  try {
+    return trunc(collapse(JSON.stringify(rec)), 160);
+  } catch {
+    return "";
+  }
+}
+function summarizeToolResult(state2) {
+  if (!state2) return "";
+  const err = state2.error;
+  if (typeof err === "string") {
+    if (err.trim() === "") return "";
+    return `error: ${trunc(err, 180)}`;
+  }
+  if (err && typeof err === "object") {
+    try {
+      const s = JSON.stringify(err);
+      if (typeof s === "string" && s.trim() !== "") {
+        return trunc(s, 180);
+      }
+    } catch {
+    }
+    return "";
+  }
+  if (typeof state2.output === "string") {
+    for (const raw of state2.output.split("\n")) {
+      const line = raw.trim();
+      if (line.length > 0) {
+        return trunc(line, 180);
+      }
+    }
+  }
+  if (typeof state2.title === "string" && state2.title.trim() !== "") {
+    return trunc(state2.title, 180);
+  }
+  return "";
+}
+function renderMessage(m) {
+  const role = m.info.role;
+  const lines = [];
+  if (role === "user") {
+    for (const p of m.parts) {
+      if (p.type === "text" && !p.synthetic && !p.ignored) {
+        if ((p.text ?? "").includes("timeline_reprocess")) continue;
+        const text = collapse(p.text ?? "");
+        lines.push(`[user] ${trunc(text, 2e3)}`);
+      }
+    }
+  } else if (role === "assistant") {
+    for (const p of m.parts) {
+      if (p.type === "text") {
+        const text = collapse(p.text ?? "");
+        lines.push(`[assistant] ${trunc(text, 1500)}`);
+      } else if (p.type === "tool") {
+        const tool3 = p.tool ?? "";
+        if (tool3 === "timeline_reprocess") continue;
+        const status = p.state?.status;
+        const summary = inputSummary(p.state?.input);
+        const result = summarizeToolResult(p.state);
+        let line = `[tool] ${tool3}`;
+        if (status) line += ` (${status})`;
+        const inputPart = summary ? trunc(summary, 220) : "";
+        let rest = "";
+        if (inputPart) rest += ` ${inputPart}`;
+        if (result) rest += ` -> ${result}`;
+        line += rest;
+        lines.push(line);
+      }
+    }
+  }
+  return lines;
+}
+function buildExcerpt(messages, cursor, budget = 8e3) {
+  let start = 0;
+  if (cursor?.messageID) {
+    const idx = messages.findIndex((m) => m.info.id === cursor.messageID);
+    if (idx >= 0) {
+      start = idx + 1;
+    } else if (cursor.time != null) {
+      const i = messages.findIndex((m) => (m.info.time?.created ?? -Infinity) > cursor.time);
+      start = i < 0 ? messages.length : i;
+    }
+  } else if (cursor?.time != null) {
+    const i = messages.findIndex((m) => (m.info.time?.created ?? -Infinity) > cursor.time);
+    start = i < 0 ? messages.length : i;
+  }
+  const outLines = [];
+  const included = [];
+  for (let i = start; i < messages.length; i++) {
+    const m = messages[i];
+    const msgLines = renderMessage(m);
+    if (msgLines.length === 0) continue;
+    const candidateLines = outLines.length === 0 ? [...msgLines] : [...outLines, ...msgLines];
+    const candidateText = candidateLines.join("\n");
+    if (included.length > 0 && candidateText.length > budget) {
+      break;
+    }
+    if (included.length === 0 && candidateText.length > budget) {
+      const block = msgLines.join("\n");
+      outLines.push(block.slice(0, budget));
+      included.push(m);
+      break;
+    }
+    outLines.push(...msgLines);
+    included.push(m);
+  }
+  let model;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const info = messages[i].info;
+    if (info.role !== "user") continue;
+    if (info.model) {
+      model = { providerID: info.model.providerID, modelID: info.model.modelID };
+      break;
+    }
+    if (info.providerID && info.modelID) {
+      model = { providerID: info.providerID, modelID: info.modelID };
+      break;
+    }
+  }
+  const lastIncluded = included[included.length - 1];
+  const next = lastIncluded ? { messageID: lastIncluded.info.id, time: lastIncluded.info.time?.created } : void 0;
+  return {
+    text: outLines.join("\n"),
+    next,
+    count: included.length,
+    model
+  };
+}
+function parseBullets(text, max = 6) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("```")) continue;
+    if (line.length > 320) continue;
+    const m = line.match(/^([-*•]|\d+[.)])\s+(.*)$/);
+    if (!m) continue;
+    const stripped = m[2].trim().replace(/`/g, "").replace(/\*\*/g, "").trim();
+    if (!stripped) continue;
+    const cleaned = stripAnsiAndControls(stripped).trim();
+    if (!cleaned) continue;
+    if (cleaned.length > 320) continue;
+    const key = cleaned.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(cleaned);
+    if (result.length >= max) break;
+  }
+  return result;
+}
+function isInternalTitle(title) {
+  const t = (title ?? "").trim();
+  return t.startsWith("context (auto") || t.startsWith("timeline (auto") || t.startsWith("pool probe");
+}
+
+// src/plugins/timeline.ts
+var DEFAULT_INTERVAL_MS = 3e5;
+var MIN_INTERVAL_MS = 1e4;
+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.
+
+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.
+- 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.
+- For configuration plumbing, write the purpose: "Config: silenced warnings for unused providers", not "declared empty overrides".
+- 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.
+
+Example output:
+- Pool: added bucket-based routing for model groups.
+- Providers: added Gemini 3.5 Flash after the previous model timed out.
+- Providers: added Cloudflare Workers AI with a tool-compatible model.
+- Config: silenced warnings for unused providers.
+- Config: standardized provider key naming and added Groq and Google.
+- Docs: aligned the routing documentation with the implemented behavior.
+
+Not this:
+- Config: declared empty OpenRouter overrides to silence warnings.
+- Providers: added a Google API key alias after Gemini 2.5-flash closure.
+- Config: standardized provider keys to _KEY-only naming.
+- Pool: reordered slots after tagging pool entries.
+- Pool: added bucket support and kept tags in pool.
+- Pool: standardized slots on opencode catalog.
+- Providers: added Gemini 3.5 Flash and a Google API key alias.
+
+This:
+- Config: silenced warnings for unused providers.
+- Providers: replaced the retired Gemini 2.5 Flash with an available model.
+- Config: standardized provider key naming.
+- Pool: moved shared-window models to the end.
+- Pool: added named bucket support for model groups.
+- 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 "- ".`;
+function timelineHooks(input, options) {
+  const { client, directory } = input;
+  const opts = options ?? {};
+  const config = typeof opts.timeline === "object" && opts.timeline !== null ? opts.timeline : void 0;
+  const disabled = opts.timeline === false || config?.enabled === false || process.env.LACODE_TIMELINE === "0";
+  const SERVICE5 = "timeline";
+  const poolState = state(options);
+  const log = (level, message, extra) => client.app.log({ body: { service: SERVICE5, level, message, extra } }).catch(() => {
+  });
+  const debug = (...args) => {
+    if (process.env.LACODE_TIMELINE_DEBUG === "1") console.error("[timeline]", ...args);
+  };
+  const rawInterval = Number(process.env.LACODE_TIMELINE_INTERVAL_MS ?? config?.intervalMs ?? DEFAULT_INTERVAL_MS);
+  const intervalMs = Number.isFinite(rawInterval) ? Math.max(MIN_INTERVAL_MS, rawInterval) : DEFAULT_INTERVAL_MS;
+  const rawMaxEntries = Number(config?.maxEntries ?? DEFAULT_MAX_ENTRIES);
+  const maxEntries = Number.isFinite(rawMaxEntries) ? Math.min(MAX_ENTRIES, Math.max(1, Math.trunc(rawMaxEntries))) : DEFAULT_MAX_ENTRIES;
+  const shared = globalThis[/* @__PURE__ */ Symbol.for("lacode:timeline:state")] ??= {
+    sessions: /* @__PURE__ */ new Map(),
+    owned: /* @__PURE__ */ new Set(),
+    reprocessing: /* @__PURE__ */ new Set()
+  };
+  const sessions = shared.sessions;
+  const owned = shared.owned;
+  const reprocessing = shared.reprocessing;
+  const MAX_REPROCESS_SLICES = 100;
+  let disposed = false;
+  const promptModel = (raw) => {
+    if (typeof raw !== "string" || !raw.includes("/")) return void 0;
+    const { provider, id } = splitModel(raw);
+    if (!id) return void 0;
+    return { providerID: provider, modelID: id };
+  };
+  const stateFor = (id) => {
+    let state2 = sessions.get(id);
+    if (!state2) {
+      state2 = {
+        running: false,
+        pending: false,
+        failures: 0,
+        cursor: readEntries(id, 1)[0]?.through
+      };
+      sessions.set(id, state2);
+      while (sessions.size > 500) {
+        let evicted = false;
+        for (const [key, st] of sessions) {
+          if (key === id) continue;
+          if (!st.timer && !st.running) {
+            sessions.delete(key);
+            evicted = true;
+            break;
+          }
+        }
+        if (!evicted) break;
+      }
+    }
+    return state2;
+  };
+  const note = (id) => {
+    if (disabled || disposed) return;
+    const state2 = stateFor(id);
+    if (state2.root === false) return;
+    state2.pending = true;
+    if (state2.timer || state2.running) return;
+    schedule(id, state2);
+  };
+  function schedule(id, state2) {
+    if (state2.timer) clearTimeout(state2.timer);
+    state2.timer = setTimeout(() => {
+      state2.timer = void 0;
+      void tick(id, state2);
+    }, intervalMs);
+    state2.timer.unref?.();
+  }
+  async function summarize(id, title, excerptText, prior, abort) {
+    if (abort?.aborted) return { ok: false, bullets: [], error: "aborted" };
+    let slot;
+    try {
+      init(poolState, (m) => log("warn", m));
+      const snap = snapshot(poolState);
+      slot = pickSlot(poolState, snap);
+    } catch (error) {
+      log("warn", String(error));
+      return { ok: false, bullets: [], error: String(error) };
+    }
+    const model = promptModel(slot?.model);
+    if (!model) {
+      log("warn", "timeline: slot model cannot be split into provider/model", { model: slot?.model });
+      return { ok: false, bullets: [], error: "slot model cannot be split into provider/model" };
+    }
+    const created = await client.session.create({
+      body: { title: "timeline (auto)" },
+      query: { directory }
+    });
+    const target = created?.data?.id;
+    if (!target) {
+      return { ok: false, bullets: [], error: "session create returned no id" };
+    }
+    const claimKey2 = claimKey(target, "timeline");
+    let claimed = false;
+    owned.add(target);
+    let abortListener;
+    try {
+      claimed = true;
+      acquire(poolState, "context", slot, target, claimKey2, target);
+      const prompt = [
+        `Session: ${title}`,
+        ...prior.length > 0 ? ["Existing timeline (do not repeat):", ...prior.map((entry) => `- ${entry.text}`)] : [],
+        "Transcript slice:",
+        excerptText
+      ].join("\n");
+      if (abort) {
+        abortListener = () => {
+          void client.session.abort({ path: { id: target }, query: { directory } }).catch(() => {
+          });
+        };
+        abort.addEventListener("abort", abortListener);
+      }
+      let timer;
+      let timedOut = false;
+      let result;
+      try {
+        const answer = client.session.prompt({
+          path: { id: target },
+          query: { directory },
+          body: {
+            model,
+            tools: { "*": false },
+            system: SYSTEM,
+            parts: [{ type: "text", text: prompt }]
+          }
+        }).then(
+          (value) => value,
+          (error) => ({ error })
+        );
+        const deadline = new Promise((resolve5) => {
+          timer = setTimeout(() => {
+            timedOut = true;
+            void client.session.abort({ path: { id: target }, query: { directory } }).catch(() => {
+            });
+            resolve5(void 0);
+          }, PROMPT_TIMEOUT_MS);
+        });
+        result = await Promise.race([answer, deadline]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+      if (abort?.aborted) {
+        return { ok: false, bullets: [], error: "aborted" };
+      }
+      const failure = result?.error ?? result?.data?.info?.error;
+      if (timedOut || failure !== void 0) {
+        return { ok: false, bullets: [], error: timedOut ? "timed out" : String(failure) };
+      } else {
+        const text = (result?.data?.parts ?? []).map((part) => part.type === "text" ? part.text ?? "" : "").join("\n");
+        const bullets = parseBullets(text, maxEntries);
+        if (bullets.length > 0) {
+          return { ok: true, bullets };
+        } else if (text.trim() === "") {
+          return { ok: true, bullets: [] };
+        } else {
+          if (process.env.LACODE_TIMELINE_DEBUG === "1") {
+            log("no bullet lines", { sessionID: id, text: text.slice(0, 300) });
+          }
+          return { ok: false, bullets: [], error: "no bullet lines" };
+        }
+      }
+    } finally {
+      if (abort && abortListener) abort.removeEventListener("abort", abortListener);
+      if (claimed && claimKey2) release(poolState, claimKey2);
+      await client.session.delete({ path: { id: target }, query: { directory } }).catch(() => {
+      });
+      owned.delete(target);
+    }
+  }
+  async function tick(id, state2) {
+    if (disposed) return;
+    if (reprocessing.has(id)) return;
+    try {
+      state2.running = true;
+      state2.pending = false;
+      let title;
+      let info = {};
+      if (state2.root === void 0) {
+        info = await client.session.get({ path: { id }, query: { directory } }).then((result2) => result2?.data).catch(() => void 0);
+        if (!info) {
+          sessions.delete(id);
+          return;
+        }
+        title = info.title;
+        state2.root = !info.parentID && !isInternalTitle(info.title);
+        if (!state2.root) {
+          sessions.delete(id);
+          return;
+        }
+      }
+      const response = await client.session.messages({ path: { id }, query: { directory } });
+      const messages = response?.data ?? [];
+      const excerpt = buildExcerpt(messages, state2.cursor);
+      if (!excerpt.text) {
+        return;
+      }
+      const result = await summarize(id, info.title ?? "untitled", excerpt.text, readEntries(id, 4));
+      if (result.ok) {
+        if (result.bullets.length) appendEntries(id, result.bullets, Date.now(), excerpt.next);
+        state2.cursor = excerpt.next;
+        state2.failures = 0;
+      } else {
+        state2.failures++;
+        log("summarize failed", { sessionID: id, error: result.error });
+      }
+    } catch (error) {
+      debug("tick failed", { sessionID: id, error });
+    } finally {
+      state2.running = false;
+      if (sessions.get(id) === state2 && state2.pending && !disabled && !disposed && state2.root !== false) {
+        schedule(id, state2);
+      }
+    }
+  }
+  async function reprocess(id, abort) {
+    if (reprocessing.has(id)) return "A timeline reprocess is already running for this session.";
+    if (sessions.get(id)?.running) return "The timeline is currently summarizing this session; try again in a moment.";
+    reprocessing.add(id);
+    const targetFile = timelineFile(id);
+    const temp = targetFile + ".reprocess." + process.pid + "." + Date.now() + ".tmp";
+    let cursor;
+    let entries = 0;
+    let calls = 0;
+    try {
+      const infoRes = await client.session.get({ path: { id }, query: { directory } });
+      const info = infoRes?.data;
+      if (!info) return "Session not found.";
+      const msgRes = await client.session.messages({ path: { id }, query: { directory } });
+      const messages = msgRes?.data ?? [];
+      writeFileSync8(temp, "");
+      for (let i = 0; i < MAX_REPROCESS_SLICES; i++) {
+        if (abort?.aborted) {
+          try {
+            rmSync3(temp, { force: true });
+          } catch {
+          }
+          return `Aborted after ${calls} summarizer calls; previous timeline kept.`;
+        }
+        const excerpt = buildExcerpt(messages, cursor);
+        if (!excerpt.text) break;
+        const prior = readEntriesAt(temp, 4);
+        const result = await summarize(id, info.title ?? "untitled", excerpt.text, prior, abort);
+        calls++;
+        if (!result.ok) {
+          try {
+            rmSync3(temp, { force: true });
+          } catch {
+          }
+          return `Stopped after ${calls} summarizer calls: ${result.error}. Previous timeline kept.`;
+        }
+        if (result.bullets.length) {
+          entries += appendEntriesAt(temp, result.bullets, Date.now(), excerpt.next);
+        }
+        cursor = excerpt.next;
+      }
+      if (abort?.aborted) {
+        try {
+          rmSync3(temp, { force: true });
+        } catch {
+        }
+        return `Aborted after ${calls} summarizer calls; previous timeline kept.`;
+      }
+      if (entries === 0) {
+        try {
+          rmSync3(temp, { force: true });
+        } catch {
+        }
+        return "No entries generated; previous timeline kept.";
+      }
+      renameSync6(temp, targetFile);
+      const state2 = sessions.get(id);
+      if (state2) {
+        state2.cursor = cursor;
+        state2.failures = 0;
+        state2.pending = false;
+      }
+      return `Rebuilt ${messages.length} messages into ${entries} entries with ${calls} summarizer calls.`;
+    } catch (error) {
+      try {
+        rmSync3(temp, { force: true });
+      } catch {
+      }
+      return `Reprocess failed: ${String(error)}. Previous timeline kept.`;
+    } finally {
+      reprocessing.delete(id);
+    }
+  }
+  const timelineReprocess = tool2({
+    description: "Rebuild the current session's entire timeline from its transcript, replacing the existing entries. Used by /reprocess-timeline.",
+    args: {},
+    execute: async (_args, ctx) => {
+      const output = await reprocess(ctx.sessionID, ctx.abort);
+      return { title: "Timeline reprocess", output };
+    }
+  });
+  return {
+    event: async ({ event }) => {
+      try {
+        switch (event.type) {
+          case "message.updated": {
+            const id = event.properties.info?.sessionID;
+            if (!id) return;
+            if (owned.has(id)) return;
+            const role = event.properties.info?.role;
+            if (role === "user" || role === "assistant") note(id);
+            return;
+          }
+          case "message.part.updated": {
+            const id = event.properties.part?.sessionID;
+            if (!id) return;
+            if (owned.has(id)) return;
+            const type = event.properties.part?.type;
+            if (type === "text" || type === "tool") note(id);
+            return;
+          }
+          case "session.created": {
+            const info = event.properties.info;
+            if (!info) return;
+            if (isInternalTitle(info.title)) owned.add(info.id);
+            return;
+          }
+          case "session.deleted": {
+            const id = event.properties.info?.id;
+            if (!id) return;
+            const state2 = sessions.get(id);
+            if (state2?.timer) {
+              clearTimeout(state2.timer);
+              state2.timer = void 0;
+            }
+            sessions.delete(id);
+            removeEntries(id);
+            owned.delete(id);
+            return;
+          }
+          default:
+            return;
+        }
+      } catch (error) {
+        debug("event failed", error);
+      }
+    },
+    dispose: async () => {
+      disposed = true;
+      for (const state2 of sessions.values()) {
+        if (state2.timer) {
+          clearTimeout(state2.timer);
+          state2.timer = void 0;
+        }
+      }
+      reprocessing.clear();
+    },
+    tool: { timeline_reprocess: timelineReprocess }
+  };
+}
+
 // src/index.ts
 var inertHooks = {
   config: async () => {
@@ -5786,7 +6705,7 @@ var LaCode = (async (input, options) => {
       return void 0;
     }
   };
-  const agentSet = buildAgentSet();
+  const agentSet = buildAgentSet(resolveModels({ models: opts.models, modelsFile: opts.modelsFile }).slots.length);
   const pool = await settled("agent-pool", () => agentPoolHooks(input, options)) ?? inertHooks;
   const autoupdate = await settled("context-autoupdate", () => contextAutoUpdateHooks(input, options)) ?? inertHooks;
   const notifier = await settled("notify", () => notifyHooks(input, options)) ?? inertHooks;
@@ -5794,6 +6713,7 @@ var LaCode = (async (input, options) => {
   const feedback = await settled("feedback", () => feedbackHooks(input, options)) ?? inertHooks;
   const omniroute = await settled("omniroute", () => omniRouteHooks(input, options)) ?? inertHooks;
   const imagepaste = await settled("image-paste", () => imagePasteHooks(input, opts.imagePaste)) ?? inertHooks;
+  const timeline = await settled("timeline", () => timelineHooks(input, options)) ?? inertHooks;
   const config = async (cfg) => {
     try {
       const injected = applyAgents(cfg, agentSet);
@@ -5817,6 +6737,8 @@ var LaCode = (async (input, options) => {
       autoupdate.event?.(payload).catch(() => {
       }),
       notifier.event?.(payload).catch(() => {
+      }),
+      timeline.event?.(payload).catch(() => {
       })
     ]);
   };
@@ -5827,7 +6749,7 @@ var LaCode = (async (input, options) => {
     // only thing that routes task calls, so there is nothing to merge them with.
     "tool.execute.before": pool["tool.execute.before"],
     "tool.execute.after": pool["tool.execute.after"],
-    tool: pool.tool,
+    tool: { ...pool.tool ?? {}, ...timeline.tool ?? {} },
     "command.execute.before": imagepaste["command.execute.before"],
     dispose: async () => {
       await pool.dispose?.();
@@ -5837,6 +6759,7 @@ var LaCode = (async (input, options) => {
       await feedback.dispose?.();
       await omniroute.dispose?.();
       await imagepaste.dispose?.();
+      await timeline.dispose?.();
     },
     "experimental.chat.system.transform": async (_input, output) => {
       if (!Array.isArray(output?.system)) return;