@lawaty/lacode 2.3.0-beta.4 → 2.3.0-beta.6

package/dist/index.js

@@ -39,14 +39,16 @@ var UNAVAILABLE_COOLDOWN_MS = 60 * 1e3;
 var UNAVAILABLE_REASON = "endpoint-unavailable";
 var PROVIDER_DEGRADED_REASON = "provider-degraded";
 var PROVIDER_DEGRADED_COOLDOWN_MS = 30 * 60 * 1e3;
+var SCAN_KEPT_REASON = "scan-kept";
 var PROVIDER_DEGRADED_WINDOW_MS = 10 * 60 * 1e3;
 var PROVIDER_DEGRADED_MIN_MODELS = 2;
 var TRANSIENT_DEGRADATION_REASONS = /^(?:no answer|no-answer|hang|timeout|timed out|endpoint-unavailable|provider-degraded|empty response|network|server)$/i;
 var FLAT_OUTAGE_REASONS = /* @__PURE__ */ new Set([UNAVAILABLE_REASON, PROVIDER_DEGRADED_REASON]);
 var MAX_WEIGHT = 100;
+var MAX_CEILING = MAX_WEIGHT;
 var MIN_SLOT_CONTEXT = 1e5;
 var MIN_SLOT_TPM = 2e4;
-var slotCeiling = (slot) => slot.weight;
+var slotCeiling = (slot) => slot.ceiling ?? slot.weight;
 var slotBucket = (slot) => slot.bucket ?? slot.model;
 var NOTIFY_DEFAULT_ON_PROVIDERS = /* @__PURE__ */ new Set(["opencode", "opencode-go"]);
 var notifyDefault = (model) => {
@@ -66,7 +68,7 @@ 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 isQuotaReason = (reason) => /quota|limit|rate|too-many|overloaded|budget|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";
@@ -75,6 +77,16 @@ var MODEL_MISSING_PATTERN = /model\s+(?:not\s+found|does\s+not\s+exist|is\s+not\
 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 ABORT_PATTERN = /MessageAbortedError|"name"\s*:\s*"[^"]*Abort/i;
+var isAbortText = (text) => ABORT_PATTERN.test(text);
+var INVALID_REQUEST_REASON = "invalid-request";
+var INVALID_REQUEST_COOLDOWN_MS = MODEL_MISSING_COOLDOWN_MS;
+var UNSUPPORTED_PARAMETER_PATTERN = /not\s+a\s+supported\s+value|unsupported\s+(?:value|parameter|field)|(?:invalid|unknown)\s+(?:value|parameter)\s+for|is\s+not\s+supported/i;
+var isUnsupportedParameterText = (text) => UNSUPPORTED_PARAMETER_PATTERN.test(text);
+var TRANSIENT_UPSTREAM_REASON = "upstream-transient";
+var TRANSIENT_UPSTREAM_COOLDOWN_MS = 60 * 1e3;
+var TRANSIENT_UPSTREAM_PATTERN = /reasoning_display/i;
+var isTransientUpstreamText = (text) => TRANSIENT_UPSTREAM_PATTERN.test(text);
 var BASES = ["explore", "implement", "context"];
 var LEARNED_TPM_FILE = "learned-tpm.json";
 var PRESETS_DIR = join2(PACKAGE_ROOT, "presets");
@@ -101,64 +113,100 @@ var coerceNotify = (raw, at, model, problems) => {
   problems.push(`${at} (${model}): notify must be a boolean or one of on/off, got ${JSON.stringify(raw)}; keeping the provider default`);
   return notifyDefault(model);
 };
+var FALLBACK_MARKER = /^(?:#\s*-*\s*fallback(?:\s+slots)?\s*-*|\[fallback\])$/i;
+var isFallbackMarker = (line) => FALLBACK_MARKER.test(String(line).trim());
+function parseSlotEntry(entry, at, problems) {
+  const model = typeof entry?.model === "string" ? entry.model.trim() : "";
+  if (!model.includes("/")) {
+    problems.push(`${at}: model must be written provider/model-id, got "${model}"`);
+    return void 0;
+  }
+  const weight = readWeight(entry, at, model, problems);
+  const ceiling = readCeiling(entry, weight, at, model, problems);
+  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`);
+  }
+  const notify = coerceNotify(entry.notify, at, model, problems);
+  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 void 0;
+  }
+  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 void 0;
+  }
+  return { index: 0, model, weight, ...ceiling === void 0 ? {} : { ceiling }, ...bucket ? { bucket } : {}, notify, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } };
+}
 function parseSlots(parsed, origin) {
   const problems = [];
-  const entries = parsed?.slots;
-  if (!Array.isArray(entries) || entries.length === 0) {
+  const primaryEntries = parsed?.slots;
+  const fallbackEntries = parsed?.fallbackSlots;
+  if ((!Array.isArray(primaryEntries) || primaryEntries.length === 0) && (!Array.isArray(fallbackEntries) || fallbackEntries.length === 0)) {
     return { slots: FALLBACK_SLOTS, problems: [`${origin} has no non-empty "slots" array; using built-in defaults`] };
   }
-  const slots = [];
-  entries.forEach((entry, i) => {
-    const model = typeof entry?.model === "string" ? entry.model.trim() : "";
-    const at = `slot ${i + 1}`;
-    if (!model.includes("/")) return problems.push(`${at}: model must be written provider/model-id, got "${model}"`);
-    const weight = readWeight(entry, at, model, problems);
-    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`);
-    }
-    const notify = coerceNotify(entry.notify, at, model, problems);
-    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;
+  const parseList = (list, fallback2) => {
+    if (!Array.isArray(list)) return [];
+    const out = [];
+    list.forEach((entry, i) => {
+      const slot = parseSlotEntry(entry, `${fallback2 ? "fallback slot" : "slot"} ${i + 1}`, problems);
+      if (slot) out.push({ ...slot, ...fallback2 ? { fallback: true } : {} });
+    });
+    return out;
+  };
+  const primary = parseList(primaryEntries, false);
+  let fallback = parseList(fallbackEntries, true);
+  const primaryBuckets = new Set(primary.map((slot) => slotBucket(slot)));
+  const primaryModels = new Set(primary.map((slot) => slot.model));
+  fallback = fallback.filter((slot) => {
+    const shared = primaryModels.has(slot.model) || primaryBuckets.has(slotBucket(slot));
+    if (shared) {
+      problems.push(
+        `fallback slot (${slot.model}): shares a limit window with the primary pool (${slotBucket(slot)}); dropping it`
+      );
+      return false;
     }
-    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } });
+    return true;
   });
