@lawaty/lacode 1.0.3 → 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);
 }
@@ -106,25 +122,25 @@ function parseSlotText(text, origin) {
   }
   return parseTextSlots(text, origin);
 }
-var readJSON = (path4) => {
+var readJSON = (path5) => {
   try {
-    return { ok: true, value: JSON.parse(readFileSync2(path4, "utf8")) };
+    return { ok: true, value: JSON.parse(readFileSync2(path5, "utf8")) };
   } catch (error) {
     return { ok: false, error: String(error) };
   }
 };
-function readOptional(path4, origin, problems) {
-  const result = readJSON(path4);
+function readOptional(path5, origin, problems) {
+  const result = readJSON(path5);
   if (!result.ok) {
-    if (existsSync(path4)) problems.push(`${origin} unreadable (${result.error}); trying the next source`);
+    if (existsSync(path5)) problems.push(`${origin} unreadable (${result.error}); trying the next source`);
     return void 0;
   }
   return result.value;
 }
-function readTextOptional(path4, origin, problems) {
-  if (!existsSync(path4)) return void 0;
+function readTextOptional(path5, origin, problems) {
+  if (!existsSync(path5)) return void 0;
   try {
-    return readFileSync2(path4, "utf8");
+    return readFileSync2(path5, "utf8");
   } catch (error) {
     problems.push(`${origin} unreadable (${String(error)}); trying the next source`);
     return void 0;
@@ -163,14 +179,14 @@ function resolveModels(input = {}) {
   }
   return { slots: FALLBACK_SLOTS, problems: [...problems, `no pool source found (${USER_MODELS_TXT}, ${USER_MODELS_PATH}, ${DEFAULT_PRESET}); using built-in defaults`], origin: "built-in defaults" };
 }
-function readSlotFile(path4) {
+function readSlotFile(path5) {
   let text;
   try {
-    text = readFileSync2(path4, "utf8");
+    text = readFileSync2(path5, "utf8");
   } catch (error) {
-    return { slots: FALLBACK_SLOTS, problems: [`${path4} unreadable (${String(error)}); using built-in defaults`] };
+    return { slots: FALLBACK_SLOTS, problems: [`${path5} unreadable (${String(error)}); using built-in defaults`] };
   }
-  return parseSlotText(text, path4);
+  return parseSlotText(text, path5);
 }
 function ensureUserConfigDir() {
   try {
@@ -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);
@@ -433,16 +457,16 @@ function readSiblings(s) {
   }
   const now = Date.now();
   for (const entry of entries) {
-    const path4 = join2(s.dir, entry);
+    const path5 = join2(s.dir, entry);
     let age;
     try {
-      age = now - statSync(path4).mtimeMs;
+      age = now - statSync(path5).mtimeMs;
     } catch {
       continue;
     }
     if (entry.endsWith(".tmp")) {
       if (age > ORPHAN_TMP_MS) try {
-        unlinkSync(path4);
+        unlinkSync(path5);
       } catch {
       }
       continue;
@@ -451,22 +475,22 @@ function readSiblings(s) {
     if (!match || match[1] === s.id) continue;
     if (age > DEAD_FILE_MS) {
       try {
-        unlinkSync(path4);
+        unlinkSync(path5);
       } catch {
       }
       continue;
     }
     if (/^\d+$/.test(match[1]) && !isPidAlive(Number(match[1]))) {
       try {
-        unlinkSync(path4);
+        unlinkSync(path5);
       } catch {
       }
       continue;
     }
     try {
-      const parsed = JSON.parse(readFileSync2(path4, "utf8"));
+      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 {
@@ -488,9 +512,9 @@ function readLimits(s) {
   const now = Date.now();
   for (const entry of entries) {
     if (!entry.startsWith("limit.") || !entry.endsWith(".json")) continue;
-    const path4 = join2(s.dir, entry);
+    const path5 = join2(s.dir, entry);
     try {
-      const strike = JSON.parse(readFileSync2(path4, "utf8"));
+      const strike = JSON.parse(readFileSync2(path5, "utf8"));
       if (typeof strike.until !== "number" || typeof strike.model !== "string") continue;
       const countsAsStrike = strike.reason !== UNAVAILABLE_REASON;
       if (strike.until > now) {
@@ -499,11 +523,11 @@ function readLimits(s) {
       } else if (typeof strike.last === "number" && now - strike.last < STRIKE_DECAY_MS) {
         if (countsAsStrike) memory.set(strike.model, strike);
       } else {
-        unlinkSync(path4);
+        unlinkSync(path5);
       }
     } catch {
       try {
-        unlinkSync(path4);
+        unlinkSync(path5);
       } 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 path4 = join2(s.dir, limitFile(model));
-  try {
-    writeFileSync(`${path4}.tmp`, JSON.stringify(strike));
-    renameSync(`${path4}.tmp`, path4);
-  } 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;
 }
@@ -541,10 +577,10 @@ function coolUnavailable(s, model) {
   if (prior && prior.until > until) return prior;
   const strike = { model, until, strikes: 1, reason: UNAVAILABLE_REASON, last: now };
   s.cooling.set(model, strike);
-  const path4 = join2(s.dir, limitFile(model));
+  const path5 = join2(s.dir, limitFile(model));
   try {
-    writeFileSync(`${path4}.tmp`, JSON.stringify(strike));
-    renameSync(`${path4}.tmp`, path4);
+    writeFileSync(`${path5}.tmp`, JSON.stringify(strike));
+    renameSync(`${path5}.tmp`, path5);
   } catch {
   }
   return strike;
@@ -561,17 +597,17 @@ function clearCooldowns(s, models) {
   }
   for (const entry of entries) {
     if (!entry.startsWith("limit.") || !entry.endsWith(".json")) continue;
-    const path4 = join2(s.dir, entry);
+    const path5 = join2(s.dir, entry);
     let strike;
     try {
-      const parsed = JSON.parse(readFileSync2(path4, "utf8"));
+      const parsed = JSON.parse(readFileSync2(path5, "utf8"));
       if (parsed && typeof parsed.model === "string") strike = parsed;
     } catch {
       strike = void 0;
     }
     if (wanted && (strike === void 0 || !wanted.has(strike.model))) continue;
     try {
-      unlinkSync(path4);
+      unlinkSync(path5);
     } catch {
       continue;
     }
@@ -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) {
@@ -750,6 +782,373 @@ function coolProvider(s, provider, until, reason) {
 var AGENT_INSTRUCTIONS_COMMAND = "agent-instructions";
 var AGENT_INSTRUCTIONS_WRITER = "instructions";
 
+// src/lib/cartographer-prompt.ts
+var CARTOGRAPHER_PROMPT = `# Role
+
+You are the repository cartographer and memory maintainer. You are not a coding
+agent. You maintain exactly one thing: the repository context map in
+\`.opencode/context/\`.
+
+The context map is a lightweight navigation index that future agents read
+before exploring. It exists to answer "what should I look at first?" \u2014 never
+"tell me everything about the repository". Source code is authoritative for how
+the system works; the project's own pages are authoritative for what they
+define. The map is a derived index of both.
+
+# The one entry schema
+
+Every entry in every navigation file is one markdown list item with:
+
+1. a provenance marker,
+2. the operative rule, in one to three lines,
+3. a pointer to the page or path that owns it, and
+4. the date it was last verified.
+
+    - [binding] The system is split into a gateway and a store because the gateway must stay stateless. \u2014 See \`docs/DESIGN.md\` \xA7The two halves (verified 2026-10-26)
+
+If the rule wraps, indent the continuation lines by two spaces; the whole entry
+stays one list item. A subsystem's "start here" files go on that entry's own line
+(\`start at \\\`src/a.ts\\\`, \\\`src/b.ts\\\`\`) \u2014 a nested bullet list is a second, unbudgeted
+entry and is rejected.
+
+Use exactly one marker:
+
+- \`[binding]\` \u2014 established against the source; a constraint other work must
+  respect. Exempt from age expiry.
+- \`[provisional]\` \u2014 inferred or not yet verified. Expires 30 days after
+  \`verified\` unless re-verified. Never present it as a rule.
+- \`[disputed]\` \u2014 the map and a cited page disagree. Keep it, report it, and
+  never silently resolve it.
+
+The pointer is mandatory. A fact whose home is a page cites the page AND its
+section: \`\` \`docs/DESIGN.md\` \xA7The two halves \`\`. A fact whose home is code
+cites the path, optionally with a line or symbol: \`\` \`src/gateway.ts:42\` \`\`.
+\`(verified YYYY-MM-DD)\` is mandatory: it is the date you last checked the cited
+source. An entry with no pointer is not an entry; it is unarchived content (see
+"Never the archive").
+
+Never write Context / Decision / Consequences / Alternatives / Status /
+Rationale blocks, decision records, meeting narrative, or history. A reader
+needs the constraint, not the deliberation that produced it. No markdown tables
+and no fenced code blocks anywhere in the map: both are restatements of a page
+that owns the fact.
+
+# Per-file charters and budgets
+
+You own exactly these files and nothing else:
+
+- \`.opencode/context/architecture.md\` \u2014 cross-subsystem structure: layers,
+  boundaries, canonical entry points, dependency rules. **At most 150 non-blank
+  lines.**
+- \`.opencode/context/contexts.md\` \u2014 subsystem boundaries: for each subsystem,
+  purpose, at most five start-here files, what must not change while working
+  there. **At most 200 lines.**
+- \`.opencode/context/conventions.md\` \u2014 rules to follow before writing code.
+  **At most 150 lines.**
+- \`.opencode/context/workflows.md\` \u2014 runtime behaviour worth tracing. **At most
+  150 lines.**
+- \`.opencode/context/decisions.md\` \u2014 architectural constraints that bind future
+  work. **At most 120 lines.**
+- \`.opencode/context/active.md\` \u2014 work in flight, grouped by the ISO week it was
+  opened. **At most 60 lines.**
+
+The unit is non-blank lines. It is what a reader actually pays for, it bounds an
+entry that wraps to three lines, and the validator can count it exactly. An
+entry count does not bound cost; a token count needs a tokenizer and is
+model-specific. Stay under the cap: consolidate overlapping entries, drop the
+lowest-value provisional ones, and link out. Never pad, never exceed, and never
+answer a budget problem by deleting a binding constraint.
+
+Every file must still answer its charter. An empty or degenerate file is a
+failed run, not a small one.
+
+# Lifecycle \u2014 what expires, on what window, what is exempt
+
+The plugin applies this on every run. Write entries in the shape that lets it.
+
+- \`active.md\`: a finished task (\`[x]\` plus \`finished YYYY-MM-DD\`) is dropped
+  after 7 days. An open task never expires, however old it is.
+- \`architecture.md\`, \`contexts.md\`, \`conventions.md\`, \`workflows.md\`,
+  \`decisions.md\`: a \`[provisional]\` entry is dropped 30 days after its
+  \`verified\` date unless it is re-verified. \`[binding]\` and \`[disputed]\` are
+  exempt: a constraint does not stop binding because it is old, and a
+  disagreement is not resolved by a clock.
+- An entry with no resolvable pointer is never auto-dropped. It is reported as
+  unarchived content. Do not delete it either.
+
+When you re-verify a binding entry, update its \`verified\` date. Age is not a
+reason to drop a constraint; a source that no longer supports it is.
+
+# Point, do not restate
+
+A fact has exactly one home. If the project's own page, README, schema,
+changelog, or source states it, the map cites the page plus section and stops.
+Do not copy a table, a measurement, a list of lengths, a version, or a "was
+refuted" finding into the map. Two copies of a fact WILL drift; one will be
+stale and nothing will notice.
+
+If the map already restates a page and the two disagree, do not simply choose
+one. See "Drift check".
+
+# Drift check \u2014 report, never overwrite
+
+At the end of every run, verify each entry against its pointer:
+
+- Open the cited path and section. If the path or section is gone, mark the
+  entry \`[disputed]\`, keep it, and report the dangling citation.
+- If the source changed after \`verified\`, re-read it. If the entry is still
+  true, update \`verified\`; if it is not, mark it \`[disputed]\`.
+- If the map and a PROJECT PAGE disagree, do not edit the page and do not
+  silently "correct" the map. Neither side is automatically right: in one real
+  case the map was right and the page was stale. Mark \`[disputed]\`, keep both,
+  and report the contradiction with both citations. Only the page's owner
+  resolves it.
+- Source CODE is different: code wins over the map. If the map contradicts code
+  you can read, correct the map and update \`verified\`.
+- Never overwrite a page, a doc, or source code. You only write the map.
+
+The plugin also runs a deterministic drift pass: dangling paths and sections, a
+numeric claim absent from the cited source, a possible negation conflict, and a
+source modified after its \`verified\` date. It reports; it never rewrites and
+never deletes.
+
+# Never the archive
+
+The map is derived. It must never be the only copy of anything. If content has
+no source in the tree \u2014 a retired decision document, a deleted page, a fact that
+exists only in the map \u2014 do not emit it as though it were derived. Keep what is
+already there, mark it \`[disputed]\` if it must stay, and report it loudly as
+unarchived content with no source. Deleting it on regeneration is not allowed:
+it may be the only copy. A sentence like "this is the only place this remains"
+is a defect to report, not a preamble to write.
+
+# Current-state only
+
+Every file you write states only the current arrangement and the reason it
+holds, in the present tense. No "used to", "previously", "before this",
+migration notes or deprecation narrative \u2014 history belongs in the project's
+changelog, not in your map. An absence that is true today is a fact worth
+stating, not a removal worth narrating. When a past state is worth keeping,
+record it briefly in \`changelog.md\` instead.
+
+Never create, modify, or delete anything outside \`.opencode/context/\`. The
+\`edit\` permission enforces this. Do not attempt to work around it with bash.
+
+To look for the map, use \`list\` or \`ls .opencode/context\`. Never use the \`glob\`
+tool for it: \`glob\` does not match hidden directories, so it reports "no files"
+even when the map exists.
+
+# Bootstrap
+
+Trigger: \`.opencode/context/\` does not exist or is empty.
+
+Explore progressively and stop as soon as you have a usable map:
+
+1. README files and any existing architecture or decision documentation.
+2. Project manifests (\`package.json\`, \`pyproject.toml\`, \`go.mod\`, \`Cargo.toml\`,
+   \u2026) for entry points, workspaces, and dependency structure.
+3. The top-level directory structure \u2014 one or two levels. Name what each
+   directory is for.
+4. Framework and build configuration (tsconfig, bundler config, CI, container
+   files) to learn how things are assembled and run.
+5. Application entry points. Read them.
+6. Obvious domain / application / infrastructure boundaries and the interfaces
+   between them.
+7. Only then inspect source selectively \u2014 the files that define the boundaries
+   you found.
+
+You are mapping a city, not auditing every house. Do not attempt to understand
+every file.
+
+Then write the five navigation files within their line budgets, using the entry
+schema above. Also create \`.opencode/context/active.md\` with its heading and no
+tasks. For each significant subsystem, give a short "Start here" list \u2014 at most
+about five canonical files, each with a one-phrase reason. This is the single
+most valuable thing you produce: where an agent should open its editor next.
+
+# Incremental update
+
+Trigger: \`.opencode/context/\` exists and work has just been done here.
+
+1. Start from the files that changed, plus their immediate architectural
+   neighborhood: what they import, who calls them, the boundary they sit on.
+2. Read only the context file(s) those changes could affect.
+3. Default to no edit. A changed file is not a changed fact: comments,
+   formatting, renames of local variables, added tests, dependency bumps, and
+   edits that stay inside one function rarely alter what the map should say.
+   Edit only when the work introduced or revealed information that will
+   materially help a future agent, such as:
+   - a new architectural boundary or module
+   - a new or moved canonical entry point
+   - a changed workflow
+   - a new repository convention
+   - an architectural decision
+   - a new dependency between subsystems
+   - a renamed or relocated subsystem
+   - an invariant not yet recorded in the map
+
+Do not update documentation merely because source files changed. Do not rewrite
+files wholesale. Do not make timestamp-only edits. Do not add a fact that is
+already stated in another context file \u2014 one fact has one home, and the other
+files link to it. If nothing material changed, make no edits and report "no
+update needed".
+
+Every new or changed entry uses the schema above and stays under the file's
+budget. If a file is already over budget, consolidate before adding anything.
+
+Also keep \`.opencode/context/active.md\` current: record work that is in flight,
+and mark a task finished \u2014 with the date it finished \u2014 when it is.
+
+# Task backlog
+
+\`.opencode/context/active.md\` holds the work in flight. It is a rolling window,
+not a history: it answers "what is open, and what just finished".
+
+Format \u2014 one line per task, under the ISO week the task was opened in:
+
+    ## 2026-W43
+
+    - [ ] Ship the release notes \u2014 opened 2026-W43
+    - [x] Fix the flaky test \u2014 opened 2026-W43, finished 2026-10-19
+
+The rules:
+
+- A task that is not marked \`[x]\` is OPEN. An open task is never removed,
+  however old it is.
+- A task is FINISHED when it is marked \`[x]\` AND carries a \`finished\` date.
+  Record the date it actually finished, as \`YYYY-MM-DD\`.
+- The week is \`YYYY-Www\`, Monday to Sunday. \`date +%G-W%V\` prints it.
+- A finished task is dropped once it is more than a week old. The plugin
+  enforces that: record the finished task with its date and let the window close
+  on its own. Do not delete old finished tasks by hand, and do not keep a
+  finished task back to preserve it \u2014 the file is meant to stay small.
+- Never invent a task. Record work that actually happened, and mark a task
+  finished only once it is finished.
+- Keep the file inside the window. If the backlog has grown past a handful of
+  weeks, that is a signal to close finished tasks, not to add sections.
+
+# Minimal exploration
+
+Default shape:
+
+    repository structure
+      \u2192 existing documentation
+      \u2192 relevant entry points
+      \u2192 relevant neighboring modules
+      \u2192 deeper exploration only when necessary
+
+Avoid:
+
+    repository
+      \u2192 every directory
+      \u2192 every file
+      \u2192 every dependency
+      \u2192 every caller
+      \u2192 the whole codebase
+
+Aim for minimum sufficient exploration. A few precise reads beat a broad sweep.
+When updating after a task, the changed files and their immediate neighborhood
+are almost always enough.
+
+# Stay inside this project
+
+The target repository is the only thing you are mapping. Everything outside its
+root is out of scope and is blocked:
+
+- Do not read OpenCode's own configuration, prompts, plugins, session storage,
+  or logs. They are not part of the project and hold no project facts.
+- Do not inspect other repositories, home directories, or system paths.
+- Do not treat a blocked tool call as a puzzle to solve. If a read or command is
+  refused, use the project's own files instead and move on.
+- Do not search the filesystem root or use \`grep -r /\`.
+
+# Source of truth
+
+Code wins over the map. If the map disagrees with code you can read:
+
+1. Investigate the discrepancy.
+2. Trust the code.
+3. Correct the map and update \`verified\`.
+
+A project page is not the same: it may be the stale side. A map/page
+disagreement is REPORTED and kept as \`[disputed]\`, never silently resolved. You
+never edit source code or a project page \u2014 you only write the map.
+
+# Confidence
+
+Do not record assumptions as facts. The one representation of uncertainty is the
+\`[provisional]\` marker; do not add a second dialect such as a blockquote or
+"Confidence: low". Intent is the most common thing code cannot tell you: a single
+\`export { app }\` does not prove a test seam was intended, and one carefully
+written expression does not prove a repository convention. Mark those
+\`[provisional]\` or leave them out.
+
+If a fact cannot be established with reasonable effort, omit it. A short map
+that is true beats a long map that is partly guesswork.
+
+# Keep it small
+
+The context system exists to REDUCE context consumption. Never let the map grow
+into an encyclopedia. Never write:
+
+- file inventories or directory listings
+- copied or paraphrased source code
+- large API descriptions
+- content duplicated from the project's own docs \u2014 link to them instead
+- tables, fenced code blocks, or copied measurements
+- generated documentation
+- exhaustive class or function lists
+- the same finding restated in several files \u2014 state a fact once, in the file
+  that owns it, and let the others point at it
+- generic programming advice that would be true in any repository
+
+Write conclusions, not inventories. Prefer a statement like "\`OrderService\` is
+the application boundary for order mutations" over a description of every
+method it exposes.
+
+If a file grows past its budget, consolidate: merge overlapping entries, drop
+the lowest-value provisional ones, and link out to authoritative project docs.
+Never drop a binding constraint to make room.
+
+# Review mode
+
+Trigger: an explicit review (see the \`context-review\` command).
+
+Audit the map files and the backlog for:
+
+- schema \u2014 every entry has one marker, at most three lines, a pointer, and a
+  \`verified\` date
+- budget \u2014 every file is within its non-blank-line cap
+- stale information \u2014 verify claims against the code and the cited page
+- contradictions between files, or between the map and a page \u2014 report them;
+  mark \`[disputed]\`; never silently pick a side
+- dangling pointers \u2014 every cited path and \xA7section exists
+- unarchived content \u2014 an entry with no source in the tree; report it, keep it
+- restatement \u2014 a table, a fenced block, or a long verbatim span from a page
+- duplicated information \u2014 one canonical place per fact
+- missing canonical entry points for significant subsystems
+- unsupported assumptions \u2014 anything that is not \`[binding]\` or \`[disputed]\`
+  should be \`[provisional]\`
+- backlog tasks that are finished but carry no date \u2014 the retention window
+  cannot age those out, so they stay forever
+
+Fix problems only in the files you own. Never modify source code or a project
+page during a review. Report what you found, what you fixed, what you left as
+\`[disputed]\`, and what you could not verify.
+
+# Reporting
+
+Finish with a short report:
+
+- what you inspected
+- what you created or changed, and why it matters for future agents
+- what you deliberately left out
+- every map/page contradiction, with both citations; say you did not resolve it
+- any unarchived content that has no source in the tree
+- what the lifecycle removed and which file it came from
+- anything you found that contradicts the code or the existing docs
+`;
+
 // src/agents.ts
 var POOLED_BASES = ["explore", "implement", "context"];
 var AGENTS = {
@@ -1160,250 +1559,7 @@ if the blocker is understanding rather than execution, report that instead.`,
     "description": "Repository cartographer and memory maintainer. Bootstraps and incrementally maintains .opencode/context/ (architecture, contexts, conventions, workflows, decisions) as a small navigation map for future agents, and keeps .opencode/context/active.md \u2014 the active backlog of work in flight, grouped by week. Runs automatically after sessions that changed files; can also be invoked with /context-init, /context-update, /context-review. Never use it for general coding tasks.",
     "mode": "subagent",
     "temperature": 0.1,
-    prompt: `# Role
-
-You are the repository cartographer and memory maintainer. You are not a coding
-agent. You maintain exactly one thing: the repository context map in
-\`.opencode/context/\`.
-
-The context map is a lightweight navigation index that future agents read
-before exploring. It exists to answer "what should I look at first?" \u2014 never
-"tell me everything about the repository". Source code is authoritative; the
-map is a derived index of it.
-
-# Owned files
-
-You own exactly these files and nothing else:
-
-- \`.opencode/context/architecture.md\` \u2014 high-level architecture, major layers,
-  boundaries, important entry points, dependency rules. Target 50\u2013150 lines.
-- \`.opencode/context/contexts.md\` \u2014 the major subsystems/modules. For each:
-  purpose, canonical start-here files, boundaries, dependencies, and what must
-  not be changed while working there. Target 50\u2013200 lines.
-- \`.opencode/context/conventions.md\` \u2014 repository-specific conventions:
-  naming, patterns, error handling, testing, persistence, framework rules.
-  Target 30\u2013150 lines.
-- \`.opencode/context/workflows.md\` \u2014 the few runtime flows worth tracing.
-  Target 30\u2013150 lines.
-- \`.opencode/context/decisions.md\` \u2014 architectural decisions discovered
-  during work that are not already recorded in the project's own decision
-  log. Concise; variable length.
-- \`.opencode/context/active.md\` \u2014 the active backlog: work in flight, grouped
-  by the week it was opened. Not part of the navigation map; it is described
-  under "Task backlog" below.
-
-# Current-state only
-
-Every file you write states only the current arrangement and the reason it
-holds, in the present tense. No "used to", "previously", "before this",
-migration notes or deprecation narrative \u2014 history belongs in the project's
-changelog, not in your map. An absence that is true today is a fact worth
-stating, not a removal worth narrating. When a past state is worth keeping,
-record it briefly in \`changelog.md\` instead.
-
-Never create, modify, or delete anything outside \`.opencode/context/\`. The
-\`edit\` permission enforces this. Do not attempt to work around it with bash.
-
-To look for the map, use \`list\` or \`ls .opencode/context\`. Never use the
-\`glob\` tool for it: \`glob\` does not match hidden directories, so it reports
-"no files" even when the map exists.
-
-# Bootstrap
-
-Trigger: \`.opencode/context/\` does not exist or is empty.
-
-Explore progressively and stop as soon as you have a usable map:
-
-1. README files and any existing architecture or decision documentation.
-2. Project manifests (\`package.json\`, \`pyproject.toml\`, \`go.mod\`, \`Cargo.toml\`,
-   \u2026) for entry points, workspaces, and dependency structure.
-3. The top-level directory structure \u2014 one or two levels. Name what each
-   directory is for.
-4. Framework and build configuration (tsconfig, bundler config, CI, container
-   files) to learn how things are assembled and run.
-5. Application entry points. Read them.
-6. Obvious domain / application / infrastructure boundaries and the
-   interfaces between them.
-7. Only then inspect source selectively \u2014 the files that define the boundaries
-   you found.
-
-You are mapping a city, not auditing every house. Do not attempt to
-understand every file.
-
-Then write the five files. Also create \`.opencode/context/active.md\` with its
-heading and no tasks. For each significant subsystem, give a short
-"Start here" list \u2014 at most about five canonical files, each with a one-phrase
-reason. This is the single most valuable thing you produce: where an agent
-should open its editor next.
-
-# Incremental update
-
-Trigger: \`.opencode/context/\` exists and work has just been done here.
-
-1. Start from the files that changed, plus their immediate architectural
-   neighborhood: what they import, who calls them, the boundary they sit on.
-2. Read only the context file(s) those changes could affect.
-3. Default to no edit. A changed file is not a changed fact: comments,
-   formatting, renames of local variables, added tests, dependency bumps, and
-   edits that stay inside one function rarely alter what the map should say.
-   Edit only when the work introduced or revealed information that will
-   materially help a future agent, such as:
-   - a new architectural boundary or module
-   - a new or moved canonical entry point
-   - a changed workflow
-   - a new repository convention
-   - an architectural decision
-   - a new dependency between subsystems
-   - a renamed or relocated subsystem
-   - an invariant not yet recorded in the map
-
-Do not update documentation merely because source files changed. Do not
-rewrite files wholesale. Do not make timestamp-only edits. Do not add a fact
-that is already stated in another context file \u2014 one fact has one home, and
-the other files link to it. If nothing material changed, make no edits and
-report "no update needed".
-
-Also keep \`.opencode/context/active.md\` current: record work that is in
-flight, and mark a task finished \u2014 with the date it finished \u2014 when it is.
-
-# Task backlog
-
-\`.opencode/context/active.md\` holds the work in flight. It is a rolling
-window, not a history: it answers "what is open, and what just finished".
-
-Format \u2014 one line per task, under the ISO week the task was opened in:
-
-    ## 2026-W43
-
-    - [ ] Ship the release notes \u2014 opened 2026-W43
-    - [x] Fix the flaky test \u2014 opened 2026-W43, finished 2026-10-19
-
-The rules:
-
-- A task that is not marked \`[x]\` is OPEN. An open task is never removed,
-  however old it is.
-- A task is FINISHED when it is marked \`[x]\` AND carries a \`finished\`
-  date. Record the date it actually finished, as \`YYYY-MM-DD\`.
-- The week is \`YYYY-Www\`, Monday to Sunday. \`date +%G-W%V\` prints it.
-- A finished task is dropped once it is more than a week old. The plugin
-  enforces that: record the finished task with its date and let the window
-  close on its own. Do not delete old finished tasks by hand, and do not
-  keep a finished task back to preserve it \u2014 the file is meant to stay
-  small.
-- Never invent a task. Record work that actually happened, and mark a task
-  finished only once it is finished.
-- Keep the file inside the window. If the backlog has grown past a handful
-  of weeks, that is a signal to close finished tasks, not to add sections.
-
-# Minimal exploration
-
-Default shape:
-
-    repository structure
-      \u2192 existing documentation
-      \u2192 relevant entry points
-      \u2192 relevant neighboring modules
-      \u2192 deeper exploration only when necessary
-
-Avoid:
-
-    repository
-      \u2192 every directory
-      \u2192 every file
-      \u2192 every dependency
-      \u2192 every caller
-      \u2192 the whole codebase
-
-Aim for minimum sufficient exploration. A few precise reads beat a broad
-sweep. When updating after a task, the changed files and their immediate
-neighborhood are almost always enough.
-
-# Stay inside this project
-
-The target repository is the only thing you are mapping. Everything outside its
-root is out of scope and is blocked:
-
-- Do not read OpenCode's own configuration, prompts, plugins, session storage,
-  or logs. They are not part of the project and hold no project facts.
-- Do not inspect other repositories, home directories, or system paths.
-- Do not treat a blocked tool call as a puzzle to solve. If a read or command
-  is refused, use the project's own files instead and move on.
-- Do not search the filesystem root or use \`grep -r /\`.
-
-# Source of truth
-
-Source code wins. If the context map disagrees with the code:
-
-1. Investigate the discrepancy.
-2. Trust the source.
-3. Correct the map.
-
-Never propagate stale context. Never edit source code to match the map \u2014 you
-never edit source code at all.
-
-# Confidence
-
-Do not record assumptions as facts. If something is uncertain, mark it inline:
-
-> Confidence: low \u2014 inferred from \`src/foo.ts\` naming only
-
-Intent is the most common thing code cannot tell you. A single \`export { app }\`
-does not prove a test seam was intended, and one carefully written expression
-does not prove a repository convention. Mark those inferences or leave them
-out.
-
-If a fact cannot be established with reasonable effort, omit it. A short map
-that is true beats a long map that is partly guesswork.
-
-# Keep it small
-
-The context system exists to REDUCE context consumption. Never let the map
-grow into an encyclopedia. Do not write:
-
-- file inventories or directory listings
-- copied or paraphrased source code
-- large API descriptions
-- content duplicated from the project's own docs \u2014 link to them instead
-- generated documentation
-- exhaustive class or function lists
-- the same finding restated in several files \u2014 state a fact once, in the file
-  that owns it, and let the others point at it
-- generic programming advice that would be true in any repository
-
-Write conclusions, not inventories. Prefer a statement like
-"\`OrderService\` is the application boundary for order mutations" over a
-description of every method it exposes.
-
-If a file grows past its target, consolidate: merge overlapping entries, drop
-the lowest-value ones, and link out to authoritative project docs.
-
-# Review mode
-
-Trigger: an explicit review (see the \`context-review\` command).
-
-Audit the map files and the backlog for:
-
-- stale information \u2014 verify claims against the code
-- contradictions between files, or between the map and the code
-- excessive size \u2014 consolidate toward the targets above
-- duplicated information \u2014 one canonical place per fact
-- missing canonical entry points for significant subsystems
-- unsupported assumptions \u2014 anything unmarked that you cannot verify
-- backlog tasks that are finished but carry no date \u2014 the retention window
-  cannot age those out, so they stay forever
-
-Fix problems only in the files you own. Never modify source code during a
-review. Report what you found, what you fixed, and what you could not
-verify.
-
-# Reporting
-
-Finish with a short report:
-
-- what you inspected
-- what you created or changed, and why it matters for future agents
-- what you deliberately left out
-- anything you found that contradicts the code or the existing docs`,
+    prompt: CARTOGRAPHER_PROMPT,
     permission: {
       "read": "allow",
       "glob": "allow",
@@ -1553,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.`,
@@ -1624,11 +1780,14 @@ your system prompt.
 Otherwise follow the bootstrap procedure in your system prompt: progressive
 exploration (README \u2192 existing docs \u2192 manifests \u2192 top-level structure \u2192 build
 and framework config \u2192 entry points \u2192 selective source), then write the five
-context files inside their size targets. Also create
-\`.opencode/context/active.md\` with its heading and no tasks.
+context files inside their line budgets, using the entry schema (provenance
+marker, rule of at most three lines, \`\u2014 See <path>[ \xA7Section] (verified
+YYYY-MM-DD)\`). Also create \`.opencode/context/active.md\` with its heading and no
+tasks.
 
-Remember: write conclusions, not inventories. Link to the project's existing
-documentation instead of duplicating it.
+Remember: write conclusions, not inventories. Point at the project's existing
+documentation instead of restating it. Run the drift pass and report a
+contradiction rather than silently choosing a side.
 
 Report what you created or updated, what you deliberately left out, and
 anything that contradicts the code or existing docs.`
@@ -1654,7 +1813,11 @@ or an invariant not yet recorded.
 
 Do not edit documentation just because source files changed. No
 timestamp-only edits. If nothing material changed, make no edits and report
-"no update needed".`
+"no update needed".
+
+Every new or changed entry uses the schema in your system prompt and stays
+under the file's line budget. If a file is already over budget, consolidate
+before adding.`
   },
   "context-review": {
     description: "Audit .opencode/context/ for staleness, contradictions, excess size, duplication, and missing entry points.",
@@ -1662,20 +1825,29 @@ timestamp-only edits. If nothing material changed, make no edits and report
     subtask: true,
     template: `Context review.
 
-Everything outside \`.opencode/context/\` is read-only for this run. Do not
-modify source code under any circumstances.
+Follow the review procedure and entry schema in your system prompt. Everything
+outside \`.opencode/context/\` is read-only for this run. Do not modify source
+code under any circumstances.
 
 Audit the context files and the backlog for:
 
-- stale information \u2014 verify claims against the actual code
-- contradictions between context files, or between the map and the code
-- excessive size \u2014 consolidate toward the per-file targets in your system
-  prompt
+- schema \u2014 every entry has one provenance marker, at most three lines, a
+  pointer, and a \`(verified YYYY-MM-DD)\` date
+- budget \u2014 every file is within its non-blank-line cap; consolidate rather
+  than exceed it
+- stale information \u2014 verify claims against the actual code and the cited page
+- contradictions between context files, or between the map and a page \u2014 mark
+  \`[disputed]\` and report both sides; never silently prefer one
+- dangling pointers \u2014 every cited path and \xA7section must exist
+- unarchived content \u2014 an entry with no source in the tree; report it and keep
+  it, because it may be the only copy
+- restatement \u2014 a table, a fenced block, or a long verbatim span copied from a
+  page
 - duplicated information \u2014 one canonical place per fact; link to the
   project's own docs rather than restating them
 - missing canonical entry points for significant subsystems
-- unsupported assumptions \u2014 anything stated as fact that you cannot verify,
-  or that lacks a confidence marker
+- unsupported assumptions \u2014 anything that is not \`[binding]\` or \`[disputed]\`
+  should be \`[provisional]\`
 - backlog tasks that are finished but carry no date \u2014 the retention window
   cannot age those out, so they stay forever
 
@@ -1699,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
@@ -1736,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.
 
@@ -1765,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"
@@ -1816,9 +1993,9 @@ function compareSemver(a, b) {
   }
   return 0;
 }
-function readInstalledVersion(packageRoot, read = (path4) => {
+function readInstalledVersion(packageRoot, read = (path5) => {
   try {
-    return readFileSync3(path4, "utf8");
+    return readFileSync3(path5, "utf8");
   } catch {
     return void 0;
   }
@@ -1876,17 +2053,17 @@ async function fetchLatest(fetchImpl = fetch, timeoutMs = FETCH_TIMEOUT_MS) {
     clearTimeout(timer);
   }
 }
-function readState(path4 = STATE_PATH) {
+function readState(path5 = STATE_PATH) {
   try {
-    return JSON.parse(readFileSync3(path4, "utf8"));
+    return JSON.parse(readFileSync3(path5, "utf8"));
   } catch {
     return {};
   }
 }
-function writeState(state2, path4 = STATE_PATH) {
+function writeState(state2, path5 = STATE_PATH) {
   try {
-    mkdirSync2(dirname2(path4), { recursive: true });
-    writeFileSync2(path4, JSON.stringify(state2));
+    mkdirSync2(dirname2(path5), { recursive: true });
+    writeFileSync2(path5, JSON.stringify(state2));
   } catch {
   }
 }
@@ -1899,39 +2076,39 @@ var isProcessAlive = (pid) => {
     return error.code === "EPERM";
   }
 };
-function acquireLock(path4 = LOCK_PATH, now = Date.now()) {
+function acquireLock(path5 = LOCK_PATH, now = Date.now()) {
   const claim = () => {
-    const fd = openSync(path4, "wx");
+    const fd = openSync(path5, "wx");
     writeSync(fd, String(process.pid));
     closeSync(fd);
     return () => {
       try {
-        unlinkSync2(path4);
+        unlinkSync2(path5);
       } catch {
       }
     };
   };
   try {
-    mkdirSync2(dirname2(path4), { recursive: true });
+    mkdirSync2(dirname2(path5), { recursive: true });
     return claim();
   } catch {
     let orphaned = false;
     try {
-      const pid = Number.parseInt(readFileSync3(path4, "utf8").trim(), 10);
+      const pid = Number.parseInt(readFileSync3(path5, "utf8").trim(), 10);
       orphaned = !Number.isFinite(pid) || pid <= 0 || !isProcessAlive(pid);
     } catch {
       orphaned = true;
     }
     if (!orphaned) {
       try {
-        orphaned = now - statSync2(path4).mtimeMs > LOCK_STALE_MS;
+        orphaned = now - statSync2(path5).mtimeMs > LOCK_STALE_MS;
       } catch {
         orphaned = true;
       }
     }
     if (!orphaned) return void 0;
     try {
-      unlinkSync2(path4);
+      unlinkSync2(path5);
     } catch {
       return void 0;
     }
@@ -2058,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;
@@ -2070,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((resolve3) => {
+    const deadline = new Promise((resolve5) => {
       timer = setTimeout(() => {
         timedOut = true;
         void client.session.abort({ path: { id: created }, query: { directory } }).catch(() => {
         });
-        resolve3(void 0);
+        resolve5(void 0);
       }, timeoutMs);
     });
     const answer = client.session.prompt({
@@ -2114,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);
@@ -2212,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);
@@ -2249,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();
@@ -2304,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`,
@@ -2372,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;
           }
@@ -2423,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.`;
@@ -2473,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.`);
@@ -2558,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`);
@@ -2566,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`, {
@@ -2578,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 {
@@ -2611,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`);
@@ -2654,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 });
@@ -2712,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));
@@ -2729,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({
@@ -2754,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);
@@ -2780,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:",
@@ -2823,9 +3139,9 @@ two ordered passes in slot order: pass 1 fills each slot to its weight, pass 2 t
 });
 
 // src/plugins/context-autoupdate.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // src/lib/active-backlog.ts
 var ACTIVE_BACKLOG_FILE = "active.md";
@@ -2922,10 +3238,498 @@ var normalizeBacklog = (text, now = Date.now()) => {
         continue;
       }
     }
-    kept.push(entry);
+    kept.push(entry);
+  }
+  return { text: renderBacklog(kept), removed };
+};
+
+// src/lib/map-schema.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4, statSync as statSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import * as path from "node:path";
+var PROVISIONAL_DAYS = 30;
+var MAP_SPECS = [
+  {
+    file: "architecture.md",
+    charter: "cross-subsystem structure: layers, boundaries, entry points, dependency rules",
+    budget: 150,
+    minEntries: 4,
+    kind: "entries",
+    provisionalDays: PROVISIONAL_DAYS,
+    sectionRequired: true
+  },
+  {
+    file: "contexts.md",
+    charter: "subsystem boundaries: purpose, start-here files, what must not change",
+    budget: 200,
+    minEntries: 3,
+    kind: "entries",
+    provisionalDays: PROVISIONAL_DAYS,
+    sectionRequired: true
+  },
+  {
+    file: "conventions.md",
+    charter: "rules to follow before writing code",
+    budget: 150,
+    minEntries: 3,
+    kind: "entries",
+    provisionalDays: PROVISIONAL_DAYS,
+    sectionRequired: true
+  },
+  {
+    file: "workflows.md",
+    charter: "runtime behaviour worth tracing",
+    budget: 150,
+    minEntries: 2,
+    kind: "entries",
+    provisionalDays: PROVISIONAL_DAYS,
+    sectionRequired: true
+  },
+  {
+    file: "decisions.md",
+    charter: "architectural constraints that bind future work",
+    budget: 120,
+    minEntries: 1,
+    kind: "entries",
+    provisionalDays: PROVISIONAL_DAYS,
+    sectionRequired: true
+  },
+  {
+    file: ACTIVE_BACKLOG_FILE,
+    charter: "work in flight, grouped by the ISO week it was opened",
+    budget: 60,
+    minEntries: 0,
+    kind: "backlog",
+    provisionalDays: PROVISIONAL_DAYS,
+    sectionRequired: false
+  }
+];
+var MAP_SPEC_BY_FILE = new Map(MAP_SPECS.map((spec) => [spec.file, spec]));
+var MAP_FILES = MAP_SPECS.map((spec) => spec.file);
+var NAVIGATION_FILES = MAP_SPECS.filter((spec) => spec.kind === "entries").map((spec) => spec.file);
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var ENTRY_START = /^([-*+])\s+\[(binding|provisional|disputed)\]\s+(.*)$/i;
+var CONTINUATION = /^\s{2,}\S/;
+var LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s+/;
+var FENCE = /^\s*(?:```|~~~)/;
+var TABLE_ROW = /^\s*\|.*\|\s*$/;
+var TABLE_SEPARATOR = /^\s*\|[\s:|-]*-{3,}[\s:|-]*\|\s*$/;
+var VERIFIED = /\(verified\s+(\d{4}-\d{2}-\d{2})\)\s*$/i;
+var POINTER = /(?:—|–|→|->)\s*See\s+`([^`\n]+)`(?:\s*§\s*([^()\n]+?))?(?:\s*\(verified\s+(\d{4}-\d{2}-\d{2})\))?\s*$/i;
+var DECISION_RECORD = /^\s*(?:#{1,6}\s*)?(?:\*\*)?(Context|Decision|Consequences|Alternatives|Status|Trade-?offs|Rationale)(?:\*\*)?\s*(?::|$)/im;
+var ARCHIVE_LANGUAGE = /\b(?:archive\s+of\s+record|this\s+(?:is|file\s+is|map\s+is)\s+the\s+only\s+(?:copy|record)|the\s+only\s+place\s+[^.\n]{0,80}?\b(?:remains|survives)\b|the\s+only\s+(?:copy|record)\s+[^.\n]{0,80}?\b(?:remains|survives|is\s+kept)\b|(?:survives|remains|is\s+kept)\s+only\s+here|no\s+longer\s+exists\s+(?:in|anywhere)|exists\s+only\s+(?:in|here))\b/i;
+var isCalendarDate2 = (value) => {
+  const at = Date.parse(`${value}T00:00:00Z`);
+  return Number.isFinite(at) && new Date(at).toISOString().slice(0, 10) === value;
+};
+var normalizeHeading = (value) => value.toLowerCase().replace(/[`*_]/g, "").replace(/^\s*\d+(?:\.\d+)*[.)]?\s*/, "").replace(/[^a-z0-9]+/g, " ").trim();
+var normalizeRule = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+var truncate = (value, max = 90) => value.length <= max ? value : `${value.slice(0, max - 1)}\u2026`;
+var parseMapEntries = (text) => {
+  const lines = text.split(/\r?\n/);
+  const entries = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (FENCE.test(lines[i])) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const start = ENTRY_START.exec(lines[i]);
+    if (!start) continue;
+    const bodyLines = [start[3]];
+    let j = i + 1;
+    while (j < lines.length && CONTINUATION.test(lines[j]) && !FENCE.test(lines[j])) {
+      bodyLines.push(lines[j].trim());
+      j++;
+    }
+    const body = bodyLines.join("\n");
+    const flat = body.replace(/\s+/g, " ").trim();
+    const pointerMatch = POINTER.exec(flat);
+    const verifiedMatch = VERIFIED.exec(flat);
+    const pointer = pointerMatch?.[1]?.trim();
+    const section = pointerMatch?.[2]?.trim() || void 0;
+    const verified = pointerMatch?.[3] ?? verifiedMatch?.[1];
+    const rule = flat.replace(POINTER, "").replace(VERIFIED, "").trim();
+    entries.push({
+      startLine: i,
+      endLine: j,
+      marker: start[2].toLowerCase(),
+      body,
+      rule,
+      lineCount: bodyLines.filter((line) => line.trim()).length,
+      ...pointer ? { pointer } : {},
+      ...section ? { section } : {},
+      ...verified ? { verified } : {}
+    });
+    i = j - 1;
+  }
+  return entries;
+};
+var stripLineSuffix = (pointer) => pointer.replace(/[\\/]$/, "").replace(/(?::\d+(?:-\d+)?|#L\d+(?:-L?\d+)?)$/i, "");
+var headingOf = (line) => {
+  const match = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+  if (!match) return void 0;
+  return { level: match[1].length, text: match[2] };
+};
+var sectionText = (text, section) => {
+  const lines = text.split(/\r?\n/);
+  const wanted = normalizeHeading(section);
+  if (!wanted) return void 0;
+  for (let i = 0; i < lines.length; i++) {
+    const heading = headingOf(lines[i]);
+    if (!heading) continue;
+    const normalized = normalizeHeading(heading.text);
+    if (!(normalized === wanted || normalized.includes(wanted) || wanted.includes(normalized))) continue;
+    let end = lines.length;
+    for (let j = i + 1; j < lines.length; j++) {
+      const next = headingOf(lines[j]);
+      if (next && next.level <= heading.level) {
+        end = j;
+        break;
+      }
+    }
+    return lines.slice(i + 1, end).join("\n");
+  }
+  return void 0;
+};
+var resolvePointer = (root, pointer, section) => {
+  const cleaned = stripLineSuffix(pointer.trim().replace(/^`|`$/g, ""));
+  if (!cleaned) return { exists: false };
+  const absolute = path.resolve(root, cleaned);
+  const rootWithSep = root.endsWith(path.sep) ? root : root + path.sep;
+  if (absolute !== root && !absolute.startsWith(rootWithSep)) return { exists: false };
+  let stat;
+  try {
+    stat = statSync3(absolute);
+  } catch {
+    return { exists: false };
+  }
+  if (!stat.isFile()) return { exists: false };
+  let text;
+  try {
+    if (stat.size <= 512 * 1024) text = readFileSync4(absolute, "utf8");
+  } catch {
+    text = void 0;
+  }
+  if (section && text !== void 0) {
+    const found = sectionText(text, section);
+    return {
+      absolute,
+      exists: true,
+      mtimeMs: stat.mtimeMs,
+      sectionFound: found !== void 0,
+      ...found !== void 0 ? { sectionText: found } : {},
+      sourceText: found ?? text
+    };
+  }
+  return { absolute, exists: true, mtimeMs: stat.mtimeMs, ...text !== void 0 ? { sourceText: text } : {} };
+};
+var words = (value) => value.toLowerCase().replace(/[`*_[\]()]/g, " ").split(/[^a-z0-9]+/).filter((word) => word.length > 0);
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "from",
+  "are",
+  "was",
+  "were",
+  "has",
+  "have",
+  "had",
+  "not",
+  "never",
+  "none",
+  "into",
+  "onto",
+  "than",
+  "then",
+  "when",
+  "where",
+  "which",
+  "what",
+  "who",
+  "will",
+  "would",
+  "can",
+  "could",
+  "must",
+  "may",
+  "might",
+  "its",
+  "their",
+  "your",
+  "our",
+  "you",
+  "they",
+  "them",
+  "there",
+  "here",
+  "only",
+  "also",
+  "but",
+  "all",
+  "any",
+  "each",
+  "every",
+  "more",
+  "most",
+  "some",
+  "such",
+  "one",
+  "two",
+  "use",
+  "used",
+  "using",
+  "via",
+  "per",
+  "out",
+  "own"
+]);
+var contentWords = (value) => words(value).filter((word) => word.length >= 4 && !STOPWORDS.has(word));
+var ngrams = (values, size) => {
+  const out = /* @__PURE__ */ new Set();
+  for (let i = 0; i + size <= values.length; i++) out.add(values.slice(i, i + size).join(" "));
+  return out;
+};
+var hasNegation = (value) => /\b(?:not|never|none|no\s+longer|refuted|unsupported|absent|missing|removed|without)\b/i.test(value);
+var STATE_AUXILIARY = /\b(?:is|are|was|were|has|have|had|does|do|can|could)\b/i;
+var numbersIn = (value) => (value.match(/\b\d+(?:[.,]\d+)?\b/g) ?? []).map((number) => number.replace(/,/g, ""));
+var sharesVerbatimRun = (rule, source) => {
+  const entryWords = words(rule);
+  if (entryWords.length < 12) return false;
+  const sourceGrams = ngrams(words(source), 12);
+  for (const gram of ngrams(entryWords, 12)) if (sourceGrams.has(gram)) return true;
+  return false;
+};
+var possibleNegationConflict = (rule, source) => {
+  if (hasNegation(rule)) return void 0;
+  const entryWords = new Set(contentWords(rule));
+  if (entryWords.size < 3) return void 0;
+  const sentences = source.split(/(?:[.!?]\s+|\n+)/);
+  for (const sentence of sentences) {
+    if (!hasNegation(sentence) || !STATE_AUXILIARY.test(sentence)) continue;
+    const sentenceWords = new Set(contentWords(sentence));
+    if (sentenceWords.size === 0) continue;
+    let overlap = 0;
+    for (const word of entryWords) if (sentenceWords.has(word)) overlap++;
+    const ratio = overlap / Math.min(entryWords.size, sentenceWords.size);
+    if (overlap >= 3 && ratio >= 0.5) return truncate(sentence.trim());
+  }
+  return void 0;
+};
+var invalidNumbers = (rule, source) => {
+  const claimed = [...new Set(numbersIn(rule))];
+  if (claimed.length === 0) return [];
+  const sourceNumbers = new Set(numbersIn(source));
+  return claimed.filter((number) => !sourceNumbers.has(number));
+};
+var validateMapText = (spec, text, options) => {
+  const violations = [];
+  const lines = text.split(/\r?\n/);
+  const nonBlank = lines.filter((line) => line.trim()).length;
+  const push = (kind, detail, line) => violations.push({ file: spec.file, kind, detail, ...line !== void 0 ? { line: line + 1 } : {} });
+  if (nonBlank === 0) push("charter", `empty file; charter is ${spec.charter}`);
+  if (nonBlank > spec.budget) {
+    push("budget", `${nonBlank} non-blank lines exceeds the ${spec.budget}-line budget; consolidate, do not pad`);
+  }
+  if (spec.kind === "backlog") {
+    if (!text.startsWith("# ")) push("charter", "active backlog must start with a top-level heading");
+    return { spec, lines: nonBlank, entries: [], violations };
+  }
+  const entries = parseMapEntries(text);
+  let inFence = false;
+  let tableReported = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (FENCE.test(lines[i])) {
+      if (!inFence) push("restatement", "fenced code block; the map cites the file that owns the code, it does not copy it", i);
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && !tableReported && (TABLE_ROW.test(lines[i]) || TABLE_SEPARATOR.test(lines[i]))) {
+      push("restatement", "table; a table belongs on the page that owns it, not in the map", i);
+      tableReported = true;
+    }
+  }
+  const record = DECISION_RECORD.exec(text);
+  if (record) {
+    push("schema", `decision-record block (${record[1]}); state only the operative constraint and its pointer`);
+  }
+  if (ARCHIVE_LANGUAGE.test(text)) {
+    push("archive", "the map claims to be an archive or the only copy; derived content must never be the archive of record");
+  }
+  const entryStarts = new Set(entries.map((entry) => entry.startLine));
+  inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (FENCE.test(lines[i])) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && LIST_ITEM.test(lines[i]) && !entryStarts.has(i)) {
+      push("schema", "unmarked list item; every entry starts with - [binding], - [provisional] or - [disputed]", i);
+    }
+  }
+  let binding = 0;
+  for (const entry of entries) {
+    const line = entry.startLine;
+    if (entry.marker === "binding") binding++;
+    if (entry.lineCount > 3) {
+      push("schema", `entry is ${entry.lineCount} lines; the rule must fit in one to three`, line);
+    }
+    if (!entry.verified) {
+      push("schema", "entry has no (verified YYYY-MM-DD); the lifecycle and drift checks need it", line);
+    } else if (!isCalendarDate2(entry.verified)) {
+      push("schema", `verified date ${entry.verified} is not a real calendar date`, line);
+    } else if (Date.parse(`${entry.verified}T00:00:00Z`) > (options.now ?? Date.now()) + DAY_MS2) {
+      push("schema", `verified date ${entry.verified} is more than a day in the future`, line);
+    }
+    if (!entry.pointer) {
+      push("schema", "entry has no `\u2014 See <path>` pointer; a fact with no home is not a map entry", line);
+      push("unarchived", "content has no resolvable source in the tree; report it, do not emit it as derived", line);
+      continue;
+    }
+    if (spec.sectionRequired && /\.md$/i.test(stripLineSuffix(entry.pointer)) && !entry.section) {
+      push("schema", `page citation \`${entry.pointer}\` needs a \xA7section; a page is cited, not restated`, line);
+    }
+    const resolved = resolvePointer(options.root, entry.pointer, entry.section);
+    if (!resolved.exists) {
+      push("dangling", `cites \`${entry.pointer}\`, which does not exist in the tree`, line);
+      push("unarchived", `no source for \`${entry.pointer}\`; keep the text and report it, never delete it`, line);
+      continue;
+    }
+    if (entry.section && resolved.sectionFound === false) {
+      push("drift", `cites \xA7${entry.section} in \`${entry.pointer}\`, but that section no longer exists`, line);
+      continue;
+    }
+    if (resolved.mtimeMs !== void 0 && entry.verified) {
+      const modified = new Date(resolved.mtimeMs).toISOString().slice(0, 10);
+      if (modified > entry.verified) {
+        push("drift", `\`${entry.pointer}\` changed on ${modified}, after this entry was verified on ${entry.verified}; re-verify it`, line);
+      }
+    }
+    if (resolved.sourceText !== void 0) {
+      const missing = invalidNumbers(entry.rule, resolved.sourceText);
+      if (missing.length > 0) {
+        push("drift", `numeric claim(s) ${missing.join(", ")} not found in \`${entry.pointer}\`; the map and the source may disagree`, line);
+      }
+      if (sharesVerbatimRun(entry.rule, resolved.sourceText)) {
+        push("restatement", `contains a long verbatim span from \`${entry.pointer}\`; cite the section instead`, line);
+      }
+      const conflict = possibleNegationConflict(entry.rule, resolved.sourceText);
+      if (conflict) {
+        push("drift", `possible contradiction with \`${entry.pointer}\`: "${conflict}"; verify, do not silently overwrite either side`, line);
+      }
+    }
+  }
+  if (entries.length < spec.minEntries) {
+    push("charter", `${entries.length} entr${entries.length === 1 ? "y" : "ies"} is degenerate for ${spec.charter}`);
+  } else if (entries.length > 0 && binding === 0) {
+    push("charter", "every entry is provisional or disputed; a navigation file must carry at least one binding constraint");
+  }
+  return { spec, lines: nonBlank, entries, violations };
+};
+var normalizeMapText = (spec, text, options = {}) => {
+  const now = options.now ?? Date.now();
+  if (spec.kind === "backlog") {
+    const result = normalizeBacklog(text, now);
+    return {
+      text: result.text,
+      removed: result.removed.map((title) => ({ line: 0, text: title })),
+      kept: 0
+    };
+  }
+  const entries = parseMapEntries(text);
+  const drop = /* @__PURE__ */ new Set();
+  const removed = [];
+  for (const entry of entries) {
+    if (entry.marker !== "provisional") continue;
+    if (!entry.verified || !entry.pointer) continue;
+    if (options.canResolve && !options.canResolve(entry.pointer, entry.section)) continue;
+    const at = Date.parse(`${entry.verified}T00:00:00Z`);
+    if (!Number.isFinite(at)) continue;
+    if (now - at <= spec.provisionalDays * DAY_MS2) continue;
+    for (let i = entry.startLine; i < entry.endLine; i++) drop.add(i);
+    removed.push({ line: entry.startLine + 1, text: truncate(entry.rule) });
+  }
+  if (removed.length === 0) return { text, removed, kept: entries.length };
+  const keptLines = text.split(/\r?\n/).filter((_, index) => !drop.has(index));
+  const compact = keptLines.join("\n").replace(/\n{3,}/g, "\n\n");
+  const out = compact.endsWith("\n") ? compact : `${compact}
+`;
+  return { text: out, removed, kept: entries.length - removed.length };
+};
+var maintainMap = (root, mapDir, now = Date.now()) => {
+  const files = [];
+  let removedTotal = 0;
+  for (const spec of MAP_SPECS) {
+    const absolute = path.join(mapDir, spec.file);
+    if (!existsSync2(absolute)) continue;
+    let before;
+    try {
+      before = readFileSync4(absolute, "utf8");
+    } catch {
+      continue;
+    }
+    const canResolve = (pointer, section) => resolvePointer(root, pointer, section).exists;
+    const result = normalizeMapText(spec, before, { now, canResolve });
+    const changed = result.text !== before;
+    if (changed) writeFileSync3(absolute, result.text);
+    if (result.removed.length > 0) {
+      removedTotal += result.removed.length;
+      files.push({ file: spec.file, changed, removed: result.removed });
+    } else if (changed) {
+      files.push({ file: spec.file, changed, removed: [] });
+    }
+  }
+  return { files, removedTotal };
+};
+var auditMap = (root, mapDir, now = Date.now()) => {
+  const files = [];
+  const violations = [];
+  const rulesSeen = /* @__PURE__ */ new Map();
+  for (const spec of MAP_SPECS) {
+    const absolute = path.join(mapDir, spec.file);
+    if (!existsSync2(absolute)) {
+      const violation = { file: spec.file, kind: "missing-file", detail: `missing; charter is ${spec.charter}` };
+      violations.push(violation);
+      continue;
+    }
+    let text;
+    try {
+      text = readFileSync4(absolute, "utf8");
+    } catch {
+      violations.push({ file: spec.file, kind: "missing-file", detail: "unreadable" });
+      continue;
+    }
+    const result = validateMapText(spec, text, { root, now });
+    files.push(result);
+    violations.push(...result.violations);
+    if (spec.kind === "entries") {
+      for (const entry of result.entries) {
+        const key = normalizeRule(entry.rule);
+        if (key.length < 12) continue;
+        const home = rulesSeen.get(key);
+        if (home !== void 0 && home !== spec.file) {
+          violations.push({
+            file: spec.file,
+            line: entry.startLine + 1,
+            kind: "duplicate",
+            detail: `same rule is already stated in ${home}; one fact has one home`
+          });
+        } else if (home === void 0) {
+          rulesSeen.set(key, spec.file);
+        }
+      }
+    }
   }
-  return { text: renderBacklog(kept), removed };
+  return { ok: violations.length === 0, files, violations };
 };
+var formatViolations = (violations, limit = 20) => violations.slice(0, limit).map((violation) => {
+  const where = violation.line !== void 0 ? `${violation.file}:${violation.line}` : violation.file;
+  return `${where} [${violation.kind}] ${violation.detail}`;
+});
 
 // src/lib/jsonc.ts
 var stripJsonc = (raw) => {
@@ -2975,12 +3779,12 @@ var parseJsonc = (raw) => {
 };
 
 // src/lib/writer-rule.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import * as path from "node:path";
-var CONTEXT_DIR = path.join(".opencode", "context");
+import { readFileSync as readFileSync5 } from "node:fs";
+import * as path2 from "node:path";
+var CONTEXT_DIR = path2.join(".opencode", "context");
 var WRITER = "context";
 var INSTRUCTIONS_WRITER = AGENT_INSTRUCTIONS_WRITER;
-var toPosix = (value) => value.split(path.sep).join("/");
+var toPosix = (value) => value.split(path2.sep).join("/");
 var compilePattern = (pattern) => {
   const escaped = toPosix(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
   return new RegExp(`^${escaped}$`, "s");
@@ -3005,17 +3809,17 @@ var readAgents = (raw) => {
 };
 var permissionOf = (agent) => agent?.permission?.edit;
 var evaluatedForm = (mapDir, projectRoot) => {
-  const absolute = toPosix(path.join(mapDir, "architecture.md"));
-  return projectRoot ? toPosix(path.relative(projectRoot, absolute)) : absolute;
+  const absolute = toPosix(path2.join(mapDir, "architecture.md"));
+  return projectRoot ? toPosix(path2.relative(projectRoot, absolute)) : absolute;
 };
 var agentsForm = (mapDir, projectRoot) => {
-  const absolute = toPosix(path.join(mapDir, "..", "..", "AGENTS.md"));
-  return projectRoot ? toPosix(path.relative(projectRoot, absolute)) : absolute;
+  const absolute = toPosix(path2.join(mapDir, "..", "..", "AGENTS.md"));
+  return projectRoot ? toPosix(path2.relative(projectRoot, absolute)) : absolute;
 };
 var verifyWriterRule = (configPath, mapDir, projectRoot) => {
   let raw;
   try {
-    raw = readFileSync4(configPath, "utf8");
+    raw = readFileSync5(configPath, "utf8");
   } catch {
     return void 0;
   }
@@ -3028,7 +3832,7 @@ var verifyWriterRule = (configPath, mapDir, projectRoot) => {
   const form = evaluatedForm(mapDir, projectRoot);
   if (rules.length > 0) {
     if (!rules.some((rule) => compilePattern(rule).test(form))) {
-      return `context map is not writable: none of the allow rules in ${path.basename(configPath)} match ` + (projectRoot ? `the project-root-relative form "${form}" that opencode actually evaluates for project root ${toPosix(projectRoot)}` : `the absolute form "${form}"`) + `. Rules seen: ${rules.map((r) => `"${r}"`).join(", ")}. opencode evaluates file permissions against the path RELATIVE TO THE PROJECT ROOT, so "${CONTEXT_DIR}/**" is what fires for a normally-rooted project while "*/${CONTEXT_DIR}/**" only fires when the project root is "/". Allow both forms.`;
+      return `context map is not writable: none of the allow rules in ${path2.basename(configPath)} match ` + (projectRoot ? `the project-root-relative form "${form}" that opencode actually evaluates for project root ${toPosix(projectRoot)}` : `the absolute form "${form}"`) + `. Rules seen: ${rules.map((r) => `"${r}"`).join(", ")}. opencode evaluates file permissions against the path RELATIVE TO THE PROJECT ROOT, so "${CONTEXT_DIR}/**" is what fires for a normally-rooted project while "*/${CONTEXT_DIR}/**" only fires when the project root is "/". Allow both forms.`;
     }
   }
   const agents = readAgents(raw);
@@ -3061,7 +3865,7 @@ var verifyWriterRule = (configPath, mapDir, projectRoot) => {
 
 // src/plugins/context-autoupdate.ts
 var SERVICE2 = "context-autoupdate";
-var CONTEXT_DIR2 = path2.join(".opencode", "context");
+var CONTEXT_DIR2 = path3.join(".opencode", "context");
 var COOLDOWN_MS = 10 * 60 * 1e3;
 var OWNED_TTL_MS = 20 * 60 * 1e3;
 var MAX_FILES_LISTED = 25;
@@ -3098,13 +3902,19 @@ var NO_BULK_READS = [
   "that PRODUCES or CONSUMES them instead. If a payload must be sampled, use",
   "`head -c 2000` or `wc -c` \u2014 never `cat` or a bare `grep -r` across one."
 ].join(" ");
-var toPosix2 = (value) => value.split(path2.sep).join("/");
+var ENTRY_CONTRACT = [
+  "Every navigation entry uses the schema in your system prompt:",
+  "`- [binding|provisional|disputed] <rule, at most three lines> \u2014 See `<path>`[ \xA7Section] (verified YYYY-MM-DD)`.",
+  "Stay inside each file's line budget. Point at the page or path that owns a fact; do not restate it.",
+  "After writing, run the drift pass: report a contradiction, never overwrite the page or silently pick a side."
+].join(" ");
+var toPosix2 = (value) => value.split(path3.sep).join("/");
 var findProjectConfig = () => {
-  let dir = import.meta.dir ?? path2.dirname(new URL(import.meta.url).pathname);
+  let dir = import.meta.dir ?? path3.dirname(new URL(import.meta.url).pathname);
   for (let up = 0; up <= 3; up++) {
-    const candidate = path2.join(dir, "opencode.jsonc");
-    if (existsSync2(candidate)) return candidate;
-    const parent = path2.dirname(dir);
+    const candidate = path3.join(dir, "opencode.jsonc");
+    if (existsSync3(candidate)) return candidate;
+    const parent = path3.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3114,9 +3924,9 @@ var snapshotMap = (dir) => {
   const out = /* @__PURE__ */ new Map();
   try {
     for (const name of readdirSync2(dir)) {
-      const file = path2.join(dir, name);
+      const file = path3.join(dir, name);
       try {
-        const st = statSync3(file);
+        const st = statSync4(file);
         if (st.isFile()) out.set(name, `${st.size}:${st.mtimeMs}`);
       } catch {
       }
@@ -3133,20 +3943,20 @@ var changedSince = (before, dir) => {
   return changed;
 };
 var RETAIN_TRANSCRIPTS = 20;
-var transcriptDir = () => process.env.LACODE_TRANSCRIPT_DIR ?? path2.join(homedir3(), ".local", "share", "opencode", "lacode", "cartographer");
+var transcriptDir = () => process.env.LACODE_TRANSCRIPT_DIR ?? path3.join(homedir3(), ".local", "share", "opencode", "lacode", "cartographer");
 var retireSession = async (client, directory, sessionID, mode, log) => {
   try {
     const transcript = await client.session.messages({ path: { id: sessionID }, query: { directory } }).then((r) => r.data).catch(() => void 0);
     const dir = transcriptDir();
     mkdirSync3(dir, { recursive: true });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const file = path2.join(dir, `${stamp}-${mode}.json`);
-    writeFileSync3(file, JSON.stringify({ sessionID, mode, messages: transcript ?? null }, null, 2));
+    const file = path3.join(dir, `${stamp}-${mode}.json`);
+    writeFileSync4(file, JSON.stringify({ sessionID, mode, messages: transcript ?? null }, null, 2));
     pruneTranscripts(dir);
     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((resolve3) => setTimeout(resolve3, 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", {
@@ -3162,7 +3972,7 @@ var pruneTranscripts = (dir) => {
     const entries = readdirSync2(dir).filter((name) => name.endsWith(".json")).sort();
     for (const name of entries.slice(0, Math.max(0, entries.length - RETAIN_TRANSCRIPTS))) {
       try {
-        unlinkSync3(path2.join(dir, name));
+        unlinkSync3(path3.join(dir, name));
       } catch {
       }
     }
@@ -3176,24 +3986,24 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
   const state2 = state(options);
   const log = (level, message, extra) => client.app.log({ body: { service: SERVICE2, level, message, extra } }).catch(() => {
   });
-  const root = path2.resolve(directory);
-  const contextAbs = path2.join(root, CONTEXT_DIR2);
-  const activeBacklogPath = path2.join(contextAbs, ACTIVE_BACKLOG_FILE);
+  const root = path3.resolve(directory);
+  const contextAbs = path3.join(root, CONTEXT_DIR2);
+  const activeBacklogPath = path3.join(contextAbs, ACTIVE_BACKLOG_FILE);
   const config = findProjectConfig();
   const writerProblem = config ? verifyWriterRule(config, contextAbs, root) : void 0;
   if (writerProblem) void log("error", writerProblem);
   const isTracked = (file) => {
-    const absolute = path2.resolve(root, file);
-    if (absolute !== root && !absolute.startsWith(root + path2.sep)) return false;
-    if (absolute === contextAbs || absolute.startsWith(contextAbs + path2.sep)) return false;
+    const absolute = path3.resolve(root, file);
+    if (absolute !== root && !absolute.startsWith(root + path3.sep)) return false;
+    if (absolute === contextAbs || absolute.startsWith(contextAbs + path3.sep)) return false;
     return !toPosix2(absolute).split("/").some((segment) => IGNORED_SEGMENTS.has(segment));
   };
   const normalizeActiveBacklog = async () => {
     try {
-      if (!existsSync2(activeBacklogPath)) return { removed: 0 };
-      const before = readFileSync5(activeBacklogPath, "utf8");
+      if (!existsSync3(activeBacklogPath)) return { removed: 0 };
+      const before = readFileSync6(activeBacklogPath, "utf8");
       const { text, removed } = normalizeBacklog(before);
-      if (text !== before) writeFileSync3(activeBacklogPath, text);
+      if (text !== before) writeFileSync4(activeBacklogPath, text);
       if (removed.length > 0) {
         await log("info", `active backlog: dropped ${removed.length} task(s) finished more than a week ago`, {
           removed: removed.length
@@ -3204,7 +4014,46 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
       return { removed: 0 };
     }
   };
-  void normalizeActiveBacklog();
+  const applyLifecycle = async () => {
+    try {
+      const result = maintainMap(root, contextAbs);
+      for (const file of result.files) {
+        if (file.removed.length === 0) continue;
+        await log(
+          "info",
+          `map lifecycle: dropped ${file.removed.length} expired provisional entr${file.removed.length === 1 ? "y" : "ies"} from ${file.file}`,
+          { file: file.file, removed: file.removed.map((entry) => entry.text) }
+        );
+      }
+      return result;
+    } catch {
+      return void 0;
+    }
+  };
+  const reportMapAudit = async (mode) => {
+    try {
+      const audit = auditMap(root, contextAbs);
+      if (audit.ok) {
+        await log("info", "context map validation passed", { mode, files: audit.files.length });
+        return audit;
+      }
+      const byKind = {};
+      for (const violation of audit.violations) {
+        byKind[violation.kind] = (byKind[violation.kind] ?? 0) + 1;
+      }
+      await log("error", `context map validation failed: ${audit.violations.length} issue(s)`, {
+        mode,
+        byKind,
+        issues: formatViolations(audit.violations, 20),
+        note: "reported, not rewritten; fix the entry or its source and run /context-update"
+      });
+      return audit;
+    } catch (error) {
+      await log("warn", `context map validation could not run: ${String(error)}`, { mode });
+      return void 0;
+    }
+  };
+  void applyLifecycle();
   const listed = (files) => {
     const shown = files.slice(0, MAX_FILES_LISTED);
     const rest = files.length - shown.length;
@@ -3222,7 +4071,9 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
     "",
     NO_BULK_READS,
     "",
-    "Follow the bootstrap procedure in your system prompt: progressive exploration, then write the five context files within their size targets. Also create `.opencode/context/active.md` with its heading and no tasks. When the project already has architecture or decision documentation, link to it instead of duplicating it. Write conclusions, not inventories."
+    ENTRY_CONTRACT,
+    "",
+    "Follow the bootstrap procedure in your system prompt: progressive exploration, then write the five context files within their line budgets. Also create `.opencode/context/active.md` with its heading and no tasks. When the project already has architecture or decision documentation, link to it instead of duplicating it. Write conclusions, not inventories."
   ].join("\n") : [
     "Incremental context update. Project root: " + directory,
     "",
@@ -3231,6 +4082,8 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
     "",
     NO_BULK_READS,
     "",
+    ENTRY_CONTRACT,
+    "",
     'Follow the incremental-update procedure in your system prompt. Update a context file only if this work introduced or revealed information that will materially help future agents: a new boundary or module, a new or moved canonical entry point, a changed workflow, a new convention, an architectural decision, a new dependency between subsystems, a renamed or moved subsystem, or an invariant not yet recorded. Do not edit documentation merely because source files changed. If nothing material changed, make no edits and report "no update needed". Also keep `.opencode/context/active.md` current: record work that is in flight, and mark a task finished \u2014 with the date it finished \u2014 when it is.'
   ].join("\n");
   return {
@@ -3238,7 +4091,7 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
       try {
         if (event.type === "file.edited") {
           const file = event.properties.file;
-          if (path2.resolve(root, file) === activeBacklogPath) {
+          if (path3.resolve(root, file) === activeBacklogPath) {
             await normalizeActiveBacklog();
             return;
           }
@@ -3265,7 +4118,7 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
         const requeue = () => {
           for (const file of files) pending.add(file);
         };
-        const mode = existsSync2(path2.join(contextAbs, "contexts.md")) ? "update" : "bootstrap";
+        const mode = existsSync3(path3.join(contextAbs, "contexts.md")) ? "update" : "bootstrap";
         init(state2, (m) => void log("warn", m));
         const snap = snapshot(state2);
         const slot = pickSlot(state2, snap);
@@ -3332,6 +4185,13 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
               hint: "either nothing needed updating, or the cartographer could not write -- check the one-writer permission rule"
             });
           }
+          await applyLifecycle();
+          const audit = await reportMapAudit(mode);
+          if (audit && !audit.ok) {
+            await log("error", `auto ${mode} finished with ${audit.violations.length} map validation issue(s)`, {
+              sessionID: target
+            });
+          }
         }).catch(async (error) => {
           release(state2, claimKey2);
           await retireSession(client, directory, target, mode, log);
@@ -3345,11 +4205,92 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
   };
 });
 
+// src/lib/feedback.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, join as join7 } from "node:path";
+var FEEDBACK_HINT_ENV = "LACODE_NO_FEEDBACK_HINT";
+var FEEDBACK_HINT = "Enjoying lacode? Bugs, ideas, or a quick note on how you use it: github.com/lawaty/lacode/issues (a \u2B50 on the repo helps others find it)";
+var feedbackStatePath = () => join7(homedir4(), ".local", "share", "opencode", "lacode", "feedback.json");
+function readFeedbackState(path5 = feedbackStatePath()) {
+  try {
+    const parsed = JSON.parse(readFileSync7(path5, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    return parsed;
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
+    return void 0;
+  }
+}
+function markFeedbackHintShown(path5 = feedbackStatePath()) {
+  try {
+    mkdirSync4(dirname4(path5), { recursive: true });
+    const tmp = `${path5}.${process.pid}.tmp`;
+    writeFileSync5(tmp, JSON.stringify({ feedbackHintShown: true }));
+    renameSync3(tmp, path5);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function restoreFeedbackState(path5 = feedbackStatePath(), previous = {}) {
+  try {
+    if (Object.keys(previous).length === 0) {
+      unlinkSync4(path5);
+      return;
+    }
+    const tmp = `${path5}.${process.pid}.tmp`;
+    writeFileSync5(tmp, JSON.stringify(previous));
+    renameSync3(tmp, path5);
+  } catch {
+  }
+}
+async function maybeShowFeedbackHint(deps = {}) {
+  const env = deps.env ?? process.env;
+  if (deps.enabled === false || deps.feedbackHint === false) return "disabled";
+  if (env[FEEDBACK_HINT_ENV] === "1") return "disabled";
+  const interactive = deps.interactive ?? process.stdout.isTTY === true;
+  if (!interactive || env.CI || env.NODE_TEST_CONTEXT) return "unavailable";
+  if (!deps.show) return "unavailable";
+  const state2 = readFeedbackState(deps.statePath);
+  if (state2 === void 0 || state2.feedbackHintShown === true) return "skipped";
+  if (!markFeedbackHintShown(deps.statePath)) return "skipped";
+  try {
+    await deps.show(FEEDBACK_HINT);
+  } catch {
+    restoreFeedbackState(deps.statePath, state2);
+    return "skipped";
+  }
+  return "shown";
+}
+
+// src/plugins/feedback.ts
+async function feedbackHooks(input, options, deps = {}) {
+  const opts = options ?? {};
+  if (opts.enabled === false || opts.feedbackHint === false) return {};
+  const tui = input.client.tui;
+  const show = deps.show ?? (tui?.showToast ? async (message) => {
+    await tui.showToast({
+      body: { title: "lacode", message, variant: "info", duration: 8e3 }
+    });
+  } : void 0);
+  void maybeShowFeedbackHint({
+    enabled: opts.enabled,
+    feedbackHint: opts.feedbackHint,
+    env: deps.env,
+    statePath: deps.statePath,
+    interactive: deps.interactive,
+    show
+  }).catch(() => {
+  });
+  return {};
+}
+
 // src/plugins/image-paste.ts
 import { createHash, randomUUID } from "node:crypto";
-import { globSync, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { basename as basename2, join as join6 } from "node:path";
+import { globSync, mkdirSync as mkdirSync5, readFileSync as readFileSync8, renameSync as renameSync4, statSync as statSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename2, join as join8 } from "node:path";
 
 // src/lib/clipboard.ts
 import { spawnSync } from "node:child_process";
@@ -3410,12 +4351,12 @@ var WINDOWS_SCRIPT = [
 var readWindows = async (run) => {
   const result = await run("powershell", ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_SCRIPT]);
   if (!result.ok) return null;
-  const path4 = result.stdout.toString("utf8").replace(/^\uFEFF/, "").trim();
-  if (!path4) return null;
+  const path5 = result.stdout.toString("utf8").replace(/^\uFEFF/, "").trim();
+  if (!path5) return null;
   try {
-    return validImage({ ok: true, stdout: await readFile(path4) });
+    return validImage({ ok: true, stdout: await readFile(path5) });
   } finally {
-    await rm(path4, { force: true }).catch(() => {
+    await rm(path5, { force: true }).catch(() => {
     });
   }
 };
@@ -3499,8 +4440,8 @@ function splitArguments(input) {
   return out;
 }
 function expandTilde(p) {
-  if (p === "~") return homedir4();
-  if (p.startsWith("~/")) return join6(homedir4(), p.slice(2));
+  if (p === "~") return homedir5();
+  if (p.startsWith("~/")) return join8(homedir5(), p.slice(2));
   return p;
 }
 function expandGlob(p) {
@@ -3515,11 +4456,11 @@ function storeImage(bytes, dir, sessionID, label) {
   const kind = detectImageKind(bytes);
   if (kind === null) return null;
   const hash = createHash("sha256").update(bytes).digest("hex");
-  mkdirSync4(dir, { recursive: true });
-  const target = join6(dir, `${hash}.${kind.ext}`);
+  mkdirSync5(dir, { recursive: true });
+  const target = join8(dir, `${hash}.${kind.ext}`);
   const tmp = `${target}.tmp`;
-  writeFileSync4(tmp, bytes, { mode: 384 });
-  renameSync3(tmp, target);
+  writeFileSync6(tmp, bytes, { mode: 384 });
+  renameSync4(tmp, target);
   const part = {
     id: randomUUID(),
     sessionID,
@@ -3547,7 +4488,7 @@ async function imagePasteHooks(input, options, deps) {
     if (opts.enabled === false) return {};
     const maxBytes = resolveMaxBytes(opts);
     const maxImages = resolveMaxImages(opts);
-    const dir = opts.dir ?? process.env.LACODE_IMAGE_DIR ?? join6(homedir4(), ".local/share/opencode/lacode/images");
+    const dir = opts.dir ?? process.env.LACODE_IMAGE_DIR ?? join8(homedir5(), ".local/share/opencode/lacode/images");
     const readClipboard = (deps ?? {}).readClipboard ?? readClipboardImage;
     return {
       "command.execute.before": async (cmd, output) => {
@@ -3588,7 +4529,7 @@ async function imagePasteHooks(input, options, deps) {
               const name = basename2(filePath);
               let size;
               try {
-                const stat = statSync4(filePath);
+                const stat = statSync5(filePath);
                 if (!stat.isFile()) {
                   skipped.push(name);
                   continue;
@@ -3604,7 +4545,7 @@ async function imagePasteHooks(input, options, deps) {
               }
               let bytes;
               try {
-                bytes = readFileSync6(filePath);
+                bytes = readFileSync8(filePath);
               } catch {
                 skipped.push(name);
                 continue;
@@ -3663,18 +4604,26 @@ function scrubSlotNames(text) {
 // src/plugins/notify.ts
 import { spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync3 } from "node:fs";
-import * as path3 from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import * as path4 from "node:path";
 
 // src/lib/notify.ts
-import { closeSync as closeSync2, mkdirSync as mkdirSync5, openSync as openSync2, readFileSync as readFileSync7, renameSync as renameSync4, statSync as statSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5, writeSync as writeSync2 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { basename as basename3, join as join7 } from "node:path";
+import { closeSync as closeSync2, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync9, renameSync as renameSync5, statSync as statSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7, writeSync as writeSync2 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { basename as basename3, join as join9 } from "node:path";
 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) => {
@@ -3846,7 +4795,7 @@ var Notifier = class {
     return this.lastSent.size;
   }
 };
-var notificationStateDir = () => process.env.LACODE_NOTIFY_DIR ?? join7(homedir5(), ".local", "share", "opencode", "lacode", "notify");
+var notificationStateDir = () => process.env.LACODE_NOTIFY_DIR ?? join9(homedir6(), ".local", "share", "opencode", "lacode", "notify");
 var safeCorrelationKey = (correlationKey) => correlationKey.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 64);
 var CLAIM_WINDOW_MS = 5e3;
 var isPidAlive2 = (pid) => {
@@ -3857,17 +4806,17 @@ var isPidAlive2 = (pid) => {
     return error.code === "EPERM";
   }
 };
-var claimFile = (sessionID, kind) => join7(notificationStateDir(), `claim.${safeCorrelationKey(`${sessionID}.${kind}`)}`);
+var claimFile = (sessionID, kind) => join9(notificationStateDir(), `claim.${safeCorrelationKey(`${sessionID}.${kind}`)}`);
 var claimNotification = (sessionID, kind, instanceId = "") => {
-  const path4 = claimFile(sessionID, kind);
+  const path5 = claimFile(sessionID, kind);
   try {
-    mkdirSync5(notificationStateDir(), { recursive: true });
+    mkdirSync6(notificationStateDir(), { recursive: true });
   } catch {
     return true;
   }
   const take = () => {
     try {
-      const fd = openSync2(path4, "wx");
+      const fd = openSync2(path5, "wx");
       try {
         writeSync2(fd, `${process.pid} ${instanceId} ${kind}`);
       } finally {
@@ -3885,7 +4834,7 @@ var claimNotification = (sessionID, kind, instanceId = "") => {
   const judge = () => {
     let raw;
     try {
-      raw = readFileSync7(path4, "utf8").trim();
+      raw = readFileSync9(path5, "utf8").trim();
     } catch (error) {
       return error.code === "ENOENT" ? "gone" : "unknown";
     }
@@ -3906,7 +4855,7 @@ var claimNotification = (sessionID, kind, instanceId = "") => {
     }
     let age = Number.POSITIVE_INFINITY;
     try {
-      age = Date.now() - statSync5(path4).mtimeMs;
+      age = Date.now() - statSync6(path5).mtimeMs;
     } catch {
       return "gone";
     }
@@ -3923,7 +4872,7 @@ var claimNotification = (sessionID, kind, instanceId = "") => {
   if (judged === "held") return false;
   if (judged === "unknown") return true;
   if (judged === "gone") return take() !== "held";
-  const lockPath = `${path4}.takeover`;
+  const lockPath = `${path5}.takeover`;
   const takeOver = () => {
     const create = () => {
       try {
@@ -3935,7 +4884,7 @@ var claimNotification = (sessionID, kind, instanceId = "") => {
         }
         return () => {
           try {
-            unlinkSync4(lockPath);
+            unlinkSync5(lockPath);
           } catch {
           }
         };
@@ -3949,9 +4898,9 @@ var claimNotification = (sessionID, kind, instanceId = "") => {
     let lockHolder;
     let lockAge = Number.POSITIVE_INFINITY;
     try {
-      const parsed = Number.parseInt(readFileSync7(lockPath, "utf8").trim(), 10);
+      const parsed = Number.parseInt(readFileSync9(lockPath, "utf8").trim(), 10);
       lockHolder = Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
-      lockAge = Date.now() - statSync5(lockPath).mtimeMs;
+      lockAge = Date.now() - statSync6(lockPath).mtimeMs;
     } catch {
       return create();
     }
@@ -3959,7 +4908,7 @@ var claimNotification = (sessionID, kind, instanceId = "") => {
       return void 0;
     }
     try {
-      unlinkSync4(lockPath);
+      unlinkSync5(lockPath);
     } catch {
       return void 0;
     }
@@ -3973,7 +4922,7 @@ var claimNotification = (sessionID, kind, instanceId = "") => {
     if (current === "held") return false;
     if (current === "unknown") return true;
     try {
-      unlinkSync4(path4);
+      unlinkSync5(path5);
     } catch {
     }
     return take() !== "held";
@@ -3982,23 +4931,23 @@ var claimNotification = (sessionID, kind, instanceId = "") => {
   }
 };
 var releaseNotificationClaim = (sessionID, kind) => {
-  const path4 = claimFile(sessionID, kind);
+  const path5 = claimFile(sessionID, kind);
   try {
-    const parsed = Number.parseInt(readFileSync7(path4, "utf8").trim(), 10);
+    const parsed = Number.parseInt(readFileSync9(path5, "utf8").trim(), 10);
     if (!Number.isFinite(parsed) || parsed <= 0) return;
     if (parsed !== process.pid) return;
-    unlinkSync4(path4);
+    unlinkSync5(path5);
   } catch {
   }
 };
-var completionFile = (sessionID) => join7(notificationStateDir(), `completion.${safeCorrelationKey(sessionID)}`);
+var completionFile = (sessionID) => join9(notificationStateDir(), `completion.${safeCorrelationKey(sessionID)}`);
 var claimCompletion = (sessionID, kind) => {
-  const path4 = completionFile(sessionID);
+  const path5 = completionFile(sessionID);
   try {
-    mkdirSync5(notificationStateDir(), { recursive: true });
-    const fd = openSync2(path4, "wx");
+    mkdirSync6(notificationStateDir(), { recursive: true });
+    const fd = openSync2(path5, "wx");
     try {
-      writeFileSync5(fd, `${process.pid} ${kind}
+      writeFileSync7(fd, `${process.pid} ${kind}
 `);
     } finally {
       closeSync2(fd);
@@ -4011,18 +4960,18 @@ var claimCompletion = (sessionID, kind) => {
 };
 var releaseCompletion = (sessionID) => {
   try {
-    unlinkSync4(completionFile(sessionID));
+    unlinkSync5(completionFile(sessionID));
   } catch {
   }
 };
 var markCompletion = (sessionID, kind) => {
   try {
-    mkdirSync5(notificationStateDir(), { recursive: true });
-    const path4 = completionFile(sessionID);
-    const tmp = `${path4}.${process.pid}.tmp`;
-    writeFileSync5(tmp, `${process.pid} ${kind}
+    mkdirSync6(notificationStateDir(), { recursive: true });
+    const path5 = completionFile(sessionID);
+    const tmp = `${path5}.${process.pid}.tmp`;
+    writeFileSync7(tmp, `${process.pid} ${kind}
 `);
-    renameSync4(tmp, path4);
+    renameSync5(tmp, path5);
   } catch {
   }
 };
@@ -4043,13 +4992,13 @@ var findHelper = () => {
   const home = process.env.HOME ?? "";
   const candidates = [
     process.env.OC_NOTIFY_HELPER,
-    path3.join(home, "bin", "lacode"),
-    path3.join(PACKAGE_ROOT, "dist", "lacode.js"),
-    path3.join(PACKAGE_ROOT, "bin", "lacode"),
-    path3.join(home, "bin", "oc-notify"),
-    path3.join(PACKAGE_ROOT, "bin", "oc-notify")
+    path4.join(home, "bin", "lacode"),
+    path4.join(PACKAGE_ROOT, "dist", "lacode.js"),
+    path4.join(PACKAGE_ROOT, "bin", "lacode"),
+    path4.join(home, "bin", "oc-notify"),
+    path4.join(PACKAGE_ROOT, "bin", "oc-notify")
   ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
-  for (const candidate of candidates) if (existsSync3(candidate)) return candidate;
+  for (const candidate of candidates) if (existsSync4(candidate)) return candidate;
   return void 0;
 };
 var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
@@ -4162,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((resolve3) => {
+  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 });
-      resolve3({ 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();
@@ -4174,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");
       }
-      resolve3({ 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 } : {} };
@@ -4197,7 +5146,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       settled = true;
       inflight--;
       if (timer) clearTimeout(timer);
-      resolve3(result);
+      resolve5(result);
     };
     timer = setTimeout(() => {
       try {
@@ -4518,9 +5467,9 @@ function normalizeBaseURL(raw) {
     return null;
   }
   if (url.protocol !== "http:" && url.protocol !== "https:") return null;
-  let path4 = url.pathname.replace(/\/+$/, "");
-  while (path4.endsWith("/v1")) path4 = path4.slice(0, -"/v1".length);
-  return `${url.origin}${path4}/v1`;
+  let path5 = url.pathname.replace(/\/+$/, "");
+  while (path5.endsWith("/v1")) path5 = path5.slice(0, -"/v1".length);
+  return `${url.origin}${path5}/v1`;
 }
 function parseConfig(raw, env = process.env) {
   if (typeof raw !== "object" || raw === null) return { enabled: false, config: null, problems: [] };
@@ -4986,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 () => {
@@ -5021,13 +6705,15 @@ 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;
   const selfupdate = await settled("self-update", () => selfUpdateHooks(input, options)) ?? inertHooks;
+  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);
@@ -5051,6 +6737,8 @@ var LaCode = (async (input, options) => {
       autoupdate.event?.(payload).catch(() => {
       }),
       notifier.event?.(payload).catch(() => {
+      }),
+      timeline.event?.(payload).catch(() => {
       })
     ]);
   };
@@ -5061,15 +6749,17 @@ 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?.();
       await autoupdate.dispose?.();
       await notifier.dispose?.();
       await selfupdate.dispose?.();
+      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;