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

package/dist/lacode.js

@@ -63,6 +63,8 @@ var DEFAULT_PRESET = join2(PRESETS_DIR, "free-tier.json");
 var USER_CONFIG_DIR = join2(homedir(), ".config", "lacode");
 var USER_MODELS_PATH = join2(USER_CONFIG_DIR, "pool.json");
 var USER_MODELS_TXT = join2(USER_CONFIG_DIR, "pool.txt");
+var CONTEXT_OVERFLOW_COOLDOWN_MS = 10 * 60 * 1e3;
+var BELOW_MIN_CONTEXT_COOLDOWN_MS = 6 * 60 * 60 * 1e3;
 var STATE_SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
 var CHILD_MEMORY_MS = 30 * 6e4;
 

package/dist/pool.js

@@ -25,6 +25,7 @@ var PACKAGE_ROOT = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
 
 // src/lib/pool.ts
 var CLAIM_TTL_MS = 10 * 60 * 1e3;
+var HEARTBEAT_PUBLISH_MS = 3e4;
 var UNBOUND_CLAIM_MS = 2 * 60 * 1e3;
 var DEAD_FILE_MS = 2 * CLAIM_TTL_MS;
 var ORPHAN_TMP_MS = 60 * 1e3;
@@ -37,6 +38,8 @@ var HANG_COOLDOWN_MS = 10 * 60 * 1e3;
 var UNAVAILABLE_COOLDOWN_MS = 60 * 1e3;
 var UNAVAILABLE_REASON = "endpoint-unavailable";
 var MAX_WEIGHT = 100;
+var MIN_SLOT_CONTEXT = 1e5;
+var MIN_SLOT_TPM = 2e4;
 var slotCeiling = (slot) => slot.weight;
 var slotBucket = (slot) => slot.bucket ?? slot.model;
 var NOTIFY_DEFAULT_ON_PROVIDERS = /* @__PURE__ */ new Set(["opencode", "opencode-go"]);
@@ -67,6 +70,7 @@ 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 LEARNED_TPM_FILE = "learned-tpm.json";
 var PRESETS_DIR = join2(PACKAGE_ROOT, "presets");
 var DEFAULT_PRESET = join2(PRESETS_DIR, "free-tier.json");
 var USER_CONFIG_DIR = join2(homedir(), ".config", "lacode");
@@ -109,7 +113,29 @@ function parseSlots(parsed, origin) {
       problems.push(`${at} (${model}): bucket must be a non-empty name; using the model id`);
     }
     const notify = coerceNotify(entry.notify, at, model, problems);
-    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify });
+    const rawContext = entry?.context;
+    let context;
+    if (rawContext !== void 0) {
+      const parsedContext = typeof rawContext === "number" ? rawContext : Number(rawContext);
+      if (Number.isFinite(parsedContext) && parsedContext > 0) context = parsedContext;
+      else problems.push(`${at} (${model}): context must be a positive number, got ${JSON.stringify(rawContext)}; ignoring it`);
+    }
+    if (context !== void 0 && context < MIN_SLOT_CONTEXT) {
+      problems.push(`${at} (${model}): context ${context} is below the ${MIN_SLOT_CONTEXT}-token minimum; dropping the slot`);
+      return;
+    }
+    const rawTpm = entry?.tpm;
+    let tpm;
+    if (rawTpm !== void 0) {
+      const parsedTpm = typeof rawTpm === "number" ? rawTpm : Number(rawTpm);
+      if (Number.isFinite(parsedTpm) && parsedTpm > 0) tpm = parsedTpm;
+      else problems.push(`${at} (${model}): tpm must be a positive number, got ${JSON.stringify(rawTpm)}; ignoring it`);
+    }
+    if (tpm !== void 0 && tpm < MIN_SLOT_TPM) {
+      problems.push(`${at} (${model}): tpm ${tpm} is below the ${MIN_SLOT_TPM}-token/minute minimum; dropping the slot`);
+      return;
+    }
+    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } });
   });
   if (slots.length > SLOTS_WARN_AT) {
     problems.push(`${origin}: ${slots.length} slots is unusually large, but every entry is kept (the pool has no slot cap)`);
@@ -129,18 +155,34 @@ function parseTextSlots(text, origin) {
     let weight;
     let bucket;
     let notify;
+    let context;
+    let tpm;
     for (const token of rest) {
       if (token.startsWith("notify:")) {
         if (notify === void 0) notify = token.slice("notify:".length);
         continue;
       }
+      if (token.startsWith("c:")) {
+        if (context === void 0) {
+          const parsedContext = Number(token.slice(2));
+          if (Number.isFinite(parsedContext) && parsedContext > 0) context = parsedContext;
+        }
+        continue;
+      }
+      if (token.startsWith("tpm:")) {
+        if (tpm === void 0) {
+          const parsedTpm = Number(token.slice(4));
+          if (Number.isFinite(parsedTpm) && parsedTpm > 0) tpm = parsedTpm;
+        }
+        continue;
+      }
       if (token.startsWith("b:")) {
         if (bucket === void 0) bucket = token.slice(2);
       } else if (weight === void 0) {
         weight = token;
       }
     }
-    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify } });
+    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify }, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } });
   }
   return parseSlots({ slots: entries }, origin);
 }
