@lawaty/lacode 0.7.1 → 0.8.0

package/dist/index.js

@@ -34,12 +34,15 @@ var MAX_CLAIM_AGE_MS = 30 * 60 * 1e3;
 var HANG_COOLDOWN_MS = 10 * 60 * 1e3;
 var UNAVAILABLE_COOLDOWN_MS = 60 * 1e3;
 var MAX_WEIGHT = 100;
+var SLOT_CEILING_FACTOR = 2;
+var slotCeiling = (slot) => slot.weight * SLOT_CEILING_FACTOR;
 var MAX_SLOTS = 4;
 var COOLDOWN_BASE_MS = 60 * 1e3;
 var COOLDOWN_MAX_MS = 15 * 60 * 1e3;
 var QUOTA_COOLDOWN_BASE_MS = 15 * 60 * 1e3;
 var QUOTA_COOLDOWN_MAX_MS = 6 * 60 * 60 * 1e3;
 var STRIKE_DECAY_MS = 30 * 60 * 1e3;
+var STATED_COOLDOWN_MAX_MS = QUOTA_COOLDOWN_MAX_MS;
 var isQuotaReason = (reason) => /quota|limit|rate|too-many|overloaded|429/i.test(reason);
 var BASES = ["explore", "implement", "context"];
 var PRESETS_DIR = join2(PACKAGE_ROOT, "presets");