+  const slots = [...primary, ...fallback].map((slot, i) => ({ ...slot, index: i + 1 }));
   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`);
+  if (primary.length === 0) {
+    problems.push(`${origin} yielded no usable primary slot; using built-in defaults`);
     return { slots: FALLBACK_SLOTS, problems };
   }
   return { slots, problems };
 }
 function parseTextSlots(text, origin) {
   const entries = [];
+  const fallbackEntries = [];
+  let section = "primary";
   for (const raw of text.split(/\r?\n/)) {
+    if (isFallbackMarker(raw)) {
+      section = "fallback";
+      continue;
+    }
     const line = raw.split("#")[0].trim();
     if (!line) continue;
     const [model, ...rest] = line.split(/\s+/);
     let weight;
+    let ceiling;
     let bucket;
     let notify;
     let context;
@@ -168,6 +216,13 @@ function parseTextSlots(text, origin) {
         if (notify === void 0) notify = token.slice("notify:".length);
         continue;
       }
+      if (token.startsWith("ceil:")) {
+        if (ceiling === void 0) {
+          const parsedCeiling = Number(token.slice("ceil:".length));
+          if (Number.isFinite(parsedCeiling) && parsedCeiling > 0) ceiling = parsedCeiling;
+        }
+        continue;
+      }
       if (token.startsWith("c:")) {
         if (context === void 0) {
           const parsedContext = Number(token.slice(2));
@@ -188,9 +243,11 @@ function parseTextSlots(text, origin) {
         weight = token;
       }
     }
-    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify }, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } });
+    const entry = { model, ...weight === void 0 ? {} : { weight }, ...ceiling === void 0 ? {} : { ceiling }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify }, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } };
+    if (section === "fallback") fallbackEntries.push(entry);
+    else entries.push(entry);
   }
-  return parseSlots({ slots: entries }, origin);
+  return parseSlots({ slots: entries, ...fallbackEntries.length > 0 ? { fallbackSlots: fallbackEntries } : {} }, origin);
 }
 function parseSlotText(text, origin) {
   if (text.trimStart().startsWith("{")) {
@@ -295,6 +352,20 @@ function readWeight(entry, at, model, problems) {
   }
   return weight;
 }
+function readCeiling(entry, weight, at, model, problems) {
+  const raw = entry?.ceiling;
+  if (raw === void 0) return void 0;
+  const ceiling = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isFinite(ceiling) || ceiling <= 0 || ceiling > MAX_CEILING) {
+    problems.push(`${at} (${model}): ceiling must be a number in (0, ${MAX_CEILING}], got ${JSON.stringify(raw)}; using the weight`);
+    return void 0;
+  }
+  if (ceiling < weight) {
+    problems.push(`${at} (${model}): ceiling ${ceiling} is below weight ${weight}; using the weight as the ceiling`);
+    return void 0;
+  }
+  return Math.floor(ceiling);
+}
 var UNAVAILABLE_PATTERN = /endpoint\s+is\s+unavailable/i;
 var LIMIT_PATTERNS = [
   /rate[\s_-]?limit/i,
@@ -302,6 +373,7 @@ var LIMIT_PATTERNS = [
   /too many requests/i,
   /\b429\b/,
   /quota/i,
+  /budget\s+exhausted|api\s+budget/i,
   /freelimiterror/i,
   /overloaded/i,
   UNAVAILABLE_PATTERN
@@ -345,7 +417,7 @@ function parseRateLimitHeaders(headers) {
   }
   return void 0;
 }
-var LIMIT_REASON_PATTERN = /rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded|limits?[\s_-]?(?:reached|exceeded)/i;
+var LIMIT_REASON_PATTERN = /rate[\s_-]?limit|usage limit|too many requests|quota|budget\s+exhausted|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) => {
   if (!isLimitText(text)) return void 0;
@@ -435,7 +507,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}:${slot.bucket ?? ""}:${slotNotify(slot) ? "1" : "0"}:${slot.tpm ?? ""}`).join("|")}`;
+var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.ceiling ?? ""}:${slot.bucket ?? ""}:${slotNotify(slot) ? "1" : "0"}:${slot.tpm ?? ""}:${slot.fallback ? "f" : "p"}`).join("|")}`;
 function reloadSlots(s, onWarn) {
   const { slots, problems, origin } = resolveModels({ models: s.inlineModels, modelsFile: s.modelsFile });
   const effective = applyLearnedTpm(s, slots, onWarn);
@@ -695,7 +767,7 @@ function readLimits(s) {
     try {
       const strike = JSON.parse(readFileSync2(path4, "utf8"));
       if (typeof strike.until !== "number" || typeof strike.model !== "string") continue;
-      const countsAsStrike = strike.reason !== UNAVAILABLE_REASON;
+      const countsAsStrike = strike.reason !== UNAVAILABLE_REASON && strike.reason !== SCAN_KEPT_REASON;
       if (strike.until > now) {
         cooling.set(strike.model, strike);
         if (countsAsStrike) memory.set(strike.model, strike);
@@ -849,52 +921,54 @@ function snapshot(s) {
 }
 var loadOf = (counts, slot) => counts.get(slot) ?? 0;
 var underCeiling = (slot, counts) => loadOf(counts, slot.index) < slotCeiling(slot);
+var fillPassIndex = (slot, counts) => Math.floor(loadOf(counts, slot.index) / Math.max(1, slot.weight));
+var pickByPass = (group, counts, prefer) => {
+  const open = group.filter((slot) => underCeiling(slot, counts));
+  if (open.length === 0) return void 0;
+  const lowest = Math.min(...open.map((slot) => fillPassIndex(slot, counts)));
+  const atPass = open.filter((slot) => fillPassIndex(slot, counts) === lowest);
+  return prefer ? atPass.reduce(prefer, atPass[0]) : atPass[0];
+};
 function pickSlot(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
-  const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const primary = slots.filter((slot) => !slot.fallback);
+  const fallback = slots.filter((slot) => slot.fallback);
+  const usablePrimary = primary.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const usable = usablePrimary.length > 0 ? usablePrimary : fallback.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);
+  const leastLoaded = (best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best;
   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]);
+    return pickByPass(usable, snap.counts) ?? usable.reduce(leastLoaded, 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;
+  const smallest = (best, slot) => Number.isFinite(effective(slot)) && effective(slot) < effective(best) ? slot : best;
   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]);
+      return pickByPass(largestSlots, snap.counts) ?? largestSlots.reduce(leastLoaded, 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]);
-  }
-  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 pickByPass(candidates, snap.counts) ?? candidates.reduce(leastLoaded, candidates[0]);
   }
-  return candidates.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, candidates[0]);
+  return pickByPass(candidates, snap.counts, smallest) ?? candidates.reduce(leastLoaded, candidates[0]);
 }
 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));
+  const primary = slots.filter((slot) => !slot.fallback);
+  const fallback = slots.filter((slot) => slot.fallback);
+  const usablePrimary = primary.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const usable = usablePrimary.length > 0 ? usablePrimary : fallback.filter((slot) => isAvailable(s, slot.model, snap.cooling));
   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";
+  const open = pool.filter((slot) => underCeiling(slot, snap.counts));
+  if (open.length === 0) return "overflow";
+  return Math.min(...open.map((slot) => fillPassIndex(slot, snap.counts))) + 1;
 }
 function agentFor(base, slot) {
   return `${base}-${slot}`;
@@ -2166,7 +2240,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 budget (its weight), and which models
+   slot's load against its ceiling, and which models
    are cooling.
 
 2. OmniRoute configured \u2014 inspect the \`@lawaty/lacode\` plugin options in the
@@ -2202,9 +2276,11 @@ The pool is ONE global slot table shared by every pooled base (explore, implemen
 1. Establish the baseline. Read \`${USER_MODELS_TXT}\`. If it is absent, the pool is resolving from the bundled preset \`presets/free-tier.json\`; read that file to learn what is in effect. Call the \`pool_status\` tool only if you need live load or cooldown state.
 
 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]\`
+   - one slot per line: \`<provider>/<model-id>  [weight]  [ceil:<max-parallel>]  [c:<context>]  [b:<bucket>]\`
    - 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.
+   - weight is optional (default 1) and must be a number in (0, ${MAX_WEIGHT}]. It is the slot's per-pass budget \u2014 how many concurrent sessions one pass may add. The pool's total capacity is the sum of the ceilings (which equals the sum of the weights when no ceiling is set). NOT a priority; pick order follows line order.
+   - \`ceil:<max-parallel>\` is optional and is the slot's hard concurrency cap (its max parallel sessions). It must be at least the weight; later passes deepen a slot toward it after every slot has had its weight. Absent means the ceiling equals the weight (one pass).
+   - a line that is exactly \`# --- fallback ---\` starts the fallback section. Keep it and the slots below it when rewriting the file: those slots are used only when no primary slot is usable, and each must not share a bucket or model with the primary.
    - \`#\` starts a comment (whole-line or trailing); blank lines are ignored.
    If the instruction names a model ambiguously, stop and ask rather than guessing.
 
@@ -2527,7 +2603,9 @@ async function maybeSelfUpdate(opts) {
 }
 
 // src/plugins/agent-pool.ts
-import { unwatchFile, watchFile } from "node:fs";
+import { readFileSync as readFileSync5, unwatchFile, watchFile } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
 import { tool } from "@opencode-ai/plugin";
 
 // src/lib/probe.ts
@@ -3179,6 +3257,43 @@ function estimateContextTokens(prompt) {
   if (typeof prompt !== "string" || prompt.length === 0) return void 0;
   return Math.ceil(prompt.length / 4) + CONTEXT_HEADROOM_TOKENS;
 }
+var poolHealthLines = (slots, now) => {
+  const lines = [];
+  const heads = slots.filter((slot) => slot.model.startsWith("opencode-go/"));
+  const headOk = heads.length > 0 && slots.slice(0, heads.length).every((slot) => slot.model.startsWith("opencode-go/"));
+  const tail = slots[slots.length - 1];
+  const tailOk = !!tail && tail.model.startsWith("opencode/") && tail.bucket === "opencode";
+  const verdict = headOk && tailOk ? "intact" : "BROKEN";
+  lines.push(
+    `pool structure: ${verdict} (${slots.length}/10 slots, head=${headOk ? `${heads.length} opencode-go` : "missing"}, tail=${tailOk ? tail.model : "missing"})`
+  );
+  try {
+    const text = readFileSync5(join6(homedir4(), ".config", "lacode", "pool.txt"), "utf8");
+    const stamp = /^#\s*Refreshed\s+(\S+)/m.exec(text)?.[1];
+    if (stamp) {
+      const ageMs = now - Date.parse(stamp);
+      if (Number.isFinite(ageMs) && ageMs >= 0) {
+        const mins = Math.floor(ageMs / 6e4);
+        lines.push(`last refresh: ${mins < 60 ? `${mins}m ago` : `${Math.floor(mins / 60)}h${mins % 60}m ago`} (${stamp})`);
+      }
+    }
+  } catch {
+  }
+  try {
+    const raw = readFileSync5(join6(homedir4(), ".config", "lacode", "provider-status.json"), "utf8");
+    const status = JSON.parse(raw);
+    if (status && typeof status === "object") {
+      const ageS = typeof status.checkedAt === "number" ? Math.max(0, Math.round((now - status.checkedAt) / 1e3)) : -1;
+      const bad = (status.services ?? []).filter((entry) => String(entry?.status ?? "") !== "operational");
+      const detail = bad.length > 0 ? `: ${bad.map((entry) => `${entry.service}=${entry.status}`).join(", ")}` : "";
+      lines.push(
+        `status page: ${status.ok === false ? "unreachable" : status.overall ?? "unknown"}${detail}${ageS >= 0 ? ` (checked ${ageS}s ago)` : ""}`
+      );
+    }
+  } catch {
+  }
+  return lines;
+};
 var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
   const opts = options ?? {};
   const notify = opts.notify ?? ((title, message) => void notifyDesktop(title, message));
@@ -3862,6 +3977,8 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           const auth2 = isAuthFailureText(haystack2) || status2 === 401 || status2 === 403;
           const limited2 = isLimitText(haystack2) || status2 === 429;
           const outage = isUnavailableText(haystack2);
+          const transientUpstream2 = status2 === 400 && isTransientUpstreamText(haystack2) && !auth2 && !limited2 && !outage;
+          const unsupported2 = status2 === 400 && error?.data?.isRetryable === false && isUnsupportedParameterText(haystack2) && !transientUpstream2 && !auth2 && !limited2 && !outage;
           if (missing2) {
             const unbound = !own && sessionID ? [...s.own.entries()].find(([, claim]) => !claim.g && claim.s === sessionID && haystack2.includes(claim.m)) : void 0;
             const target = own ?? (unbound ? { key: unbound[0], claim: unbound[1] } : void 0);
@@ -3887,6 +4004,30 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
             }
             return;
           }
+          if (transientUpstream2) {
+            if (own) {
+              const transient = coolUnavailable(s, own.claim.m, TRANSIENT_UPSTREAM_COOLDOWN_MS, TRANSIENT_UPSTREAM_REASON);
+              recordFailure(s, {
+                ts: Date.now(),
+                source: "observed",
+                base: own.claim.v,
+                slot: own.claim.k,
+                model: own.claim.m,
+                session: sessionID,
+                reason: TRANSIENT_UPSTREAM_REASON,
+                elapsedMs: Date.now() - own.claim.t,
+                released: true,
+                detail: haystack2.slice(0, 400)
+              });
+              release(s, own.key);
+              await log(
+                "warn",
+                transient ? `cooling ${own.claim.m} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${TRANSIENT_UPSTREAM_REASON}) after a flaky upstream error` : `released ${own.claim.v} claim on ${own.claim.m} after a flaky upstream error`,
+                { base: own.claim.v, model: own.claim.m, slot: own.claim.k, session: sessionID }
+              );
+            }
+            return;
+          }
           const isTpm2 = isRequestTooLargeText(haystack2);
           const statedLimit2 = isTpm2 ? parseStatedTokenLimit(haystack2) : void 0;
           const headers2 = error?.data?.responseHeaders;
@@ -3913,23 +4054,40 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           if (!limited2 && !outage && !auth2) {
             if (own) {
               const detail = haystack2.slice(0, 400);
-              recordFailure(s, {
-                ts: Date.now(),
-                source: "observed",
-                base: own.claim.v,
-                slot: own.claim.k,
-                model: own.claim.m,
-                session: sessionID,
-                reason: "provider error",
-                elapsedMs: Date.now() - own.claim.t,
-                released: true,
-                detail
-              });
-              if (!observedErrors.has(own.key)) {
-                observedErrors.set(own.key, { reason: "provider error", detail });
-                if (observedErrors.size > 32) {
-                  const oldest = observedErrors.keys().next().value;
-                  if (oldest !== void 0) observedErrors.delete(oldest);
+              const aborted = isAbortText(haystack2);
+              const reason2 = unsupported2 ? INVALID_REQUEST_REASON : "provider error";
+              if (!aborted) {
+                recordFailure(s, {
+                  ts: Date.now(),
+                  source: "observed",
+                  base: own.claim.v,
+                  slot: own.claim.k,
+                  model: own.claim.m,
+                  session: sessionID,
+                  reason: reason2,
+                  elapsedMs: Date.now() - own.claim.t,
+                  released: true,
+                  detail
+                });
+                if (!observedErrors.has(own.key)) {
+                  observedErrors.set(own.key, { reason: reason2, detail });
+                  if (observedErrors.size > 32) {
+                    const oldest = observedErrors.keys().next().value;
+                    if (oldest !== void 0) observedErrors.delete(oldest);
+                  }
+                }
+                const strike2 = recordStrike(
+                  s,
+                  own.claim.m,
+                  reason2,
+                  unsupported2 ? INVALID_REQUEST_COOLDOWN_MS : void 0
+                );
+                if (strike2) {
+                  await log(
+                    "warn",
+                    `bench ${own.claim.m} (${reason2}, strike ${strike2.strikes}, ${Math.round((strike2.until - Date.now()) / 1e3)}s) after a terminal session error`,
+                    { model: own.claim.m, slot: own.claim.k, session: sessionID, reason: detail }
+                  );
                 }
               }
               release(s, own.key);
@@ -4054,6 +4212,8 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         const gateway5xx = status !== void 0 && status >= 500 && status <= 599;
         const transientGateway = gateway5xx || isTransientGatewayText(haystack);
         const missing = isModelMissingText(haystack);
+        const transientUpstream = status === 400 && isTransientUpstreamText(haystack) && !auth && !limited && !transientGateway;
+        const unsupported = status === 400 && info.error.data?.isRetryable === false && isUnsupportedParameterText(haystack) && !transientUpstream && !auth && !limited && !transientGateway;
         const model = `${info.providerID ?? "?"}/${info.modelID ?? "?"}`;
         const ownMsg = claimFor(info.sessionID);
         const isTpm = isRequestTooLargeText(haystack);
@@ -4080,24 +4240,36 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         if (!limited && !transientGateway && !auth && !missing) {
           const ownMsgUnclassified = ownMsg;
           if (ownMsgUnclassified) {
-            recordFailure(s, {
-              ts: Date.now(),
-              source: "observed",
-              base: ownMsgUnclassified.claim.v,
-              slot: ownMsgUnclassified.claim.k,
-              model: ownMsgUnclassified.claim.m,
-              session: info.sessionID,
-              reason: "provider error",
-              elapsedMs: Date.now() - ownMsgUnclassified.claim.t,
-              released: false,
-              detail: haystack.slice(0, 400)
-            });
-            if (!observedErrors.has(ownMsgUnclassified.key)) {
-              observedErrors.set(ownMsgUnclassified.key, { reason: "provider error", detail: haystack.slice(0, 400) });
-              if (observedErrors.size > 32) {
-                const oldest = observedErrors.keys().next().value;
-                if (oldest !== void 0) observedErrors.delete(oldest);
+            const aborted = isAbortText(haystack);
+            if (!aborted) {
+              recordFailure(s, {
+                ts: Date.now(),
+                source: "observed",
+                base: ownMsgUnclassified.claim.v,
+                slot: ownMsgUnclassified.claim.k,
+                model: ownMsgUnclassified.claim.m,
+                session: info.sessionID,
+                reason: "provider error",
+                elapsedMs: Date.now() - ownMsgUnclassified.claim.t,
+                released: true,
+                detail: haystack.slice(0, 400)
+              });
+              if (!observedErrors.has(ownMsgUnclassified.key)) {
+                observedErrors.set(ownMsgUnclassified.key, { reason: "provider error", detail: haystack.slice(0, 400) });
+                if (observedErrors.size > 32) {
+                  const oldest = observedErrors.keys().next().value;
+                  if (oldest !== void 0) observedErrors.delete(oldest);
+                }
               }
+              const strike2 = recordStrike(s, ownMsgUnclassified.claim.m, "provider error");
+              if (strike2) {
+                await log(
+                  "warn",
+                  `bench ${ownMsgUnclassified.claim.m} (provider error, strike ${strike2.strikes}) after an unclassified terminal error`,
+                  { model: ownMsgUnclassified.claim.m, slot: ownMsgUnclassified.claim.k, session: info.sessionID, reason: haystack.slice(0, 400) }
+                );
+              }
+              release(s, ownMsgUnclassified.key);
             }
           }
           return;
@@ -4130,6 +4302,39 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           }
           return;
         }
+        if (unsupported) {
+          const ownUnsupported = ownMsg;
+          if (ownUnsupported) {
+            const strike2 = recordStrike(s, ownUnsupported.claim.m, INVALID_REQUEST_REASON, INVALID_REQUEST_COOLDOWN_MS);
+            if (strike2) {
+              await log(
+                "warn",
+                `bench ${ownUnsupported.claim.m} (${INVALID_REQUEST_REASON}, ${Math.round((strike2.until - Date.now()) / 1e3)}s) after a non-retryable unsupported-parameter error`,
+                { model: ownUnsupported.claim.m, slot: ownUnsupported.claim.k, session: info.sessionID, reason: haystack.slice(0, 400) }
+              );
+            }
+            recordFailure(s, {
+              ts: Date.now(),
+              source: "observed",
+              base: ownUnsupported.claim.v,
+              slot: ownUnsupported.claim.k,
+              model: ownUnsupported.claim.m,
+              session: info.sessionID,
+              reason: INVALID_REQUEST_REASON,
+              elapsedMs: Date.now() - ownUnsupported.claim.t,
+              released: true,
+              detail: haystack.slice(0, 400)
+            });
+            release(s, ownUnsupported.key);
+            await log("warn", `released ${ownUnsupported.claim.v} claim on ${ownUnsupported.claim.m} after an unsupported-parameter error`, {
+              base: ownUnsupported.claim.v,
+              model: ownUnsupported.claim.m,
+              slot: ownUnsupported.claim.k,
+              session: info.sessionID
+            });
+          }
+          return;
+        }
         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})`);