@@ -260,6 +302,43 @@ var LIMIT_PATTERNS = [
 ];
 var LIMIT_REACHED_PATTERN = /\blimits?[\s_-]?(?:reached|exceeded)\b|\breached\s+(?:your|the|its)\s+limit\b/i;
 var CONTEXT_LIMIT_PATTERN = /(?:context|token|length|window|prompt|char|character|byte|size)\s*(?:limit|length|size|window)/i;
+var CONTEXT_OVERFLOW_COOLDOWN_MS = 10 * 60 * 1e3;
+var CONTEXT_OVERFLOW_PATTERNS = [
+  /context[_\s-]*(?:length|window|limit|overflow|exceed)/i,
+  /input\s+too\s+long/i,
+  /prompt\s+is\s+too\s+long/i,
+  /maximum\s+(?:context|prompt|token)/i,
+  /reduce\s+the\s+length\s+of\s+(?:the\s+)?messages/i
+];
+var isContextOverflowText = (text) => CONTEXT_OVERFLOW_PATTERNS.some((re) => re.test(text));
+var BELOW_MIN_CONTEXT_COOLDOWN_MS = 6 * 60 * 60 * 1e3;
+var REQUEST_TOO_LARGE_PATTERNS = [
+  /request\s+too\s+large/i,
+  /please\s+reduce\s+your\s+message\s+size/i,
+  /limit\s+\d+\s*,\s*requested\s+\d+/i,
+  /\(tpm\)/i
+];
+var isRequestTooLargeText = (text) => REQUEST_TOO_LARGE_PATTERNS.some((re) => re.test(text));
+var parseStatedTokenLimit = (text) => {
+  for (const re of [/limit\s+(\d+)\s*,\s*requested\s+\d+/i, /limit\s+is\s+(\d+)/i]) {
+    const match = text.match(re);
+    if (match) {
+      const value = Number(match[1]);
+      if (Number.isFinite(value) && value > 0) return value;
+    }
+  }
+  return void 0;
+};
+function parseRateLimitHeaders(headers) {
+  if (typeof headers !== "object" || headers === null || Array.isArray(headers)) return void 0;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== "x-ratelimit-limit-tokens") continue;
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value.trim()) : Number.NaN;
+    if (Number.isFinite(parsed) && parsed > 0 && Number.isInteger(parsed)) return parsed;
+    return void 0;
+  }
+  return void 0;
+}
 var LIMIT_REASON_PATTERN = /rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded|limits?[\s_-]?(?:reached|exceeded)/i;
 var isLimitText = (text) => LIMIT_PATTERNS.some((re) => re.test(text)) || LIMIT_REACHED_PATTERN.test(text) && !CONTEXT_LIMIT_PATTERN.test(text);
 var limitReason = (text) => {
@@ -326,6 +405,7 @@ function state(opts = {}) {
       reaping: false,
       lastSweep: 0,
       lastDirSweep: 0,
+      lastHeartbeatPublish: 0,
       connected: /* @__PURE__ */ new Set(),
       connectedAt: 0,
       connectedReady: false,
@@ -344,26 +424,75 @@ function state(opts = {}) {
 function ensureSlots(s, onWarn) {
   if (s.slots.length > 0) return s.slots;
   const { slots, problems, origin } = resolveModels({ models: s.inlineModels, modelsFile: s.modelsFile });
-  s.slots = slots;
+  s.slots = applyLearnedTpm(s, slots, onWarn);
   s.origin = origin;
   for (const problem of problems) onWarn(problem);
   return slots;
 }
-var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.bucket ?? ""}:${slotNotify(slot) ? "1" : "0"}`).join("|")}`;
+var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.bucket ?? ""}:${slotNotify(slot) ? "1" : "0"}:${slot.tpm ?? ""}`).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);
-  if (!changed) return { changed, slots, origin };
-  s.slots = slots;
+  const effective = applyLearnedTpm(s, slots, onWarn);
+  const changed = slotSignature(origin, effective) !== slotSignature(s.origin, s.slots);
+  if (!changed) return { changed, slots: s.slots, origin: s.origin };
+  s.slots = effective;
   s.origin = origin;
   for (const problem of problems) onWarn(problem);
-  return { changed, slots, origin };
+  return { changed, slots: effective, origin };
 }
 function slotSources(input = {}) {
   if (input.models !== void 0) return [];
   if (input.modelsFile) return [input.modelsFile];
   return [USER_MODELS_TXT, USER_MODELS_PATH, DEFAULT_PRESET];
 }
+var learnedTpmPath = (s) => join2(s.dir, LEARNED_TPM_FILE);
+function readLearnedTpm(s) {
+  try {
+    const raw = JSON.parse(readFileSync2(learnedTpmPath(s), "utf8"));
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {};
+    const out = {};
+    for (const [model, value] of Object.entries(raw)) {
+      const n = typeof value === "number" ? value : Number(value);
+      if (Number.isFinite(n) && n > 0) out[model] = n;
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function applyLearnedTpm(s, slots, onWarn) {
+  const learned = readLearnedTpm(s);
+  const out = [];
+  for (const slot of slots) {
+    const tpm = learned[slot.model];
+    if (tpm !== void 0 && tpm < MIN_SLOT_TPM) {
+      onWarn?.(`learned-tpm: dropping ${slot.model} (tpm ${tpm} < ${MIN_SLOT_TPM})`);
+      continue;
+    }
+    if (tpm !== void 0) out.push({ ...slot, tpm: Math.min(slot.tpm ?? tpm, tpm) });
+    else out.push(slot);
+  }
+  return out.map((slot, i) => ({ ...slot, index: i + 1 }));
+}
+function noteTpm(s, model, tpm) {
+  if (!Number.isFinite(tpm) || tpm <= 0) return false;
+  const map = readLearnedTpm(s);
+  map[model] = tpm;
+  if (s.dirReady) {
+    try {
+      const path = learnedTpmPath(s);
+      writeFileSync(`${path}.tmp`, JSON.stringify(map));
+      renameSync(`${path}.tmp`, path);
+    } catch {
+    }
+  }
+  if (tpm < MIN_SLOT_TPM) {
+    s.slots = s.slots.filter((slot) => slot.model !== model).map((slot, i) => ({ ...slot, index: i + 1 }));
+    return true;
+  }
+  s.slots = s.slots.map((slot) => slot.model === model ? { ...slot, tpm: Math.min(slot.tpm ?? tpm, tpm) } : slot);
+  return false;
+}
 var claimKey = (sessionID, callID) => `${sessionID}:${callID}`;
 var selfFile = (id) => `claims.${id}.json`;
 var limitFile = (model) => `limit.${model.replace(/[^a-zA-Z0-9._-]/g, "__")}.json`;
@@ -713,20 +842,51 @@ function snapshot(s) {
 }
 var loadOf = (counts, slot) => counts.get(slot) ?? 0;
 var underCeiling = (slot, counts) => loadOf(counts, slot.index) < slotCeiling(slot);
-function pickSlot(s, snap) {
+function pickSlot(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
-  const configured = slots.filter((slot) => providerReady(s, slot.model));
-  const usable = configured.filter((slot) => isAvailable(s, slot.model, snap.cooling));
-  const pool = usable.length > 0 ? usable : configured.length > 0 ? configured : slots;
-  for (const slot of usable) {
-    if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+  const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  if (usable.length === 0) return void 0;
+  const effective = (slot) => Math.min(slot.context ?? Number.POSITIVE_INFINITY, slot.tpm ?? Number.POSITIVE_INFINITY);
+  if (neededContext === void 0) {
+    for (const slot of usable) {
+      if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+    }
+    return usable.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, usable[0]);
+  }
+  const adequate = usable.filter((slot) => effective(slot) >= neededContext);
+  const adequateKnown = adequate.filter((slot) => Number.isFinite(effective(slot)));
+  const candidates = adequate.length > 0 ? adequate : usable;
+  if (adequateKnown.length === 0) {
+    const known = usable.filter((slot) => Number.isFinite(effective(slot)));
+    if (known.length > 0) {
+      const largest = Math.max(...known.map((slot) => effective(slot)));
+      const largestSlots = known.filter((slot) => effective(slot) === largest);
+      for (const slot of largestSlots) {
+        if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+      }
+      return largestSlots.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, largestSlots[0]);
+    }
+    for (const slot of candidates) {
+      if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+    }
+    return candidates.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, candidates[0]);
   }
-  return pool.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, pool[0]);
+  const underWeight = candidates.filter((slot) => loadOf(snap.counts, slot.index) < slot.weight);
+  if (underWeight.length > 0) {
+    const known = underWeight.filter((slot) => Number.isFinite(effective(slot)));
+    if (known.length === 0) return underWeight[0];
+    return known.reduce((best, slot) => effective(slot) < effective(best) ? slot : best, known[0]);
+  }
+  return candidates.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, candidates[0]);
 }
-function poolPass(s, snap) {
+function poolPass(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
   const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
-  if (usable.some((slot) => loadOf(snap.counts, slot.index) < slot.weight)) return 1;
+  if (usable.length === 0) return "none";
+  const effective = (slot) => Math.min(slot.context ?? Number.POSITIVE_INFINITY, slot.tpm ?? Number.POSITIVE_INFINITY);
+  const candidates = neededContext === void 0 ? usable : usable.filter((slot) => effective(slot) >= neededContext);
+  const pool = candidates.length > 0 ? candidates : usable;
+  if (pool.some((slot) => loadOf(snap.counts, slot.index) < slot.weight)) return 1;
   return "overflow";
 }
 function agentFor(base, slot) {
@@ -786,7 +946,10 @@ function noteActivity(s, sessionID) {
   s.activity.set(sessionID, now);
   let touched = false;
   for (const claim of s.own.values()) if (claim.g === sessionID) claim.hb = now, touched = true;
-  if (touched) publish(s);
+  if (touched && now - s.lastHeartbeatPublish >= HEARTBEAT_PUBLISH_MS) {
+    s.lastHeartbeatPublish = now;
+    publish(s);
+  }
 }
 function idleFor(s, claim, now) {
   const target = claim.g;
@@ -886,14 +1049,20 @@ export {
   AUTH_FAILURE_COOLDOWN_MS,
   AUTH_FAILURE_REASON,
   BASES,
+  BELOW_MIN_CONTEXT_COOLDOWN_MS,
   CATALOG_TTL_MS,
   CLAIM_TTL_MS,
+  CONTEXT_OVERFLOW_COOLDOWN_MS,
   DEAD_FILE_MS,
   DEFAULT_PRESET,
   FALLBACK_SLOTS,
   HANG_COOLDOWN_MS,
+  HEARTBEAT_PUBLISH_MS,
+  LEARNED_TPM_FILE,
   MAX_CLAIM_AGE_MS,
   MAX_WEIGHT,
+  MIN_SLOT_CONTEXT,
+  MIN_SLOT_TPM,
   MODEL_MISSING_COOLDOWN_MS,
   MODEL_MISSING_REASON,
   ORPHAN_TMP_MS,
@@ -916,6 +1085,7 @@ export {
   acquire,
   agentFor,
   announcesReset,
+  applyLearnedTpm,
   backfillChild,
   bindChild,
   claimKey,
@@ -930,19 +1100,24 @@ export {
   init,
   isAuthFailureText,
   isAvailable,
+  isContextOverflowText,
   isLimitText,
   isModelMissingText,
   isProbe,
   isQuotaReason,
+  isRequestTooLargeText,
   isTransientGatewayText,
   isUnavailableText,
   limitReason,
   manualVariant,
   markProbe,
   noteActivity,
+  noteTpm,
   notifyDefault,
+  parseRateLimitHeaders,
   parseSlotText,
   parseSlots,
+  parseStatedTokenLimit,
   parseTextSlots,
   pickSlot,
   poolPass,
@@ -952,6 +1127,7 @@ export {
   pruneSessions,
   publish,
   readFailures,
+  readLearnedTpm,
   readLimits,
   readSiblings,
   readSlotFile,

package/dist/tui.js

@@ -822,33 +822,12 @@ function createVoiceClient(options, deps) {
 }
 
 // src/tui/timeline.tsx
-import { readFileSync as readFileSync3 } from "node:fs";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join3, resolve } from "node:path";
 import { jsx, jsxs } from "@opentui/solid/jsx-runtime";
 var registered = false;
 var ENTRY_LINES = 14;
-var readEntries = (id) => {
-  if (typeof id !== "string" || !/^[A-Za-z0-9_.-]+$/.test(id)) return [];
-  const rawDir = process.env.LACODE_TIMELINE_DIR;
-  const dir = rawDir ? resolve(rawDir) : join3(homedir2(), ".local/share/opencode/lacode/timeline");
-  try {
-    const raw = readFileSync3(join3(dir, id + ".jsonl"), "utf8");
-    const parsed = [];
-    for (const line of raw.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const obj = JSON.parse(trimmed);
-        if (obj && typeof obj.ts === "number" && typeof obj.text === "string") parsed.push(obj.text);
-      } catch {
-      }
-    }
-    return parsed.slice(-ENTRY_LINES).reverse();
-  } catch {
-    return [];
-  }
-};
 var tui = async (api) => {
   if (registered) return;
   registered = true;
@@ -862,15 +841,80 @@ var tui = async (api) => {
       sidebar_content(ctx, props) {
         const rows = [];
         const muted = ctx.theme.current.textMuted;
+        const cache = { path: null, size: -1, mtimeMs: -1, ino: -1, entries: [], rendered: [] };
+        const readEntries = (id) => {
+          if (typeof id !== "string" || !/^[A-Za-z0-9_.-]+$/.test(id)) return [];
+          const rawDir = process.env.LACODE_TIMELINE_DIR;
+          const dir = rawDir ? resolve(rawDir) : join3(homedir2(), ".local/share/opencode/lacode/timeline");
+          const path = join3(dir, id + ".jsonl");
+          try {
+            const stat = statSync(path);
+            if (cache.path === path && cache.size === stat.size && cache.mtimeMs === stat.mtimeMs && cache.ino === stat.ino) {
+              return cache.entries;
+            }
+            const maxRead = 64 * 1024;
+            const start = Math.max(0, stat.size - maxRead);
+            const length = stat.size - start;
+            const fd = openSync(path, "r");
+            try {
+              const buf = Buffer.alloc(length);
+              let total = 0;
+              while (total < length) {
+                const n = readSync(fd, buf, total, length - total, start + total);
+                if (n <= 0) break;
+                total += n;
+              }
+              if (total < length) {
+                return [];
+              }
+              let raw = buf.toString("utf8");
+              if (start > 0) {
+                const firstNl = raw.indexOf("\n");
+                raw = firstNl === -1 ? "" : raw.slice(firstNl + 1);
+              }
+              const parsed = [];
+              for (const line of raw.split("\n")) {
+                const trimmed = line.trim();
+                if (!trimmed) continue;
+                try {
+                  const obj = JSON.parse(trimmed);
+                  if (obj && typeof obj.ts === "number" && typeof obj.text === "string") {
+                    parsed.push({ ts: obj.ts, text: obj.text });
+                  }
+                } catch {
+                }
+              }
+              const entries = parsed.slice(-ENTRY_LINES).reverse();
+              cache.path = path;
+              cache.size = stat.size;
+              cache.mtimeMs = stat.mtimeMs;
+              cache.ino = stat.ino;
+              cache.entries = entries;
+              return entries;
+            } finally {
+              closeSync(fd);
+            }
+          } catch {
+            return [];
+          }
+        };
         const paint = () => {
           const entries = readEntries(props.session_id);
+          const next = [];
+          for (let i = 0; i < ENTRY_LINES; i++) {
+            const text = entries[i]?.text;
+            next.push(text ? `\u2022 ${text}` : i === 0 && entries.length === 0 ? "No timeline yet" : "");
+          }
+          if (cache.rendered.length === ENTRY_LINES && next.every((value, i) => value === cache.rendered[i])) {
+            return;
+          }
           for (let i = 0; i < ENTRY_LINES; i++) {
             const row = rows[i];
             if (!row) continue;
-            const text = entries[i];
-            row.content = text ? `\u2022 ${text}` : i === 0 && entries.length === 0 ? "No timeline yet" : "";
+            row.content = next[i];
             row.requestRender?.();
           }
+          cache.rendered = next;
         };
         const timer = setInterval(paint, 1e3);
         timer.unref?.();
@@ -899,6 +943,47 @@ var plugin = {
 };
 var timeline_default = plugin;
 
+// src/lib/modes.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname, join as join4 } from "node:path";
+var MODES_FILE = process.env.LACODE_MODES_FILE ?? join4(homedir3(), ".config", "lacode", "modes.json");
+var bool = (value, fallback) => typeof value === "boolean" ? value : fallback;
+function readModes(defaults = {}) {
+  const fallback = { yolo: defaults.yolo === true, ykb: defaults.ykb === true };
+  try {
+    const raw = JSON.parse(readFileSync3(MODES_FILE, "utf8"));
+    return { yolo: bool(raw?.yolo, fallback.yolo), ykb: bool(raw?.ykb, fallback.ykb) };
+  } catch {
+    return fallback;
+  }
+}
+function writeModes(modes) {
+  const path = MODES_FILE;
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify({ yolo: modes.yolo, ykb: modes.ykb }, null, 2)}
+`);
+  renameSync(tmp, path);
+}
+function toggleMode(name, defaults = {}) {
+  const current = readModes(defaults);
+  const next = { ...current, [name]: !current[name] };
+  writeModes(next);
+  return next;
+}
+function recommendedAnswer(question) {
+  const q = question;
+  const options = (Array.isArray(q?.options) ? q.options : []).filter(
+    (option) => typeof option?.label === "string" && option.label.length > 0
+  );
+  if (options.length === 0) return [];
+  const recommended = options.find(
+    (option) => /\(recommended\)/i.test(option.label) || typeof option.description === "string" && /\(recommended\)/i.test(option.description)
+  );
+  return [(recommended ?? options[0]).label];
+}
+
 // src/tui/index.ts
 var DEFAULT_MODEL = "whisper-large-v3-turbo";
 var DEFAULT_LANGUAGE = "en";