@@ -207,12 +210,13 @@ var isUnavailableText = (text) => UNAVAILABLE_PATTERN.test(text);
 var TRANSIENT_GATEWAY_PATTERNS = [/queue budget/i, /exceeded queue/i, /aborted due to timeout/i, /timeout/i];
 var isTransientGatewayText = (text) => TRANSIENT_GATEWAY_PATTERNS.some((re) => re.test(text));
 var statedCooldown = (text) => {
-  const hm = /resets?\s+in\s+(\d+)\s*(?:h|hr|hour)s?\s*(\d+)?\s*(?:m|min|minute)?s?/i.exec(text);
-  if (hm) return (Number(hm[1]) * 60 + (hm[2] ? Number(hm[2]) : 0)) * 60 * 1e3;
-  const m = /resets?\s+in\s+(\d+)\s*(?:m|min|minute)s?/i.exec(text);
-  if (m) return Number(m[1]) * 60 * 1e3;
-  const s = /retry[\s-]?in\s+(\d+)\s*(?:s|sec|second)s?/i.exec(text);
-  if (s) return Number(s[1]) * 1e3;
+  const bounded = (ms) => Number.isFinite(ms) && ms > 0 && ms <= STATED_COOLDOWN_MAX_MS ? ms : void 0;
+  const hm = /resets?\s+in\s+(\d+)\s*(?:hour|hr|h)s?\s*(\d+)?\s*(?:minute|min|m)?s?/i.exec(text);
+  if (hm) return bounded((Number(hm[1]) * 60 + (hm[2] ? Number(hm[2]) : 0)) * 60 * 1e3);
+  const m = /resets?\s+in\s+(\d+)\s*(?:minute|min|m)s?/i.exec(text);
+  if (m) return bounded(Number(m[1]) * 60 * 1e3);
+  const s = /retry[\s-]?in\s+(\d+)\s*(?:second|sec|s)s?/i.exec(text);
+  if (s) return bounded(Number(s[1]) * 1e3);
   return void 0;
 };
 var retryAfterMs = (headers) => {
@@ -246,10 +250,14 @@ function state(opts = {}) {
       cooling: /* @__PURE__ */ new Map(),
       strikes: /* @__PURE__ */ new Map(),
       activity: /* @__PURE__ */ new Map(),
+      probes: /* @__PURE__ */ new Set(),
+      probing: false,
+      lastProbe: 0,
       children: /* @__PURE__ */ new Map(),
       reaped: 0,
       reaping: false,
       lastSweep: 0,
+      lastDirSweep: 0,
       id,
       dir,
       modelsFile,
@@ -286,10 +294,88 @@ function init(s, onWarn) {
     onWarn(`claim dir ${s.dir} unusable; pool load tracked in memory only`);
   }
 }
+var STATE_SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
+function sweepStateDir(s) {
+  const removed = [];
+  if (!s.dirReady) return removed;
+  let entries;
+  try {
+    entries = readdirSync(s.dir);
+  } catch {
+    return removed;
+  }
+  const now = Date.now();
+  const drop = (name) => {
+    try {
+      unlinkSync(join2(s.dir, name));
+      removed.push(name);
+    } catch {
+    }
+  };
+  for (const entry of entries) {
+    let age;
+    try {
+      age = now - statSync(join2(s.dir, entry)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (entry.endsWith(".tmp")) {
+      if (age > ORPHAN_TMP_MS) drop(entry);
+      continue;
+    }
+    const claim = /^claims\.(.+)\.json$/.exec(entry);
+    if (claim) {
+      if (claim[1] === s.id) continue;
+      if (/^\d+$/.test(claim[1]) && !isPidAlive(Number(claim[1]))) {
+        drop(entry);
+        continue;
+      }
+      if (age > DEAD_FILE_MS) drop(entry);
+      continue;
+    }
+    if (entry.startsWith("limit.") && entry.endsWith(".json")) {
+      try {
+        const strike = JSON.parse(readFileSync2(join2(s.dir, entry), "utf8"));
+        if (typeof strike.until !== "number") {
+          drop(entry);
+          continue;
+        }
+        if (strike.until > now) continue;
+        if (typeof strike.last === "number" && now - strike.last < STRIKE_DECAY_MS) continue;
+        drop(entry);
+      } catch {
+        drop(entry);
+      }
+    }
+  }
+  return removed;
+}
 function pruneOwn(s) {
   const now = Date.now();
   for (const [key, claim] of s.own) if (now - (claim.hb ?? claim.t) > CLAIM_TTL_MS) s.own.delete(key);
 }
+function pruneActivity(s, now) {
+  if (s.activity.size === 0) return;
+  const live = /* @__PURE__ */ new Set();
+  for (const claim of s.own.values()) if (claim.g) live.add(claim.g);
+  for (const [id, seen] of s.activity) {
+    if (live.has(id)) continue;
+    if (now - seen > CLAIM_TTL_MS) s.activity.delete(id);
+  }
+}
+function pruneChildren(s, now) {
+  if (s.children.size === 0) return;
+  for (const [parent, ring] of s.children) {
+    const fresh = ring.filter((child) => now - child.t <= CHILD_MEMORY_MS);
+    if (fresh.length === 0) s.children.delete(parent);
+    else if (fresh.length !== ring.length) s.children.set(parent, fresh);
+  }
+}
+function pruneSessions(s) {
+  const now = Date.now();
+  pruneActivity(s, now);
+  pruneChildren(s, now);
+}
 function publish(s) {
   if (!s.dirReady) return;
   const now = Date.now();
@@ -435,6 +521,50 @@ function coolUnavailable(s, model) {
   }
   return strike;
 }
+function clearCooldowns(s, models) {
+  const cleared = [];
+  const now = Date.now();
+  const wanted = models && models.length > 0 ? new Set(models) : void 0;
+  let entries;
+  try {
+    entries = readdirSync(s.dir);
+  } catch {
+    return cleared;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("limit.") || !entry.endsWith(".json")) continue;
+    const path4 = join2(s.dir, entry);
+    let strike;
+    try {
+      const parsed = JSON.parse(readFileSync2(path4, "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);
+    } catch {
+      continue;
+    }
+    if (strike === void 0) {
+      cleared.push({ model: entry, reason: "unreadable cooldown file", strikes: 0, secondsLeft: 0 });
+      continue;
+    }
+    s.cooling.delete(strike.model);
+    s.strikes.delete(strike.model);
+    cleared.push({
+      model: strike.model,
+      reason: typeof strike.reason === "string" ? strike.reason : "unknown",
+      strikes: typeof strike.strikes === "number" ? strike.strikes : 0,
+      secondsLeft: typeof strike.until === "number" ? Math.max(0, Math.ceil((strike.until - now) / 1e3)) : 0
+    });
+  }
+  return cleared;
+}
+var markProbe = (s, sessionID) => s.probes.add(sessionID);
+var unmarkProbe = (s, sessionID) => s.probes.delete(sessionID);
+var isProbe = (s, sessionID) => s.probes.has(sessionID);
 function refreshCatalog(s, serverUrl) {
   if (!serverUrl || Date.now() - s.catalogAt < CATALOG_TTL_MS) return;
   s.catalogAt = Date.now();
@@ -457,6 +587,7 @@ function isAvailable(s, model, cooling) {
 }
 function snapshot(s) {
   pruneOwn(s);
+  pruneSessions(s);
   const siblings = readSiblings(s);
   const cooling = readLimits(s);
   const counts = /* @__PURE__ */ new Map();
@@ -466,7 +597,7 @@ function snapshot(s) {
   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) < slot.weight;
+var underCeiling = (slot, counts) => loadOf(counts, slot.model) < slotCeiling(slot);
 function roundRobinSequence(slots) {
   const seq = [];
   for (const slot of slots) for (let turn = 0; turn < slot.weight; turn++) seq.push(slot.index);
@@ -1319,20 +1450,46 @@ on that.
   write only what the client asked for.
 - Say plainly in your report that you created the file.
 
+# Before you write
+
+Read \`.opencode/context/\` first when it is there \u2014 \`architecture.md\`,
+\`conventions.md\` or \`contexts.md\`, whichever bears on the directive \u2014 so you do
+not record a fact the project has already settled, and do not contradict one you
+do not know yet. Read only what is relevant, and carry on if it is missing.
+
+That map is READ-ONLY to you: the \`context\` agent is its only writer. If the
+directive contradicts it, say so plainly in your report and still write what the
+client asked for. Never edit the map to agree with \`AGENTS.md\` \u2014 the two are
+different files with different jobs, and this one is yours alone.
+
 # Reporting
 
 Report briefly what you changed and where. Do not edit any other file.`,
   permission: {
-    // Read is scoped to the one file too: the directive is about AGENTS.md, and
-    // nothing else is any of this agent's business.
+    // Read reaches AGENTS.md and the context map, and nothing else.
+    //
+    // The map is here because the directive is about how work is DONE in this
+    // project and the map is the maintained record of what the project IS: reading
+    // it is how this agent avoids recording a fact the code already settles, and
+    // avoids contradicting one it does not know yet. It stays READ-ONLY — `edit`
+    // below still denies the map, so this grant cannot turn the one-writer rule
+    // into a two-writer rule, and the writer guard does not have to care about it
+    // (it reads `edit` alone).
+    //
+    // Both spellings are required, and every allow must sit AFTER the broad deny:
+    // LAST match wins, so an allow written before "*": "deny" is silently inert.
     read: {
       "*": "deny",
       "AGENTS.md": "allow",
-      "*/AGENTS.md": "allow"
+      "*/AGENTS.md": "allow",
+      "*/.opencode/context/**": "allow",
+      ".opencode/context/**": "allow"
     },
     glob: "deny",
     grep: "deny",
     list: "deny",
+    // Still exactly one writable path. The map is readable (see above) and stays
+    // unwritable: `context` is its only writer, and this agent is not it.
     edit: {
       "*": "deny",
       "AGENTS.md": "allow",
@@ -1468,7 +1625,8 @@ 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 weight ceiling, and which models are cooling.
+   slot's load against its ceiling (twice the slot's weight), and which models
+   are cooling.
 
 2. OmniRoute configured \u2014 inspect the \`@lawaty/lacode\` plugin options in the
    user's opencode config for an \`omniroute\` block with \`enabled: true\`. If it
@@ -1505,7 +1663,7 @@ 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 soft ceiling on concurrent claims and the slot's share of the rotation \u2014 NOT a priority; pick order follows line order.
+   - weight is optional (default 1) and must be a number in (0, ${MAX_WEIGHT}]. It is the slot's share of the rotation \u2014 how many turns it takes per cycle \u2014 and its concurrency ceiling is twice that. 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.
 
@@ -1540,11 +1698,126 @@ function applyCommands(cfg, commands = COMMANDS) {
 
 // src/plugins/agent-pool.ts
 import { tool } from "@opencode-ai/plugin";
+
+// src/lib/probe.ts
+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 failureText = (error) => {
+  if (error === void 0 || error === null) return "";
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error) ?? String(error);
+  } catch {
+    return String(error);
+  }
+};
+var shortReason = (text) => {
+  if (!text) return "failed";
+  const matched = text.match(/rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded/i)?.[0];
+  return matched ? matched.toLowerCase().replace(/[\s_]/g, "-") : 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) => ({
+    model,
+    ok,
+    reason,
+    hadSeconds: leftSeconds,
+    leftSeconds: left
+  });
+  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);
+  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) => {
+      timer = setTimeout(() => {
+        timedOut = true;
+        void client.session.abort({ path: { id: created }, query: { directory } }).catch(() => {
+        });
+        resolve3(void 0);
+      }, timeoutMs);
+    });
+    const answer = client.session.prompt({
+      path: { id: created },
+      query: { directory },
+      body: {
+        model: { providerID: provider, modelID },
+        system: PROBE_SYSTEM,
+        parts: [{ type: "text", text: PROBE_PROMPT }]
+      }
+    }).then(
+      (result2) => result2,
+      (error) => ({ error })
+    );
+    const result = await Promise.race([answer, deadline]);
+    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);
+    }
+    const text = failureText(failure);
+    const stated = statedCooldown(text);
+    if (stated !== void 0) recordStrike(s, model, shortReason(text), stated);
+    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
+    );
+  } finally {
+    if (timer) clearTimeout(timer);
+    const deleted = await client.session.delete({ path: { id: created }, query: { directory } }).then(() => true, () => false);
+    if (deleted) unmarkProbe(s, created);
+  }
+};
+async function probeCooling(client, opts) {
+  const s = opts.state;
+  const now = opts.now ?? Date.now;
+  const empty = { outcomes: [], cleared: [], kept: [], changed: false };
+  if (s.probing) return empty;
+  const cooling = readLimits(s);
+  const at = now();
+  const wanted = opts.models && opts.models.length > 0 ? new Set(opts.models) : void 0;
+  const candidates = [...cooling.values()].filter(
+    (strike) => strike.until > at && (wanted === void 0 || wanted.has(strike.model))
+  );
+  if (candidates.length === 0) return empty;
+  s.probing = true;
+  const outcomes = [];
+  try {
+    for (const strike of candidates.sort((a, b) => a.until - b.until)) {
+      outcomes.push(await probeOne(client, opts, strike.model, Math.ceil((strike.until - at) / 1e3)));
+    }
+  } finally {
+    s.probing = false;
+    s.lastProbe = Date.now();
+  }
+  const reAdmitted = outcomes.filter((o) => o.ok).map((o) => o.model);
+  const stillLimited = outcomes.filter((o) => !o.ok);
+  return {
+    outcomes,
+    cleared: reAdmitted,
+    kept: stillLimited.map((o) => o.model),
+    // A window the provider restated is a change too: the pool now waits a
+    // different length than it did, and the user is the one who set that.
+    changed: reAdmitted.length > 0 || stillLimited.some((o) => o.leftSeconds !== o.hadSeconds)
+  };
+}
+
+// src/plugins/agent-pool.ts
 var SERVICE = "agent-pool";
 var REAP_INTERVAL_MS = 3e4;
 var HANG_FALLBACK_MS = 10 * 60 * 1e3;
+var PROBE_INTERVAL_MS = 15 * 60 * 1e3;
 var ABORT_TIMEOUT_MS = 1e4;
-var agentPoolHooks = (async ({ client, serverUrl }, options) => {
+var formatWindow = (seconds) => seconds < 60 ? `${seconds}s` : `${Math.ceil(seconds / 60)}m`;
+var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
   const opts = options ?? {};
   const s = state(opts);
   ensureUserConfigDir();
@@ -1556,6 +1829,13 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
     await log("warn", message);
   };
   init(s, (m) => void warnOnce(m));
+  const sweepDirIfDue = () => {
+    if (Date.now() - s.lastDirSweep < STATE_SWEEP_INTERVAL_MS) return;
+    s.lastDirSweep = Date.now();
+    const removed = sweepStateDir(s);
+    if (removed.length > 0) void log("info", `swept ${removed.length} stale pool file(s): ${removed.join(", ")}`);
+  };
+  sweepDirIfDue();
   const abortSession = async (sessionID) => {
     if (!serverUrl) return { ok: false, why: "no serverUrl: this process has no HTTP server to abort through" };
     try {
@@ -1597,6 +1877,8 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
     s.reaping = true;
     s.lastSweep = Date.now();
     try {
+      pruneSessions(s);
+      sweepDirIfDue();
       const stuck = findStuck(s);
       if (stuck.length === 0) return;
       const released = [];
@@ -1661,6 +1943,46 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
     "info",
     `reaper armed: every ${Math.round(reapMs / 1e3)}s, aborts a claim older than ${Math.round(STUCK_MIN_AGE_MS / 6e4)}m whose target has been silent ${Math.round(STUCK_IDLE_MS / 6e4)}m, or any claim past the ${Math.round(MAX_CLAIM_AGE_MS / 6e4)}m ceiling however chatty`
   );
+  const EMPTY_REPORT = { outcomes: [], cleared: [], kept: [], changed: false };
+  const reportTitle = (report) => report.outcomes.length === 0 ? "nothing cooling to probe" : `probed ${report.outcomes.length} cooling model(s), re-admitted ${report.cleared.length}`;
+  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 rotation` : `${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.` : "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.kept.length} cooling model(s) re-checked, still limited.`;
+    await log("info", `pool probe: ${message}`, { cleared: report.cleared, kept: report.kept });
+    try {
+      await client.tui?.showToast?.({
+        body: { title: "pool recheck", message, variant: report.cleared.length > 0 ? "success" : "info", duration: 8e3 }
+      });
+    } catch {
+    }
+  };
+  const runProbe = async (models) => {
+    let report = EMPTY_REPORT;
+    try {
+      report = await probeCooling(client, { state: s, directory, models });
+    } catch (error) {
+      await log("error", `pool probe failed: ${String(error)}`);
+      return EMPTY_REPORT;
+    }
+    await announce(report);
+    return report;
+  };
+  const probeMs = opts.probeMs ?? PROBE_INTERVAL_MS;
+  const probeTimer = probeMs > 0 ? setInterval(() => void runProbe(), probeMs) : void 0;
+  probeTimer?.unref?.();
+  void log(
+    "info",
+    probeMs > 0 ? `cooldown probe armed: every ${Math.round(probeMs / 6e4)}m, checks the models that are cooling by using them (one request each, one at a time); 0 to disable` : "cooldown probe disabled (probeMs: 0); use the pool_recheck tool to check on demand"
+  );
   return {
     config: async (cfg) => {
       const slots = ensureSlots(s, (m) => void warnOnce(m));
@@ -1712,6 +2034,10 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
           const reason2 = status2?.action?.reason ?? "";
           if (status2?.type === "retry" && status2.action?.provider && (reason2 === "free_tier_limit" || isLimitText(reason2))) {
             const provider = status2.action.provider;
+            if (sessionID && isProbe(s, sessionID)) {
+              await log("debug", `probe on provider ${provider} was limited (${reason2 || "rate-limited"}); not cooling the provider`);
+              return;
+            }
             const until = typeof status2.next === "number" && status2.next > Date.now() ? status2.next : Date.now() + HANG_FALLBACK_MS;
             const cooled = coolProvider(s, provider, until, reason2 || "rate-limited");
             if (cooled.length > 0) {
@@ -1746,6 +2072,10 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
         const transientGateway = gateway5xx || isTransientGatewayText(haystack);
         if (!limited && !transientGateway) 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;
+        }
         if (isUnavailableText(haystack) || !limited && transientGateway) {
           const transient = coolUnavailable(s, model);
           if (transient) await log("warn", `cooling ${model} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${transient.reason})`);
@@ -1787,15 +2117,22 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
           }
           acquire(s, requested, slot, input.sessionID, claimKey(input.sessionID, input.callID));
           output.args.subagent_type = variant;
-          await log("info", `routed ${requested} -> ${variant}`, {
+          await log("info", `routed ${requested} to slot ${slot.index} on ${slot.model}`, {
             slot: slot.index,
             weight: slot.weight,
             model: slot.model,
-            ceiling: slot.weight,
+            ceiling: slotCeiling(slot),
             load: (snap.counts.get(slot.model) ?? 0) + 1
           });
           return;
         }
+        const pinned = s.models.get(requested);
+        const bench = pinned ? snap.cooling.get(pinned) : void 0;
+        if (pinned && bench) {
+          await warnOnce(
+            `${requested} runs ${pinned}, which is cooling (${bench.reason}, strike ${bench.strikes}) -- it cannot fail over, because only ${BASES.join("/")} are pooled. Drop the model line from ${requested} to route it through the pool, or wait out the cooldown.`
+          );
+        }
       } catch (error) {
         await log("error", `routing failed, spawn unchanged: ${String(error)}`);
       }
@@ -1805,8 +2142,18 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
       release(s, claimKey(input.sessionID, input.callID));
     },
     tool: {
+      pool_recheck: tool({
+        description: "Probe the models the pool has benched and re-admit the ones that answer. Each probe is a real request on that exact model, so it settles what a cooldown can only guess: if the model replies, its cooldown is cleared and it is back in the rotation; if it is still limited, the existing cooldown stands. Call it after resetting a quota in the provider's own console, when the pool feels short of capacity, or to check now instead of waiting for the next automatic pass.",
+        args: {
+          models: tool.schema.array(tool.schema.string()).optional().describe("Model ids to probe, as provider/model-id. Omit to probe every model that is cooling.")
+        },
+        async execute(args) {
+          const report = await runProbe(args?.models);
+          return { title: `agent-pool: ${reportTitle(report)}`, output: reportText(report) };
+        }
+      }),
       pool_status: tool({
-        description: "Show live pool load across every opencode process, per free model and per agent type, each slot's load against its weight ceiling, the slot marked <- next that the next spawn would take, and which models are cooling after a rate limit or a stuck task. Check it before launching many parallel subagents.",
+        description: "Show live pool load across every opencode process, per free model and per agent type, each slot's load against its ceiling, the slot marked <- next that the next spawn would take, and which models are cooling after a rate limit or a stuck task. Check it before launching many parallel subagents.",
         args: {},
         async execute() {
           refreshCatalog(s, serverUrl);
@@ -1835,7 +2182,7 @@ var agentPoolHooks = (async ({ client, serverUrl }, options) => {
             const marker = slot.index === next.index ? " <- next" : "";
             const load = entry?.total ?? 0;
             const atCeiling = !underCeiling(slot, snap.counts);
-            return `  slot ${slot.index} w${slot.weight}  ${slot.model}  load=${load}/${slot.weight}${atCeiling ? " FULL" : ""}${marker}  [${users}${notes.length ? "; " + notes.join("; ") : ""}]`;
+            return `  slot ${slot.index} w${slot.weight}  ${slot.model}  load=${load}/${slotCeiling(slot)}${atCeiling ? " FULL" : ""}${marker}  [${users}${notes.length ? "; " + notes.join("; ") : ""}]`;
           };
           const total = [...snap.counts.values()].reduce((sum, n) => sum + n, 0);
           const coolingNow = [...snap.cooling.entries()].filter(([, st]) => st.until > now);
@@ -1857,6 +2204,10 @@ round robin in slot order, each slot taking as many turns as its weight says, so
               `hung past ${Math.round(STUCK_MIN_AGE_MS / 6e4)}min with ${Math.round(STUCK_IDLE_MS / 6e4)}min silence: ${hung} (auto-aborted); reaped total: ${s.reaped}.`,
               `overran past ${Math.round(MAX_CLAIM_AGE_MS / 6e4)}min: ${overran} (auto-aborted).`,
               `watchdog alive: last sweep ${s.lastSweep ? `${Math.max(0, Math.round((now - s.lastSweep) / 1e3))}s ago` : "never"} (every ${Math.round(reapMs / 1e3)}s).`,
+              // When the cooled models were last USED rather than inferred, because
+              // "still cooling" and "nobody has actually asked it lately" are
+              // different situations and this is the line that tells them apart.
+              probeMs > 0 ? `cooldown probe: last ${s.lastProbe ? `${Math.max(0, Math.round((now - s.lastProbe) / 1e3))}s ago` : "never (nothing has been cooling)"}, every ${Math.round(probeMs / 6e4)}m; call the pool_recheck tool to ask now.` : "cooldown probe: off (probeMs: 0); call the pool_recheck tool to ask now.",
               coolingNow.length === 0 ? "no models cooling down." : `cooling: ${coolingNow.map(([m, st]) => `${m} for ${Math.ceil((st.until - now) / 1e3)}s`).join(", ")}`
             ].join("\n")
           };
@@ -1865,14 +2216,18 @@ round robin in slot order, each slot taking as many turns as its weight says, so
     },
     dispose: async () => {
       clearInterval(timer);
+      if (probeTimer) clearInterval(probeTimer);
       s.own.clear();
+      s.activity.clear();
+      s.children.clear();
       publish(s);
     }
   };
 });
 
 // src/plugins/context-autoupdate.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
 import * as path2 from "node:path";
 
 // src/lib/jsonc.ts
@@ -2028,8 +2383,24 @@ var IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
   ".next",
   ".turbo",
   ".cache",
-  ".git"
+  ".git",
+  // Generated payloads. These are OUTPUT, not source: a single decoded corpus or
+  // derived report in one of these is routinely tens of megabytes, and an agent
+  // that samples one with `head`/`cat` produces a tool output large enough to
+  // be worth recording on its own.
+  "derived_outputs",
+  "derived",
+  "artifacts",
+  "corpus",
+  "corpora"
 ]);
+var NO_BULK_READS = [
+  "Do not read generated, vendored or corpus payloads: `node_modules/`, `dist/`,",
+  "`build/`, `out/`, `*.min.js`, `derived_outputs/`, `*.bytes`, and large `.json`/`.csv`",
+  "corpora. They are megabytes each and describe no architecture. Read the source",
+  "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 findProjectConfig = () => {
   let dir = import.meta.dir ?? path2.dirname(new URL(import.meta.url).pathname);
@@ -2064,6 +2435,33 @@ var changedSince = (before, dir) => {
   for (const name of before.keys()) if (!after.has(name)) changed++;
   return changed;
 };
+var RETAIN_TRANSCRIPTS = 20;
+var transcriptDir = () => process.env.LACODE_TRANSCRIPT_DIR ?? path2.join(homedir2(), ".local", "share", "opencode", "lacode", "cartographer");
+var retireSession = async (client, directory, sessionID, mode) => {
+  try {
+    const transcript = await client.session.messages({ path: { id: sessionID }, query: { directory } }).then((r) => r.data).catch(() => void 0);
+    const dir = transcriptDir();
+    mkdirSync2(dir, { recursive: true });
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const file = path2.join(dir, `${stamp}-${mode}.json`);
+    writeFileSync2(file, JSON.stringify({ sessionID, mode, messages: transcript ?? null }, null, 2));
+    pruneTranscripts(dir);
+    await client.session.delete({ path: { id: sessionID }, query: { directory } }).catch(() => void 0);
+  } catch {
+  }
+};
+var pruneTranscripts = (dir) => {
+  try {
+    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 {
+        unlinkSync2(path2.join(dir, name));
+      } catch {
+      }
+    }
+  } catch {
+  }
+};
 var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
   const pending = /* @__PURE__ */ new Set();
   const owned = /* @__PURE__ */ new Map();
@@ -2097,6 +2495,8 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
     "This session touched these paths (starting context, not an exhaustive list):",
     listed(files),
     "",
+    NO_BULK_READS,
+    "",
     "Follow the bootstrap procedure in your system prompt: progressive exploration, then write the five context files within their size targets. 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,
@@ -2104,6 +2504,8 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
     "This session touched these paths (start from these and their immediate architectural neighborhood):",
     listed(files),
     "",
+    NO_BULK_READS,
+    "",
     '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 a previously undocumented invariant. Do not edit documentation merely because source files changed. If nothing material changed, make no edits and report "no update needed".'
   ].join("\n");
   return {
@@ -2119,6 +2521,7 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
           lastRun = Date.now();
           return;
         }
+        if (isProbe(state2, sessionID)) return;
         const now = Date.now();
         for (const [id, startedAt] of owned) if (now - startedAt > OWNED_TTL_MS) owned.delete(id);
         if (owned.size > 0) return;
@@ -2163,6 +2566,7 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
           body: { agent, parts: [{ type: "text", text: compose(mode, files) }] }
         }).then(async (result) => {
           release(state2, claimKey2);
+          await retireSession(client, directory, target, mode);
           const failure = result.error ?? result.data?.info?.error;
           if (failure) {
             requeue();
@@ -2186,6 +2590,7 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
           }
         }).catch(async (error) => {
           release(state2, claimKey2);
+          await retireSession(client, directory, target, mode);
           requeue();
           await log("error", `auto ${mode} failed: ${String(error)}`);
         });
@@ -2372,6 +2777,9 @@ var Notifier = class {
 // src/plugins/notify.ts
 var SERVICE3 = "notify";
 var COOLDOWN_MS2 = 5e3;
+var MAX_INFLIGHT_HELPERS = 4;
+var HELPER_TIMEOUT_MS = 3e4;
+var MAX_TRACKED_SESSIONS = 500;
 var SOUND_ENV = "LACODE_SOUND";
 var SOUND_OFF_VALUES = ["0", "false", "off", "no"];
 var findHelper = () => {
@@ -2388,6 +2796,8 @@ var findHelper = () => {
   return void 0;
 };
 var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
+  const maxInflight = deps.maxInflightHelpers ?? MAX_INFLIGHT_HELPERS;
+  const helperTimeoutMs = deps.helperTimeoutMs ?? HELPER_TIMEOUT_MS;
   const opts = options ?? {};
   const soundEnv = (process.env[SOUND_ENV] ?? "").trim().toLowerCase();
   const soundOn = !SOUND_OFF_VALUES.includes(soundEnv) && opts.sound !== false;
@@ -2397,6 +2807,15 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
   const pending = /* @__PURE__ */ new Set();
   const permissions = /* @__PURE__ */ new Set();
   let warnedHelper = false;
+  let inflight = 0;
+  const rememberActive = (sessionID) => {
+    active.add(sessionID);
+    while (active.size > MAX_TRACKED_SESSIONS) active.delete(active.values().next().value);
+  };
+  const rememberTitle = (id, title) => {
+    titles.set(id, title);
+    while (titles.size > MAX_TRACKED_SESSIONS) titles.delete(titles.keys().next().value);
+  };
   const log = (level, message, extra) => client.app.log({ body: { service: SERVICE3, level, message, extra } }).catch(() => {
   });
   const fetchInfo = async (sessionID) => {
@@ -2404,6 +2823,11 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
     return info;
   };
   const deliverViaHelper = (title, message, urgency, sound) => new Promise((resolve3) => {
+    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})` });
+      return;
+    }
     const helper = findHelper();
     if (!helper) {
       if (!warnedHelper) {
@@ -2417,13 +2841,32 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       stdio: ["ignore", "ignore", "pipe"],
       detached: true
     });
+    inflight++;
+    let settled = false;
+    let timer;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      inflight--;
+      if (timer) clearTimeout(timer);
+      resolve3(result);
+    };
+    timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      void log("warn", `notification helper timed out after ${helperTimeoutMs}ms`, { title });
+      finish({ ok: false, detail: `helper timed out after ${helperTimeoutMs}ms` });
+    }, helperTimeoutMs);
+    timer.unref?.();
     let stderr = "";
     child.stderr?.on("data", (chunk) => {
       if (stderr.length < 400) stderr += String(chunk);
     });
     child.on("error", (error) => {
       void log("warn", `notification helper failed: ${String(error)}`, { title });
-      resolve3({ ok: false, detail: String(error) });
+      finish({ ok: false, detail: String(error) });
     });
     child.on("exit", (code) => {
       const noise = stderr.trim();
@@ -2434,7 +2877,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
           message
         });
       }
-      resolve3({ ok, detail: noise || void 0 });
+      finish({ ok, detail: noise || void 0 });
     });
     child.unref();
   });
@@ -2489,12 +2932,12 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       try {
         if (event.type === "session.status") {
           const { sessionID: sessionID2, status } = event.properties;
-          if (status.type === "busy" && sessionID2) active.add(sessionID2);
+          if (status.type === "busy" && sessionID2) rememberActive(sessionID2);
           return;
         }
         if (event.type === "session.updated") {
           const info = event.properties.info;
-          if (info?.id) titles.set(info.id, info.title);
+          if (info?.id) rememberTitle(info.id, info.title);
           return;
         }
         if (event.type === "question.asked") {
@@ -2502,7 +2945,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
           const sessionID2 = properties?.sessionID;
           if (!sessionID2) return;
           pending.add(sessionID2);
-          active.add(sessionID2);
+          rememberActive(sessionID2);
           const headline = questionHeadline(properties.questions);
           void announce(sessionID2, "question", headline || void 0);
           return;
@@ -2517,7 +2960,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
           const sessionID2 = properties?.sessionID;
           if (!sessionID2) return;
           permissions.add(sessionID2);
-          active.add(sessionID2);
+          rememberActive(sessionID2);
           void announce(sessionID2, "permission", permissionHeadline(properties) || void 0);
           return;
         }
@@ -2730,6 +3173,12 @@ function createSelector(config, deps = {}) {
   const now = deps.now ?? Date.now;
   const stats = /* @__PURE__ */ new Map();
   const sticky = /* @__PURE__ */ new Map();
+  const MAX_STICKY = 500;
+  const rememberSticky = (sessionID, modelID) => {
+    sticky.delete(sessionID);
+    sticky.set(sessionID, modelID);
+    while (sticky.size > MAX_STICKY) sticky.delete(sticky.keys().next().value);
+  };
   let cands = [];
   const ensure = (modelID) => {
     let stat = stats.get(modelID);
@@ -2766,7 +3215,10 @@ function createSelector(config, deps = {}) {
       if (list.length === 0) return null;
       if (config.stickyPerSession) {
         const held = sticky.get(sessionID);
-        if (held !== void 0 && list.includes(held) && !cooling(held)) return held;
+        if (held !== void 0 && list.includes(held) && !cooling(held)) {
+          rememberSticky(sessionID, held);
+          return held;
+        }
       }
       let bestID = null;
       let bestStat = null;
@@ -2781,7 +3233,7 @@ function createSelector(config, deps = {}) {
         }
       }
       if (bestID === null) return null;
-      if (config.stickyPerSession) sticky.set(sessionID, bestID);
+      if (config.stickyPerSession) rememberSticky(sessionID, bestID);
       return bestID;
     },
     stickyFor(sessionID) {
@@ -2813,6 +3265,9 @@ function createSelector(config, deps = {}) {
       const out = {};
       for (const [id, stat] of stats) out[id] = { ...stat };
       return out;
+    },
+    stickySize() {
+      return sticky.size;
     }
   };
 }
@@ -3032,8 +3487,8 @@ var omniRouteHooks = async (input, options, deps = {}) => {
 
 // src/lib/selfupdate.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, statSync as statSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2, writeSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { closeSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, statSync as statSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3, writeSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
 import { dirname as dirname3, join as join6, resolve as resolve2 } from "node:path";
 var REGISTRY_LATEST = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
@@ -3043,7 +3498,7 @@ var LOCK_STALE_MS = 10 * 60 * 1e3;
 var CHILD_ENV = "LACODE_SELFUPDATE_CHILD";
 var OPT_OUT_ENV = "LACODE_NO_SELFUPDATE";
 var inTestRunner = (env = process.env) => typeof env.NODE_TEST_CONTEXT === "string" && env.NODE_TEST_CONTEXT.length > 0;
-var STATE_DIR = join6(homedir2(), ".local", "share", "opencode", "lacode");
+var STATE_DIR = join6(homedir3(), ".local", "share", "opencode", "lacode");
 var STATE_PATH = join6(STATE_DIR, "selfupdate.json");
 var LOCK_PATH = join6(STATE_DIR, "selfupdate.lock");
 function compareSemver(a, b) {
@@ -3100,7 +3555,7 @@ function resolveOpencodeBin(execPath = process.execPath, env = process.env, exis
     const candidate = join6(dir, "opencode");
     if (exists(candidate)) return candidate;
   }
-  const fallback = join6(homedir2(), ".opencode", "bin", "opencode");
+  const fallback = join6(homedir3(), ".opencode", "bin", "opencode");
   return exists(fallback) ? fallback : void 0;
 }
 async function fetchLatest(fetchImpl = fetch, timeoutMs = FETCH_TIMEOUT_MS) {
@@ -3126,8 +3581,8 @@ function readState(path4 = STATE_PATH) {
 }
 function writeState(state2, path4 = STATE_PATH) {
   try {
-    mkdirSync2(dirname3(path4), { recursive: true });
-    writeFileSync2(path4, JSON.stringify(state2));
+    mkdirSync3(dirname3(path4), { recursive: true });
+    writeFileSync3(path4, JSON.stringify(state2));
   } catch {
   }
 }
@@ -3147,13 +3602,13 @@ function acquireLock(path4 = LOCK_PATH, now = Date.now()) {
     closeSync(fd);
     return () => {
       try {
-        unlinkSync2(path4);
+        unlinkSync3(path4);
       } catch {
       }
     };
   };
   try {
-    mkdirSync2(dirname3(path4), { recursive: true });
+    mkdirSync3(dirname3(path4), { recursive: true });
     return claim();
   } catch {
     let orphaned = false;
@@ -3172,7 +3627,7 @@ function acquireLock(path4 = LOCK_PATH, now = Date.now()) {
     }
     if (!orphaned) return void 0;
     try {
-      unlinkSync2(path4);
+      unlinkSync3(path4);
     } catch {
       return void 0;
     }