@@ -4278,15 +4483,19 @@ ${detail}` : detail;
             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);
+            const untilClock = strike ? new Date(strike.until).toISOString().slice(11, 19) + "Z" : "";
             const notes = [
-              strike ? `UNAVAILABLE (COOLING ${Math.ceil((strike.until - now) / 1e3)}s, ${strike.reason}, strike ${strike.strikes})` : "",
+              strike ? `UNAVAILABLE (COOLING ${Math.ceil((strike.until - now) / 1e3)}s left, until ${untilClock}, ${strike.reason}, strike ${strike.strikes})` : "",
               !providerReady(s, slot.model) ? `UNAVAILABLE (provider-unconfigured: ${providerOf(slot.model)}; run \`opencode auth login ${providerOf(slot.model)}\`)` : "",
               status && status !== "active" && status !== "unknown" ? `catalog:${status}` : ""
             ].filter(Boolean);
             const marker = next && slot.index === next.index ? " <- next" : "";
             const load = entry?.total ?? 0;
+            const ceiling = slotCeiling(slot);
             const atCeiling = !underCeiling(slot, snap.counts);
-            return `  slot ${slot.index} w${slot.weight}  ${slot.model}  load=${load}/${slotCeiling(slot)}${atCeiling ? " FULL" : ""}${marker}  [${users}${notes.length ? "; " + notes.join("; ") : ""}]`;
+            const cap = ceiling === slot.weight ? `w${slot.weight}` : `w${slot.weight} c${ceiling}`;
+            const tier = slot.fallback ? " [fallback]" : "";
+            return `  slot ${slot.index} ${cap}  ${slot.model}${tier}  load=${load}/${ceiling}${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);
@@ -4295,7 +4504,7 @@ ${detail}` : detail;
           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.seats += slotCeiling(slot);
             entry.slots++;
             if (snap.cooling.has(slot.model)) entry.cooling = true;
             buckets.set(name, entry);