@@ -1328,6 +1413,46 @@ var tui2 = async (api, options) => {
       toast(api, { variant: "error", title: "lacode voice", message: readableError(err) });
     }
   };
+  async function drainPendingMode(name) {
+    try {
+      const pending = await fetchPending(api);
+      for (const item of pending) {
+        if (name === "yolo" && item.kind === "permission") {
+          await api.client.permission.reply({ requestID: item.request.id, reply: "once" });
+        }
+        if (name === "ykb" && item.kind === "question") {
+          const answers = item.request.questions.map((question) => recommendedAnswer(question));
+          if (answers.some((answer) => answer.length > 0)) {
+            await api.client.question.reply({ requestID: item.request.id, answers });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  async function runToggleMode(name) {
+    try {
+      const next = toggleMode(name);
+      toast(api, {
+        variant: next[name] ? "success" : "info",
+        message: `${name.toUpperCase()} mode ${next[name] ? "on" : "off"}`
+      });
+      if (next[name]) await drainPendingMode(name);
+    } catch (error) {
+      toast(api, { variant: "error", message: `Could not toggle ${name.toUpperCase()}: ${String(error)}` });
+    }
+  }
+  async function runModeStatus() {
+    try {
+      const modes = readModes();
+      toast(api, {
+        variant: "info",
+        message: `YOLO ${modes.yolo ? "on" : "off"} \xB7 YKB ${modes.ykb ? "on" : "off"}`
+      });
+    } catch (error) {
+      toast(api, { variant: "error", message: `Could not read mode state: ${String(error)}` });
+    }
+  }
   const commands = [
     {
       name: "lacode.voice.dictate",
@@ -1349,7 +1474,10 @@ var tui2 = async (api, options) => {
       category: "Voice",
       namespace: "palette",
       run: async () => runCheck()
-    }
+    },
+    { name: "lacode.mode.yolo", title: "Mode: toggle YOLO (auto-approve permissions)", category: "Modes", namespace: "palette", slashName: "yolo", run: async () => runToggleMode("yolo") },
+    { name: "lacode.mode.ykb", title: "Mode: toggle YKB (no questions, decide itself)", category: "Modes", namespace: "palette", slashName: "ykb", run: async () => runToggleMode("ykb") },
+    { name: "lacode.mode.status", title: "Mode: show YOLO/YKB status", category: "Modes", namespace: "palette", slashName: "modes", run: async () => runModeStatus() }
   ];
   const bindings = [];
   if (opts.dictation) {

package/dist/tunnel.js

@@ -56,6 +56,8 @@ var DEFAULT_PRESET = join2(PRESETS_DIR, "free-tier.json");
 var USER_CONFIG_DIR = join2(homedir(), ".config", "lacode");
 var USER_MODELS_PATH = join2(USER_CONFIG_DIR, "pool.json");
 var USER_MODELS_TXT = join2(USER_CONFIG_DIR, "pool.txt");
+var CONTEXT_OVERFLOW_COOLDOWN_MS = 10 * 60 * 1e3;
+var BELOW_MIN_CONTEXT_COOLDOWN_MS = 6 * 60 * 60 * 1e3;
 var STATE_SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
 var CHILD_MEMORY_MS = 30 * 6e4;
 

package/docs/CONFIGURATION.md

@@ -7,7 +7,7 @@ The plugin options, where the model pool gets its slots, and exactly what LaCode
 The slot list is the first of these that yields usable slots:
 
 1. plugin options — `models` in the [tuple](../README.md#configure)
-2. `~/.config/lacode/pool.txt` — flat `model [weight] [b:<bucket>] [notify:on|off]` per line, preferred
+2. `~/.config/lacode/pool.txt` — flat `model [weight] [b:<bucket>] [c:<context>] [notify:on|off]` per line, preferred
 3. `~/.config/lacode/pool.json` (its parent directory is created for you)
 4. the bundled `presets/free-tier.json`
 5. a built-in fallback, so routing always works
@@ -33,6 +33,8 @@ A slot may also declare a shared quota bucket with `b:<name>` on the line (or a
 the sibling would spend the same exhausted window; without one, the model is its
 own bucket. `pool_status` shows each shared bucket's effective capacity.
 
+`c:<context>` is the model's context window in tokens; the router uses it to prefer the smallest model that fits the task, and it is optional for hand-written lines.
+
 Each slot gets a `notify` flag that controls the desktop "rate-limit reset"
 notice raised when a slot that was cooling for a quota/rate-limit reason becomes
 usable again. The default is **provider-based**: on for `opencode` and
@@ -48,6 +50,18 @@ warning. The flag gates only the desktop reset notice, not pool routing or
 status, and pool files are hot-reloaded so changes take effect without a
 restart.
 
+## Modes
+
+Two runtime modes can be seeded from plugin options and toggled from the TUI:
+
+| Command | Effect |
+| --- | --- |
+| `/yolo` | Toggle YOLO. Every permission request that would `ask` is approved automatically; an explicit `deny` still wins. |
+| `/ykb` | Toggle YKB (You Know Better). The agent is told not to ask questions and to continue with its recommendation. A question that still appears is answered with its `(Recommended)` option, or its first option when none is marked. |
+| `/modes` | Show both switches. |
+
+The toggles write `~/.config/lacode/modes.json` (override with `LACODE_MODES_FILE`) and the server picks the change up on the next decision — no restart. Turning a mode on also answers requests that are already pending. The `yolo` / `ykb` plugin options only seed the file on first run; after that, the file wins. A free-text question with no options is left for the user, since there is no option to choose.
+
 
 ## Which models run which agent