@@ -4307,12 +4516,13 @@ ${detail}` : detail;
           return {
             title: `agent-pool: ${total} task(s) in flight, ${coolingNow.length} model(s) cooling`,
             output: [
-              `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).`,
+              `shared pool over ${slots.filter((slot) => !slot.fallback).length} primary slot(s) + ${slots.filter((slot) => slot.fallback).length} fallback slot(s) from ${s.origin}; state ${pass}; bases: ${BASES.join(", ")}
+ordered fill in declaration order: each pass fills every usable slot to its weight, then the next pass deepens a slot toward its ceiling (max parallel sessions). The fallback section is used only when no primary slot is usable. Capacity is the sum of the ceilings; weight alone is the per-pass budget (FULL = at ceiling).`,
               ...next ? [] : ["next: none - no routable slot; every slot is cooling, catalog-retired, or provider-unconfigured. A spawn will fail explicitly instead of routing."],
               ...sharedBuckets.length ? [`buckets: ${sharedBuckets.map(([name, entry]) => `${name} ${entry.seats} seat(s)${entry.cooling ? " COOLING" : ""}`).join("; ")}`] : [],
               ...degradedProviders.length ? [`provider degraded: ${degradedProviders.join(", ")} (flat window; a probe re-admits a model when it answers)`] : [],
               ...slots.map(line),
+              ...poolHealthLines(slots.filter((slot) => !slot.fallback), now),
               "",
               "by process:",
               `  ${s.id} (this process): ${snap.own.size} claim(s)`,
@@ -4380,11 +4590,11 @@ one ordered pass in slot order: each slot fills to its weight, then overflow goe
 
 // src/plugins/context-autoupdate.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync6, readdirSync as readdirSync3, statSync as statSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import * as path3 from "node:path";
 
 // src/lib/map-schema.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5, statSync as statSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync6, statSync as statSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import * as path from "node:path";
 var PROVISIONAL_DAYS = 30;
 var MAP_SPECS = [
@@ -4537,7 +4747,7 @@ var resolvePointer = (root, pointer, section) => {
   if (!stat.isFile()) return { exists: false };
   let text;
   try {
-    if (stat.size <= 512 * 1024) text = readFileSync5(absolute, "utf8");
+    if (stat.size <= 512 * 1024) text = readFileSync6(absolute, "utf8");
   } catch {
     text = void 0;
   }
@@ -4786,7 +4996,7 @@ var maintainMap = (root, mapDir, now = Date.now()) => {
     if (!existsSync3(absolute)) continue;
     let before;
     try {
-      before = readFileSync5(absolute, "utf8");
+      before = readFileSync6(absolute, "utf8");
     } catch {
       continue;
     }
@@ -4814,7 +5024,7 @@ var auditMap = (root, mapDir, now = Date.now()) => {
     }
     let text;
     try {
-      text = readFileSync5(absolute, "utf8");
+      text = readFileSync6(absolute, "utf8");
     } catch {
       violations.push({ file: spec.file, kind: "missing-file", detail: "unreadable" });
       continue;
@@ -4893,7 +5103,7 @@ var parseJsonc = (raw) => {
 };
 
 // src/lib/writer-rule.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import * as path2 from "node:path";
 var CONTEXT_DIR = path2.join(".opencode", "context");
 var WRITER = "context";
@@ -4933,7 +5143,7 @@ var agentsForm = (mapDir, projectRoot) => {
 var verifyWriterRule = (configPath, mapDir, projectRoot) => {
   let raw;
   try {
-    raw = readFileSync6(configPath, "utf8");
+    raw = readFileSync7(configPath, "utf8");
   } catch {
     return void 0;
   }
@@ -4978,25 +5188,25 @@ var verifyWriterRule = (configPath, mapDir, projectRoot) => {
 };
 
 // src/lib/timeline.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname3, join as join8, resolve as resolve3 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync8, renameSync as renameSync4, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname3, join as join9, resolve as resolve3 } from "node:path";
 var TIMELINE_STATE_VERSION = 1;
 function timelineDir() {
   const env = process.env.LACODE_TIMELINE_DIR;
   if (env) return resolve3(env);
-  return join8(homedir4(), ".local/share/opencode/lacode/timeline");
+  return join9(homedir5(), ".local/share/opencode/lacode/timeline");
 }
 function assertValidSessionID(sessionID) {
   if (!/^[A-Za-z0-9_.-]+$/.test(sessionID)) throw new Error("invalid sessionID");
 }
 function timelineFile(sessionID) {
   assertValidSessionID(sessionID);
-  return join8(timelineDir(), sessionID + ".jsonl");
+  return join9(timelineDir(), sessionID + ".jsonl");
 }
 function timelineStateFile(sessionID) {
   assertValidSessionID(sessionID);
-  return join8(timelineDir(), sessionID + ".state.json");
+  return join9(timelineDir(), sessionID + ".state.json");
 }
 function normalizeThrough(through) {
   if (!through || typeof through !== "object") return void 0;
@@ -5043,7 +5253,7 @@ function appendEntriesAt(file, texts, now, through) {
 function readEntriesAt(file, limit) {
   let raw = "";
   try {
-    raw = readFileSync7(file, "utf8");
+    raw = readFileSync8(file, "utf8");
   } catch {
     return [];
   }
@@ -5096,7 +5306,7 @@ function normalizePersistedState(raw) {
 }
 function readTimelineState(sessionID) {
   try {
-    const raw = readFileSync7(timelineStateFile(sessionID), "utf8");
+    const raw = readFileSync8(timelineStateFile(sessionID), "utf8");
     return normalizePersistedState(JSON.parse(raw));
   } catch {
     return void 0;
@@ -5522,7 +5732,7 @@ var changedSince = (before, dir) => {
   return changed;
 };
 var RETAIN_TRANSCRIPTS = 20;
-var transcriptDir = () => process.env.LACODE_TRANSCRIPT_DIR ?? path3.join(homedir5(), ".local", "share", "opencode", "lacode", "cartographer");
+var transcriptDir = () => process.env.LACODE_TRANSCRIPT_DIR ?? path3.join(homedir6(), ".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);
@@ -5778,15 +5988,15 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
 });
 
 // src/lib/feedback.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync5, unlinkSync as unlinkSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { dirname as dirname5, join as join10 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync9, renameSync as renameSync5, unlinkSync as unlinkSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname5, join as join11 } 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 = () => join10(homedir6(), ".local", "share", "opencode", "lacode", "feedback.json");
+var feedbackStatePath = () => join11(homedir7(), ".local", "share", "opencode", "lacode", "feedback.json");
 function readFeedbackState(path4 = feedbackStatePath()) {
   try {
-    const parsed = JSON.parse(readFileSync8(path4, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path4, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
     return parsed;
   } catch (error) {
@@ -5860,9 +6070,9 @@ async function feedbackHooks(input, options, deps = {}) {
 
 // src/plugins/image-paste.ts
 import { createHash, randomUUID } from "node:crypto";
-import { globSync, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync6, statSync as statSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { basename as basename3, join as join11 } from "node:path";
+import { globSync, mkdirSync as mkdirSync8, readFileSync as readFileSync10, renameSync as renameSync6, statSync as statSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { basename as basename3, join as join12 } from "node:path";
 
 // src/lib/clipboard.ts
 import { spawnSync } from "node:child_process";
@@ -6012,8 +6222,8 @@ function splitArguments(input) {
   return out;
 }
 function expandTilde(p) {
-  if (p === "~") return homedir7();
-  if (p.startsWith("~/")) return join11(homedir7(), p.slice(2));
+  if (p === "~") return homedir8();
+  if (p.startsWith("~/")) return join12(homedir8(), p.slice(2));
   return p;
 }
 function expandGlob(p) {
@@ -6029,7 +6239,7 @@ function storeImage(bytes, dir, sessionID, label) {
   if (kind === null) return null;
   const hash = createHash("sha256").update(bytes).digest("hex");
   mkdirSync8(dir, { recursive: true });
-  const target = join11(dir, `${hash}.${kind.ext}`);
+  const target = join12(dir, `${hash}.${kind.ext}`);
   const tmp = `${target}.tmp`;
   writeFileSync9(tmp, bytes, { mode: 384 });
   renameSync6(tmp, target);
@@ -6060,7 +6270,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 ?? join11(homedir7(), ".local/share/opencode/lacode/images");
+    const dir = opts.dir ?? process.env.LACODE_IMAGE_DIR ?? join12(homedir8(), ".local/share/opencode/lacode/images");
     const readClipboard = (deps ?? {}).readClipboard ?? readClipboardImage;
     return {
       "command.execute.before": async (cmd, output) => {
@@ -6117,7 +6327,7 @@ async function imagePasteHooks(input, options, deps) {
               }
               let bytes;
               try {
-                bytes = readFileSync9(filePath);
+                bytes = readFileSync10(filePath);
               } catch {
                 skipped.push(name);
                 continue;
@@ -6168,14 +6378,14 @@ async function imagePasteHooks(input, options, deps) {
 }
 
 // src/lib/opencode-config.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync9, readFileSync as readFileSync10, renameSync as renameSync7, writeFileSync as writeFileSync10 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync9, readFileSync as readFileSync11, renameSync as renameSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname6, join as join13 } from "node:path";
 import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
 function globalOpencodeConfigPath() {
-  const base = process.env.XDG_CONFIG_HOME ?? join12(homedir8(), ".config");
-  const jsonc = join12(base, "opencode", "opencode.jsonc");
-  return existsSync5(jsonc) ? jsonc : join12(base, "opencode", "opencode.json");
+  const base = process.env.XDG_CONFIG_HOME ?? join13(homedir9(), ".config");
+  const jsonc = join13(base, "opencode", "opencode.jsonc");
+  return existsSync5(jsonc) ? jsonc : join13(base, "opencode", "opencode.json");
 }
 var OpenCodeConfigError = class extends Error {
   constructor(message) {
@@ -6188,7 +6398,7 @@ function isPlainObject(value) {
 }
 function readOpencodeConfig(path4 = globalOpencodeConfigPath()) {
   if (!existsSync5(path4)) return {};
-  const text = readFileSync10(path4, "utf8");
+  const text = readFileSync11(path4, "utf8");
   const errors = [];
   const parsed = parse(text, errors, { allowTrailingComma: true, disallowComments: false });
   if (errors.length > 0) {
@@ -7313,6 +7523,43 @@ function normalizeChunk(value) {
   }
   return changed;
 }
+var UPSTREAM_ATTEMPTS = 3;
+var UPSTREAM_RETRY_DELAY_MS = 250;
+var TRANSIENT_UPSTREAM_PATTERN2 = /reasoning_display/i;
+function requestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  if (input && typeof input === "object") {
+    const url = input.url;
+    if (typeof url === "string") return url;
+  }
+  return "";
+}
+function isOpencodeInferenceChat(raw) {
+  if (!raw) return false;
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return false;
+  }
+  if (url.hostname !== "opencode.ai" && !url.hostname.endsWith(".opencode.ai")) return false;
+  return url.pathname.includes("/inference/") && url.pathname.endsWith("/chat/completions");
+}
+function isReplayableInit(init2) {
+  if (!init2 || typeof init2 !== "object") return false;
+  const body = init2.body;
+  return typeof body === "string" || body instanceof Uint8Array || body instanceof ArrayBuffer;
+}
+async function isTransientUpstreamResponse(response) {
+  if (response.status !== 400) return false;
+  try {
+    const text = await response.clone().text();
+    return TRANSIENT_UPSTREAM_PATTERN2.test(text) && /not\s+a\s+supported\s+value|unsupported/i.test(text);
+  } catch {
+    return false;
+  }
+}
 function normalizeSseLine(line) {
   const trimmed = line.trim();
   if (!trimmed.startsWith("data:")) return line;
@@ -7349,9 +7596,22 @@ function createChunkNormalizer() {
     }
   });
 }
-function wrapFetch(original) {
+var sleep = (ms) => ms > 0 ? new Promise((resolve5) => setTimeout(resolve5, ms)) : Promise.resolve();
+function wrapFetch(original, options = {}) {
+  const attempts = Math.max(1, Math.trunc(options.attempts ?? UPSTREAM_ATTEMPTS));
+  const delayMs = Math.max(0, Math.trunc(options.delayMs ?? UPSTREAM_RETRY_DELAY_MS));
   const wrapped = async (input, init2) => {
-    const response = await original(input, init2);
+    const retryable = attempts > 1 && isReplayableInit(init2) && isOpencodeInferenceChat(requestUrl(input));
+    let response = await original(input, init2);
+    for (let attempt = 1; retryable && attempt < attempts; attempt++) {
+      if (!await isTransientUpstreamResponse(response)) break;
+      try {
+        await response.body?.cancel();
+      } catch {
+      }
+      await sleep(delayMs);
+      response = await original(input, init2);
+    }
     try {
       const contentType = response.headers.get("content-type") ?? "";
       if (!contentType.includes("text/event-stream") || !response.body) return response;
@@ -7424,7 +7684,7 @@ async function selfUpdateHooks(input, options) {
 
 // src/plugins/timeline.ts
 import { existsSync as existsSync6, writeFileSync as writeFileSync11, renameSync as renameSync8, rmSync as rmSync3 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { tool as tool2 } from "@opencode-ai/plugin";
 var DEFAULT_INTERVAL_MS = 3e5;
 var MIN_INTERVAL_MS = 1e4;
@@ -7500,7 +7760,7 @@ function errorText(value) {
 }
 var MAX_TASK_CHILDREN_EXPANDED = 40;
 async function expandTaskSessions(client, messages, directory, owned, onError, cursor) {
-  const projectOwnsTooling = existsSync6(join13(directory, "src/plugins/timeline.ts"));
+  const projectOwnsTooling = existsSync6(join14(directory, "src/plugins/timeline.ts"));
   let attempts = 0;
   const expandedMessages = [];
   let startIndex = 0;
@@ -8066,9 +8326,9 @@ function timelineHooks(input, options) {
 
 // src/lib/timer-migration.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync10, readFileSync as readFileSync11, renameSync as renameSync9, writeFileSync as writeFileSync12 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { basename as basename4, dirname as dirname7, join as join14 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync10, readFileSync as readFileSync12, renameSync as renameSync9, writeFileSync as writeFileSync12 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { basename as basename4, dirname as dirname7, join as join15 } from "node:path";
 var TIMER_MIGRATION_ENV = "LACODE_NO_TIMER_MIGRATION";
 var TIMER_MIGRATION_STATE_VERSION = 1;
 var defaultRun2 = (file, args, options) => new Promise((resolve5, reject) => {
@@ -8082,15 +8342,15 @@ function resolveNodeBinary(execPath = process.execPath) {
   if (existsSync7("/usr/bin/node")) return "/usr/bin/node";
   return "node";
 }
-function timerMigrationStatePath(home = homedir9()) {
-  return join14(home, ".local", "share", "opencode", "lacode", "migrations.json");
+function timerMigrationStatePath(home = homedir10()) {
+  return join15(home, ".local", "share", "opencode", "lacode", "migrations.json");
 }
-function timerMigrationUnitPath(home = homedir9()) {
-  return join14(home, ".config", "systemd", "user", "lacode-refresh-pool.timer");
+function timerMigrationUnitPath(home = homedir10()) {
+  return join15(home, ".config", "systemd", "user", "lacode-refresh-pool.timer");
 }
 function readState2(path4) {
   try {
-    return JSON.parse(readFileSync11(path4, "utf8"));
+    return JSON.parse(readFileSync12(path4, "utf8"));
   } catch {
     return {};
   }
@@ -8109,7 +8369,7 @@ async function runTimerMigration(options = {}) {
   const packageRoot = options.packageRoot ?? PACKAGE_ROOT;
   const version = options.version ?? readInstalledVersion(packageRoot);
   if (!version) return { action: "skipped", reason: "no-version" };
-  const home = options.home ?? homedir9();
+  const home = options.home ?? homedir10();
   const statePath = options.statePath ?? timerMigrationStatePath(home);
   const state2 = readState2(statePath);
   if (state2.timersVersion === version && existsSync7(timerMigrationUnitPath(home))) {
@@ -8121,7 +8381,7 @@ async function runTimerMigration(options = {}) {
   } catch {
     return { action: "skipped", reason: "no-systemd" };
   }
-  const script = join14(packageRoot, "scripts", "refresh-pool.mjs");
+  const script = join15(packageRoot, "scripts", "refresh-pool.mjs");
   if (!existsSync7(script)) return { action: "failed", version, error: `timer script not found: ${script}` };
   try {
     await run(resolveNodeBinary(), [script, "--install-timer", "--stable"], { stdio: "ignore" });