@lawaty/lacode 0.10.0 → 1.0.0

package/dist/index.js

@@ -33,6 +33,7 @@ var STUCK_IDLE_MS = 3 * 60 * 1e3;
 var MAX_CLAIM_AGE_MS = 30 * 60 * 1e3;
 var HANG_COOLDOWN_MS = 10 * 60 * 1e3;
 var UNAVAILABLE_COOLDOWN_MS = 60 * 1e3;
+var UNAVAILABLE_REASON = "endpoint-unavailable";
 var MAX_WEIGHT = 100;
 var SLOT_CEILING_FACTOR = 2;
 var slotCeiling = (slot) => slot.weight * SLOT_CEILING_FACTOR;
@@ -44,6 +45,10 @@ 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 MODEL_MISSING_REASON = "model-missing";
+var MODEL_MISSING_COOLDOWN_MS = QUOTA_COOLDOWN_MAX_MS;
+var MODEL_MISSING_PATTERN = /model\s+(?:not\s+found|does\s+not\s+exist|is\s+not\s+available)|(?:unknown|no\s+such)\s+model/i;
+var isModelMissingText = (text) => MODEL_MISSING_PATTERN.test(text);
 var BASES = ["explore", "implement", "context"];
 var PRESETS_DIR = join2(PACKAGE_ROOT, "presets");
 var DEFAULT_PRESET = join2(PRESETS_DIR, "free-tier.json");
@@ -52,7 +57,7 @@ var USER_MODELS_PATH = join2(USER_CONFIG_DIR, "pool.json");
 var USER_MODELS_TXT = join2(USER_CONFIG_DIR, "pool.txt");
 var FALLBACK_SLOTS = [
   { index: 1, model: "opencode/big-pickle", weight: 3 },
-  { index: 2, model: "opencode-go/minimax-m3.1-flash-free", weight: 2 },
+  { index: 2, model: "opencode-go/beam-free", weight: 2 },
   { index: 3, model: "opencode/deepseek-v4.1-flash-free", weight: 1 },
   { index: 4, model: "opencode/glm-5.3-flash-free", weight: 1 }
 ];
@@ -205,7 +210,14 @@ var LIMIT_PATTERNS = [
   /overloaded/i,
   UNAVAILABLE_PATTERN
 ];
-var isLimitText = (text) => LIMIT_PATTERNS.some((re) => re.test(text));
+var LIMIT_REACHED_PATTERN = /\blimits?[\s_-]?(?:reached|exceeded)\b|\breached\s+(?:your|the|its)\s+limit\b/i;
+var CONTEXT_LIMIT_PATTERN = /(?:context|token|length|window|prompt|char|character|byte|size)\s*(?:limit|length|size|window)/i;
+var LIMIT_REASON_PATTERN = /rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded|limits?[\s_-]?(?:reached|exceeded)/i;
+var isLimitText = (text) => LIMIT_PATTERNS.some((re) => re.test(text)) || LIMIT_REACHED_PATTERN.test(text) && !CONTEXT_LIMIT_PATTERN.test(text);
+var limitReason = (text) => {
+  if (!isLimitText(text)) return void 0;
+  return text.match(LIMIT_REASON_PATTERN)?.[0]?.toLowerCase().replace(/[\s_]/g, "-");
+};
 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));
@@ -276,6 +288,21 @@ function ensureSlots(s, onWarn) {
   for (const problem of problems) onWarn(problem);
   return slots;
 }
+var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}`).join("|")}`;
+function reloadSlots(s, onWarn) {
+  const { slots, problems, origin } = resolveModels({ models: s.inlineModels, modelsFile: s.modelsFile });
+  const changed = slotSignature(origin, slots) !== slotSignature(s.origin, s.slots);
+  if (!changed) return { changed, slots, origin };
+  s.slots = slots;
+  s.origin = origin;
+  for (const problem of problems) onWarn(problem);
+  return { changed, slots, origin };
+}
+function slotSources(input = {}) {
+  if (input.models !== void 0) return [];
+  if (input.modelsFile) return [input.modelsFile];
+  return [USER_MODELS_TXT, USER_MODELS_PATH, DEFAULT_PRESET];
+}
 var claimKey = (sessionID, callID) => `${sessionID}:${callID}`;
 var selfFile = (id) => `claims.${id}.json`;
 var limitFile = (model) => `limit.${model.replace(/[^a-zA-Z0-9._-]/g, "__")}.json`;
@@ -465,11 +492,12 @@ 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;
       if (strike.until > now) {
         cooling.set(strike.model, strike);
-        memory.set(strike.model, strike);
+        if (countsAsStrike) memory.set(strike.model, strike);
       } else if (typeof strike.last === "number" && now - strike.last < STRIKE_DECAY_MS) {
-        memory.set(strike.model, strike);
+        if (countsAsStrike) memory.set(strike.model, strike);
       } else {
         unlinkSync(path4);
       }
@@ -486,6 +514,7 @@ function readLimits(s) {
 }
 function recordStrike(s, model, reason, stated) {
   if (!s.dirReady) return;
+  if (reason === UNAVAILABLE_REASON) return coolUnavailable(s, model);
   const now = Date.now();
   const prior = s.strikes.get(model);
   const strikes = prior && now - prior.last < STRIKE_DECAY_MS ? prior.strikes + 1 : 1;
@@ -510,9 +539,8 @@ function coolUnavailable(s, model) {
   const prior = s.cooling.get(model);
   const until = now + UNAVAILABLE_COOLDOWN_MS;
   if (prior && prior.until > until) return prior;
-  const strike = { model, until, strikes: 1, reason: "endpoint-unavailable", last: now };
+  const strike = { model, until, strikes: 1, reason: UNAVAILABLE_REASON, last: now };
   s.cooling.set(model, strike);
-  s.strikes.set(model, strike);
   const path4 = join2(s.dir, limitFile(model));
   try {
     writeFileSync(`${path4}.tmp`, JSON.stringify(strike));
@@ -598,48 +626,24 @@ function snapshot(s) {
 }
 var loadOf = (counts, model) => counts.get(model) ?? 0;
 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);
-  return seq;
-}
-var CURSOR_FILE = "cursor.json";
-function readCursor(s) {
-  try {
-    const parsed = JSON.parse(readFileSync2(join2(s.dir, CURSOR_FILE), "utf8"));
-    if (typeof parsed.seq === "number" && Number.isInteger(parsed.seq) && parsed.seq >= 0) return parsed.seq;
-  } catch {
+function pickSlot(s, snap) {
+  const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
+  const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const pool = usable.length > 0 ? usable : slots;
+  for (const slot of usable) {
+    if (loadOf(snap.counts, slot.model) < slot.weight) return slot;
   }
-  return 0;
-}
-function writeCursor(s, seq) {
-  if (!s.dirReady) return;
-  const path4 = join2(s.dir, CURSOR_FILE);
-  try {
-    writeFileSync(`${path4}.tmp`, JSON.stringify({ seq }));
-    renameSync(`${path4}.tmp`, path4);
-  } catch {
+  for (const slot of usable) {
+    if (loadOf(snap.counts, slot.model) < slotCeiling(slot)) return slot;
   }
+  return pool.reduce((best, slot) => loadOf(snap.counts, slot.model) < loadOf(snap.counts, best.model) ? slot : best, pool[0]);
 }
-function pickSlot(s, snap, options) {
-  const advance = options?.advance !== false;
+function poolPass(s, snap) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
-  const seq = roundRobinSequence(slots);
-  if (seq.length > 0) {
-    const byIndex = new Map(slots.map((slot) => [slot.index, slot]));
-    const start = readCursor(s) % seq.length;
-    for (let step = 0; step < seq.length; step++) {
-      const at = (start + step) % seq.length;
-      const slot = byIndex.get(seq[at]);
-      if (slot && isAvailable(s, slot.model, snap.cooling) && underCeiling(slot, snap.counts)) {
-        if (advance) writeCursor(s, at + 1);
-        return slot;
-      }
-    }
-  }
   const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
-  const pool = usable.length > 0 ? usable : slots;
-  return pool.reduce((best, slot) => loadOf(snap.counts, slot.model) < loadOf(snap.counts, best.model) ? slot : best, pool[0]);
+  if (usable.some((slot) => loadOf(snap.counts, slot.model) < slot.weight)) return 1;
+  if (usable.some((slot) => loadOf(snap.counts, slot.model) < slotCeiling(slot))) return 2;
+  return "overflow";
 }
 function agentFor(base, slot) {
   return `${base}-${slot}`;
@@ -774,9 +778,12 @@ Every question of the form "what does this file do", "where is X handled", or
   that proves it. Never one whole refactor handed over in a single piece \u2014
   see \`# Task size\` below.
 
-Spawn the BARE pooled base \u2014 \`explore\`, \`implement\` or \`context\`. The pool
-refuses a \`-N\` variant, and a refusal means spawn the bare base, never a
-different number.
+Spawn the pooled base \u2014 \`explore\`, \`implement\` or \`context\`. The plugin decides
+which model runs the work; do not try to choose one yourself.
+
+\`expert\` is not part of the pool and is expensive: spawn it only when the user
+explicitly asks for it. Never escalate to it on your own, and never as a
+fallback when a pooled spawn fails.
 
 # When the pool is unavailable
 
@@ -785,12 +792,12 @@ pool cannot serve a spawn \u2014 every slot cooling or exhausted, spawns repeate
 failing, or a runtime message saying no slot is available \u2014 that is not a reason
 to do the work yourself, and not a reason to stop and ask.
 
-**Retry.** A refused or cooling slot is transient and costs you nothing but a
-turn. Spawn the bare base again. Do not escalate to a numbered variant after a
-refusal \u2014 the refusal means the pool has a routing problem, not that you
-picked the wrong number.
+**Retry.** A cooling model is transient and costs you nothing but a turn. Spawn
+the same base again. If a spawn fails, do not switch to a different name \u2014 a
+failure means the pool has a routing problem, not that you picked the wrong one.
 
-Retry is always available and never wrong, which is why it is the default. But
+Retry is always available
+ and never wrong, which is why it is the default. But
 "never wrong" is not "sufficient": looping silently against a pool with every
 model cooling goes nowhere and burns the slot doing it. So separate the two
 failures. **Transient** \u2014 a cooldown, a rate limit, one slot at its ceiling \u2014
@@ -798,7 +805,8 @@ means retry. **Persistent or structural** \u2014 every slot cooling, the same sp
 failing repeatedly with the same error, a malformed model id \u2014 means stop
 retrying and *report* it: say what failed (slot, model, error) and continue
 with whatever else the task needs, or ask the user. Surface the failure; do not
-spin on it and do not let it end the whole task.
+spin on it and do not let it end the whole task. Do not escalate to \`expert\` as
+a workaround; it is opt-in by the user.
 
 **Never fall back to reading, grepping, exploring or implementing on your own.**
 Do not "just quickly" inspect a file because a spawn failed. A failed spawn is
@@ -915,8 +923,11 @@ When you need to understand the codebase:
 2. Invoke @explore with specific, focused instructions (e.g. "read src/auth.ts", "grep for 'migration' in *.py files", "list the src/ directory")
 3. @explore will return its findings \u2014 you process them and plan accordingly
 
-Spawn the BARE pooled base (\`explore\`, \`implement\`, \`context\`); the pool
-refuses \`-N\` variants, and a refusal means spawn the bare base, not another number.
+Spawn the pooled base (\`explore\`, \`implement\`, \`context\`); the plugin decides
+which model runs the work. Do not try to choose one yourself.
+
+\`expert\` is not part of the pool and is expensive: spawn it only when the user
+explicitly asks for it.
 
 If the pool cannot serve a spawn \u2014 every slot cooling or exhausted, or repeated
 failures \u2014 do NOT fall back to reading or planning from your own inspection.
@@ -1244,7 +1255,7 @@ Trigger: \`.opencode/context/\` exists and work has just been done here.
    - an architectural decision
    - a new dependency between subsystems
    - a renamed or relocated subsystem
-    - a previously undocumented invariant
+   - an invariant not yet recorded in the map
 
 Do not update documentation merely because source files changed. Do not
 rewrite files wholesale. Do not make timestamp-only edits. Do not add a fact
@@ -1550,7 +1561,7 @@ function buildAgentSet() {
     for (let slot = 1; slot <= MAX_SLOTS; slot++) {
       const variant = {
         ...def,
-        description: `Hidden pool variant ${base}-${slot}: slot ${slot}. Its model is NOT set here -- LaCode injects it from the resolved pool preset at config time, so the preset is the only place a pool model is written down. Spawn '${base}' and let the pool route.`,
+        description: `Hidden pool slot ${slot} for ${base}. Its model is NOT set here -- LaCode injects it from the resolved pool preset at config time, so the preset is the only place a pool model is written down. Spawn '${base}' and let the pool route.`,
         hidden: true,
         // `mode: "primary"` is what keeps a variant OUT of the model's system
         // prompt. `hidden` cannot do it.
@@ -1562,9 +1573,10 @@ function buildAgentSet() {
         // and by default-agent resolution. A variant left as `mode: "subagent"`
         // is therefore listed to the model under its own name -- "explore-1:
         // Hidden pool variant explore-1" -- and the model copies that name
-        // straight into its next spawn. The pool then refuses it, because
-        // naming a variant is how a caller would pick the provider and skip the
-        // rotation. The refusal is right; the leak that provokes it is not.
+        // straight into its next spawn. The task hook coerces a hand-named
+        // variant back to its base, because naming one is how a caller would
+        // pick the provider and skip ordered slot fill and the slot ceiling. The coercion is right; the
+        // leak that provokes it is not.
         //
         // `mode` is the only field that filter respects, and setting it here is
         // safe: the task tool never reads an agent's mode -- it resolves the
@@ -1638,7 +1650,7 @@ context file only if this work introduced or revealed information that will
 materially help future agents \u2014 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.
+or an invariant not yet recorded.
 
 Do not edit documentation just because source files changed. No
 timestamp-only edits. If nothing material changed, make no edits and report
@@ -1713,7 +1725,7 @@ Print one PASS/FAIL line per check below, with the exact fix for any FAIL.
 Change nothing. Print a final one-line summary of failures.`
   },
   "pool": {
-    description: "Modify this machine's LaCode pool from a short instruction \u2014 the shared free-model slot table in ~/.config/lacode/pool.txt. Restarts opencode afterwards.",
+    description: "Modify this machine's LaCode pool from a short instruction \u2014 the shared free-model slot table in ~/.config/lacode/pool.txt. Picked up live; no restart.",
     template: `Apply this change to the LaCode pool on this machine:
 
 $ARGUMENTS
@@ -1725,22 +1737,41 @@ The pool is ONE global slot table shared by every pooled base (explore, implemen
 2. Resolve the instruction above into a target slot table. These are the rules the loader enforces \u2014 never write a file that breaks one:
    - one slot per line: \`<provider>/<model-id>  [weight]\`
    - at most ${MAX_SLOTS} slots, and a model may appear only once
-   - weight is optional (default 1) and must be a number in (0, ${MAX_WEIGHT}]. It is the slot's 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.
+   - weight is optional (default 1) and must be a number in (0, ${MAX_WEIGHT}]. It is the slot's active-session budget for one pass \u2014 how many turns it takes per cycle \u2014 and its concurrency ceiling is twice that. NOT a priority; pick order follows line order.
    - \`#\` 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.
 
-3. Write the WHOLE file, not a patch. This file is an override, not an edit target: any slot you drop disappears, and slot numbers are line positions, so a partial write silently renumbers the rotation. Keep the existing comment header. If the write fails on a missing directory, create \`~/.config/lacode\` first and retry.
+3. Write the WHOLE file, not a patch. This file is an override, not an edit target: any slot you drop disappears, and slot numbers are line positions, so a partial write silently renumbers slots. Keep the existing comment header. If the write fails on a missing directory, create \`~/.config/lacode\` first and retry.
 
-4. Report the before \u2192 after slot table, the resolved path, and this reminder in substance: nothing hot-reloads, so every running opencode process must be restarted before the new pool takes effect.
+4. Report the before \u2192 after slot table and the resolved path. The running process watches the pool files: it reloads the table, re-binds the variant agents and validates every slot, so no restart is needed. If a slot names a model the provider does not serve, it will be benched and named in the log and toast \u2014 report that instead of claiming the swap succeeded.
 
 Two traps that fail silently, so check and state them explicitly:
 - A slot's provider must already exist in the user's opencode config, or that slot cannot resolve at all. If the instruction adds a model on a provider that is not configured, say so.
 - If a slot model is \`omniroute/<id>\`, that id must also appear in the plugin's \`omniroute.models\` allowlist (or be the \`combo\` id, which needs no entry) \u2014 otherwise the pool resolves and every spawn fails with \`ProviderModelNotFoundError\`.
 - A provider \`whitelist\` is an allowlist, and the plugin appends your model to it at config time. Nothing for you to do there.
 
-If the instruction is to RESET or REVERT rather than to change models, delete \`${USER_MODELS_TXT}\` instead, and report that the pool falls back to the bundled preset \u2014 with the same restart reminder.
+If the instruction is to RESET or REVERT rather than to change models, delete \`${USER_MODELS_TXT}\` instead, and report that the pool falls back to the bundled preset \u2014 the running process picks that up automatically too.
 
 Change nothing else. In particular do not touch \`presets/free-tier.json\`, \`~/.config/lacode/pool.json\`, \`FALLBACK_SLOTS\` in \`src/lib/pool.ts\`, or \`tests/models-snapshot.json\`: this command owns the per-machine override and nothing else.`
+  },
+  "pool-recheck": {
+    description: "Probe the pool now \u2014 re-admit benched models that answer, keep the ones still limited, and bench a model the provider no longer serves.",
+    template: `Probe the LaCode pool now and report the result. Run inline; do not spawn a subagent and do not edit the pool.
+
+$ARGUMENTS
+
+- If the text above names one or more models, call the \`pool_recheck\` tool with those ids in \`models\` (provider/model-id).
+- Otherwise call \`pool_recheck\` with no arguments; it probes every model that is currently cooling.
+
+Report the tool's output as it came back, then add one short line naming what changed: re-admitted, still limited, or benched because the provider does not serve the model. If a model was benched as \`model-missing\`, say so and name the replacement in \`~/.config/lacode/pool.txt\` \u2014 but change nothing yourself.`
+  },
+  "image-in-cb": {
+    description: "Attach the clipboard image to this message \u2014 macOS needs pngpaste, Linux needs wl-paste or xclip.",
+    template: "$ARGUMENTS"
+  },
+  "image": {
+    description: "Attach one or more image files to this message",
+    template: "$ARGUMENTS"
   }
 };
 function applyCommands(cfg, commands = COMMANDS) {
@@ -1758,125 +1789,427 @@ function applyCommands(cfg, commands = COMMANDS) {
   return { added, kept };
 }
 
-// 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;
+// src/lib/selfupdate.ts
+import { spawn } from "node:child_process";
+import { closeSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2, writeSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join3, resolve } from "node:path";
+var REGISTRY_LATEST = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 4e3;
+var INSTALL_TIMEOUT_MS = 12e4;
+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 = join3(homedir2(), ".local", "share", "opencode", "lacode");
+var STATE_PATH = join3(STATE_DIR, "selfupdate.json");
+var LOCK_PATH = join3(STATE_DIR, "selfupdate.lock");
+function compareSemver(a, b) {
+  const parse = (v) => v.split("-")[0].split("+")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const left = parse(a);
+  const right = parse(b);
+  for (let i = 0; i < 3; i++) {
+    const l = left[i] ?? 0;
+    const r = right[i] ?? 0;
+    if (l !== r) return l > r ? 1 : -1;
+  }
+  return 0;
+}
+function readInstalledVersion(packageRoot, read = (path4) => {
   try {
-    return JSON.stringify(error) ?? String(error);
+    return readFileSync3(path4, "utf8");
   } catch {
-    return String(error);
+    return void 0;
   }
-};
-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
-    );
+    const raw = read(join3(packageRoot, "package.json"));
+    if (raw === void 0) return void 0;
+    const manifest = JSON.parse(raw);
+    if (manifest.name !== PACKAGE_NAME) return void 0;
+    return typeof manifest.version === "string" ? manifest.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveCacheRoot(packageRoot, exists = (p) => {
+  try {
+    return statSync2(p).isFile();
+  } catch {
+    return false;
+  }
+}) {
+  const tail = join3("node_modules", "@lawaty", "lacode");
+  if (!packageRoot.endsWith(tail)) return void 0;
+  const cacheRoot = resolve(packageRoot, "..", "..", "..");
+  if (!exists(join3(cacheRoot, "package.json"))) return void 0;
+  return cacheRoot;
+}
+function resolveOpencodeBin(execPath = process.execPath, env = process.env, exists = (p) => {
+  try {
+    return statSync2(p).isFile();
+  } catch {
+    return false;
+  }
+}) {
+  if (execPath && /(^|[\\/])opencode(\.exe)?$/.test(execPath)) return execPath;
+  for (const dir of (env.PATH ?? "").split(":")) {
+    if (!dir) continue;
+    const candidate = join3(dir, "opencode");
+    if (exists(candidate)) return candidate;
+  }
+  const fallback = join3(homedir2(), ".opencode", "bin", "opencode");
+  return exists(fallback) ? fallback : void 0;
+}
+async function fetchLatest(fetchImpl = fetch, timeoutMs = FETCH_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(REGISTRY_LATEST, { signal: controller.signal });
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    return typeof body.version === "string" ? body.version : void 0;
+  } catch {
+    return void 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);
+    clearTimeout(timer);
+  }
+}
+function readState(path4 = STATE_PATH) {
+  try {
+    return JSON.parse(readFileSync3(path4, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeState(state2, path4 = STATE_PATH) {
+  try {
+    mkdirSync2(dirname2(path4), { recursive: true });
+    writeFileSync2(path4, JSON.stringify(state2));
+  } catch {
+  }
+}
+var isDue = (state2, now, interval = CHECK_INTERVAL_MS) => typeof state2.checkedAt !== "number" || now - state2.checkedAt >= interval;
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
   }
 };
-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 = [];
+function acquireLock(path4 = LOCK_PATH, now = Date.now()) {
+  const claim = () => {
+    const fd = openSync(path4, "wx");
+    writeSync(fd, String(process.pid));
+    closeSync(fd);
+    return () => {
+      try {
+        unlinkSync2(path4);
+      } catch {
+      }
+    };
+  };
   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)));
+    mkdirSync2(dirname2(path4), { recursive: true });
+    return claim();
+  } catch {
+    let orphaned = false;
+    try {
+      const pid = Number.parseInt(readFileSync3(path4, "utf8").trim(), 10);
+      orphaned = !Number.isFinite(pid) || pid <= 0 || !isProcessAlive(pid);
+    } catch {
+      orphaned = true;
+    }
+    if (!orphaned) {
+      try {
+        orphaned = now - statSync2(path4).mtimeMs > LOCK_STALE_MS;
+      } catch {
+        orphaned = true;
+      }
+    }
+    if (!orphaned) return void 0;
+    try {
+      unlinkSync2(path4);
+    } catch {
+      return void 0;
+    }
+    try {
+      return claim();
+    } catch {
+      return void 0;
     }
-  } 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;
+async function checkForUpdate(opts) {
+  const installed = readInstalledVersion(opts.packageRoot);
+  const latest = await fetchLatest(opts.fetchImpl);
+  return {
+    installed,
+    latest,
+    newer: Boolean(installed && latest && compareSemver(latest, installed) > 0),
+    cacheRoot: resolveCacheRoot(opts.packageRoot, opts.exists),
+    bin: resolveOpencodeBin(opts.execPath, opts.env, opts.exists)
+  };
+}
+async function refreshCache(opts) {
+  const { cacheRoot, bin, latest } = opts;
+  const spawnImpl = opts.spawnImpl ?? spawn;
+  const timeoutMs = opts.timeoutMs ?? INSTALL_TIMEOUT_MS;
+  const fresh = join3(cacheRoot, "node_modules", "@lawaty", "lacode");
+  const aside = `${cacheRoot}.stale-${Date.now()}`;
+  try {
+    rmSync(aside, { recursive: true, force: true });
+    renameSync2(cacheRoot, aside);
+  } catch (error) {
+    return { ok: false, detail: `could not set the old cache aside: ${String(error)}` };
+  }
+  const exited = await new Promise((settle) => {
+    let done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      settle(value);
+    };
+    const child = spawnImpl(bin, ["plugin", PACKAGE_NAME, "-g"], {
+      env: { ...process.env, [CHILD_ENV]: "1" },
+      stdio: "ignore"
+    });
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      finish(false);
+    }, timeoutMs);
+    child.on("error", () => finish(false));
+    child.on("exit", (code) => finish(code === 0));
+  });
+  const installed = readInstalledVersion(fresh);
+  const ok = exited && installed === latest;
+  if (ok) {
+    try {
+      rmSync(aside, { recursive: true, force: true });
+    } catch {
+    }
+  } else {
+    try {
+      renameSync2(aside, cacheRoot);
+    } catch {
+    }
+  }
+  return {
+    ok,
+    detail: ok ? `installed ${installed}` : `installer exited ${exited ? "0" : "non-zero"}, cache now ${installed ?? "missing"}`
+  };
+}
+async function maybeSelfUpdate(opts) {
+  const env = opts.env ?? process.env;
+  if (opts.enabled === false || env[CHILD_ENV] === "1" || env[OPT_OUT_ENV] === "1" || inTestRunner(env)) {
+    return { action: "disabled" };
+  }
+  const now = (opts.now ?? Date.now)();
+  const statePath = opts.statePath ?? STATE_PATH;
+  const state2 = readState(statePath);
+  if (!isDue(state2, now, opts.intervalMs ?? CHECK_INTERVAL_MS)) return { action: "skipped", detail: "checked recently" };
+  const release2 = acquireLock(opts.lockPath, now);
+  if (!release2) return { action: "skipped", detail: "another process is updating" };
+  try {
+    const check = await checkForUpdate(opts);
+    if (!check.installed) return { action: "skipped", detail: "no installed version" };
+    if (!check.latest) {
+      writeState({ ...state2, checkedAt: now }, statePath);
+      return { action: "skipped", detail: "registry unreachable" };
+    }
+    if (!check.newer) {
+      writeState({ ...state2, checkedAt: now, latest: check.latest }, statePath);
+      return { action: "current", detail: `${check.installed} is current` };
+    }
+    if (!check.cacheRoot) {
+      writeState({ ...state2, checkedAt: now, latest: check.latest }, statePath);
+      return { action: "skipped", detail: "not an opencode cache install" };
+    }
+    if (!check.bin) {
+      writeState({ ...state2, checkedAt: now, latest: check.latest }, statePath);
+      opts.log?.("warn", `LaCode ${check.latest} is available but no opencode binary was found to install it`);
+      return { action: "failed", detail: "no opencode binary" };
+    }
+    const result = await refreshCache({ cacheRoot: check.cacheRoot, bin: check.bin, latest: check.latest, spawnImpl: opts.spawnImpl });
+    if (result.ok) {
+      writeState({ ...state2, checkedAt: now, latest: check.latest, updatedTo: check.latest }, statePath);
+      opts.log?.("info", `LaCode updated ${check.installed} -> ${check.latest}; restart opencode to apply`);
+      return { action: "updated", detail: `${check.installed} -> ${check.latest}` };
+    }
+    writeState({ ...state2, checkedAt: now, latest: check.latest }, statePath);
+    opts.log?.("warn", `LaCode update to ${check.latest} failed: ${result.detail}`);
+    return { action: "failed", detail: result.detail };
+  } finally {
+    release2();
+  }
+}
+
+// src/plugins/agent-pool.ts
+import { unwatchFile, watchFile } from "node:fs";
+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";
+  if (isModelMissingText(text)) return MODEL_MISSING_REASON;
+  return limitReason(text) ?? (isLimitText(text) ? "limit" : "failed");
+};
+var probeOne = async (client, opts, model, leftSeconds) => {
+  const { state: s, directory } = opts;
+  const { provider, id: modelID } = splitModel(model);
+  const settle = (ok, reason, left) => ({
+    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);
+    if (isModelMissingText(text)) {
+      recordStrike(s, model, MODEL_MISSING_REASON, MODEL_MISSING_COOLDOWN_MS);
+    } else {
+      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 probeModels(client, opts) {
+  const s = opts.state;
+  const now = opts.now ?? Date.now;
+  const empty = { outcomes: [], cleared: [], kept: [], missing: [], changed: false };
+  if (s.probing) return empty;
+  const models = [...new Set(opts.models)];
+  if (models.length === 0) return empty;
+  const cooling = readLimits(s);
+  const at = now();
+  const wasCooling = new Set([...cooling.values()].filter((strike) => strike.until > at).map((strike) => strike.model));
+  s.probing = true;
+  const outcomes = [];
+  try {
+    for (const model of models) {
+      const strike = cooling.get(model);
+      outcomes.push(await probeOne(client, opts, model, strike && strike.until > at ? Math.ceil((strike.until - at) / 1e3) : 0));
+    }
+  } finally {
+    s.probing = false;
+    s.lastProbe = Date.now();
+  }
+  const reAdmitted = outcomes.filter((o) => o.ok && wasCooling.has(o.model)).map((o) => o.model);
+  const missing = outcomes.filter((o) => o.reason === MODEL_MISSING_REASON).map((o) => o.model);
+  const stillLimited = outcomes.filter((o) => !o.ok && o.reason !== MODEL_MISSING_REASON);
+  return {
+    outcomes,
+    cleared: reAdmitted,
+    kept: stillLimited.map((o) => o.model),
+    missing,
+    changed: reAdmitted.length > 0 || missing.length > 0 || stillLimited.some((o) => o.leftSeconds !== o.hadSeconds)
+  };
+}
+async function probeCooling(client, opts) {
+  const s = opts.state;
+  const now = opts.now ?? Date.now;
+  const empty = { outcomes: [], cleared: [], kept: [], missing: [], 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 missing = outcomes.filter((o) => o.reason === MODEL_MISSING_REASON).map((o) => o.model);
+  const stillLimited = outcomes.filter((o) => !o.ok && o.reason !== MODEL_MISSING_REASON);
+  return {
+    outcomes,
+    cleared: reAdmitted,
+    kept: stillLimited.map((o) => o.model),
+    missing,
+    // 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 || missing.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 SLOT_WATCH_MS = 1e3;
+var SLOT_WATCH_DEBOUNCE_MS = 250;
 var ABORT_TIMEOUT_MS = 1e4;
 var formatWindow = (seconds) => seconds < 60 ? `${seconds}s` : `${Math.ceil(seconds / 60)}m`;
 var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
@@ -1899,15 +2232,18 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
   };
   sweepDirIfDue();
   const abortSession = async (sessionID) => {
-    if (!serverUrl) return { ok: false, why: "no serverUrl: this process has no HTTP server to abort through" };
     try {
-      const res = await fetch(new URL(`/session/${sessionID}/abort`, serverUrl).toString(), {
-        method: "POST",
+      const result = await client.session.abort({
+        path: { id: sessionID },
+        query: { directory },
         signal: AbortSignal.timeout(ABORT_TIMEOUT_MS)
       });
-      if (!res.ok) return { ok: false, why: `gateway answered HTTP ${res.status}` };
-      const body = (await res.text()).trim();
-      if (body === "false") return { ok: false, why: "server reported the session was not aborted" };
+      if (!result.response?.ok) {
+        return { ok: false, why: `server answered HTTP ${result.response?.status ?? "?"}` };
+      }
+      if (result.data === false) {
+        return { ok: false, why: "server reported the session was not aborted" };
+      }
       return { ok: true, why: "" };
     } catch (error) {
       return { ok: false, why: String(error) };
@@ -1921,18 +2257,95 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     const strike = recordStrike(s, claim.m, "hang", HANG_FALLBACK_MS);
     if (strike) await log2("warn", `cooling ${claim.m} for ${Math.round((strike.until - now) / 1e3)}s (hang)`);
   };
-  const failOver = async (sessionID, model, reason) => {
-    if (!sessionID) return;
-    const entry = [...s.own.entries()].find(([, claim2]) => claim2.g === sessionID);
-    if (!entry) return;
-    const [key, claim] = entry;
-    const kill = await abortSession(sessionID);
-    release(s, key);
-    await log(
-      "warn",
-      kill.ok ? `limit (${reason}) on ${model}; aborted in-flight ${claim.v} session ${sessionID} to fail over now` : `limit (${reason}) on ${model}; released in-flight ${claim.v} claim after a failed abort (${kill.why})`,
-      { base: claim.v, model: claim.m, slot: claim.k, session: sessionID, aborted: kill.ok, reason }
-    );
+  const claimFor = (sessionID) => {
+    if (!sessionID) return void 0;
+    for (const [key, claim] of s.own) if (claim.g === sessionID) return { key, claim };
+    return void 0;
+  };
+  const identifyPooledSession = async (sessionID) => {
+    try {
+      const info = await client.session.get({ path: { id: sessionID }, query: { directory } }).then((r) => r.data).catch(() => void 0);
+      if (!info?.parentID) return void 0;
+      const msgs = await client.session.messages({ path: { id: sessionID }, query: { directory } }).then(
+        (r) => r.data
+      ).catch(() => void 0);
+      if (!Array.isArray(msgs)) return void 0;
+      const userMsg = msgs.find((m) => m?.info?.role === "user");
+      if (!userMsg?.info) return void 0;
+      const agent = userMsg.info.agent;
+      if (typeof agent !== "string") return void 0;
+      const modelInfo = userMsg.info.model;
+      const userModel = modelInfo?.providerID && modelInfo?.modelID ? `${modelInfo.providerID}/${modelInfo.modelID}` : void 0;
+      if (s.known.size > 0 && !s.known.has(agent)) return void 0;
+      if (s.known.size === 0 && manualVariant(agent) === void 0 && !(BASES.includes(agent) && userModel)) {
+        return void 0;
+      }
+      const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
+      if (!slots || slots.length === 0) return void 0;
+      let slot;
+      const variantBase = manualVariant(agent);
+      if (variantBase) {
+        const idx = Number(agent.slice(agent.lastIndexOf("-") + 1));
+        if (!Number.isFinite(idx)) return void 0;
+        slot = slots.find((sl) => sl.index === idx);
+      } else if (BASES.includes(agent) && userModel) {
+        slot = slots.find((sl) => sl.model === userModel);
+      }
+      if (!slot) return void 0;
+      return { agent, slot: slot.index, model: slot.model };
+    } catch {
+      return void 0;
+    }
+  };
+  const failOver = async (sessionID, model, reason, opts2) => {
+    const entry = claimFor(sessionID);
+    if (entry) {
+      const { key, claim } = entry;
+      const kill = await abortSession(sessionID);
+      if (kill.ok) {
+        release(s, key);
+        await log(
+          "warn",
+          `limit (${reason}) on ${model}; aborted in-flight ${claim.v} session ${sessionID} to fail over now`,
+          { base: claim.v, model: claim.m, slot: claim.k, session: sessionID, aborted: true, reason }
+        );
+        return;
+      }
+      await log(
+        "warn",
+        `limit (${reason}) on ${model}; abort failed (${kill.why}); claim on slot ${claim.k} held for retry`,
+        { base: claim.v, model: claim.m, slot: claim.k, session: sessionID, aborted: false, reason }
+      );
+      return;
+    }
+    if (!entry) {
+      if (opts2?.cool !== false && sessionID) {
+        const pooled = await identifyPooledSession(sessionID);
+        if (pooled) {
+          recordStrike(s, pooled.model, reason, opts2?.stated);
+          const kill = await abortSession(sessionID);
+          await log(
+            "warn",
+            `limit (${reason}) on ${pooled.model}; aborted pooled ${pooled.agent} session ${sessionID} (slot ${pooled.slot}) to fail over now`,
+            { base: pooled.agent, model: pooled.model, slot: pooled.slot, session: sessionID, aborted: kill.ok, reason }
+          );
+          return;
+        }
+      } else if (opts2?.cool === false && sessionID) {
+        const pooled = await identifyPooledSession(sessionID);
+        if (pooled) {
+          const kill = await abortSession(sessionID);
+          await log(
+            "warn",
+            `limit (${reason}) on ${pooled.model}; aborted pooled ${pooled.agent} session ${sessionID} (slot ${pooled.slot}) to fail over now`,
+            { base: pooled.agent, model: pooled.model, slot: pooled.slot, session: sessionID, aborted: kill.ok, reason }
+          );
+          return;
+        }
+      }
+      await log("warn", `limit (${reason}) on ${model} for session ${sessionID ?? "?"}, which has no pool claim; nothing aborted`);
+      return;
+    }
   };
   const reapStuck = async () => {
     if (s.reaping) return;
@@ -2005,20 +2418,25 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, 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 EMPTY_REPORT = { outcomes: [], cleared: [], kept: [], missing: [], changed: false };
+  const reportTitle = (report) => {
+    if (report.outcomes.length === 0) return "nothing cooling to probe";
+    const parts = [`probed ${report.outcomes.length} model(s)`, `re-admitted ${report.cleared.length}`];
+    if (report.missing.length > 0) parts.push(`benched ${report.missing.length} missing`);
+    return parts.join(", ");
+  };
   const reportText = (report) => {
     if (report.outcomes.length === 0) return "no models are cooling down, so there was nothing to probe.";
     return [
       ...report.outcomes.map(
-        (outcome) => outcome.ok ? `${outcome.model}: answered \u2014 cooldown cleared (it had ${formatWindow(outcome.hadSeconds)} left), back in the rotation` : `${outcome.model}: still limited (${outcome.reason}) \u2014 cooldown kept${outcome.leftSeconds > 0 ? `, ${formatWindow(outcome.leftSeconds)} left` : ""}`
+        (outcome) => outcome.ok ? `${outcome.model}: answered \u2014 cooldown cleared (it had ${formatWindow(outcome.hadSeconds)} left), back in the pool` : outcome.reason === MODEL_MISSING_REASON ? `${outcome.model}: not served by the provider (${outcome.reason}) \u2014 benched${outcome.leftSeconds > 0 ? `, ${formatWindow(outcome.leftSeconds)} left` : ""}` : `${outcome.model}: still limited (${outcome.reason}) \u2014 cooldown kept${outcome.leftSeconds > 0 ? `, ${formatWindow(outcome.leftSeconds)} left` : ""}`
       ),
-      report.cleared.length > 0 ? `re-admitted: ${report.cleared.join(", ")}. They route again on the next pooled spawn \u2014 nothing needs restarting or reloading.` : "nothing was re-admitted; the pool is short exactly as much as it was."
+      report.cleared.length > 0 ? `re-admitted: ${report.cleared.join(", ")}. They route again on the next pooled spawn \u2014 nothing needs restarting or reloading.` : report.missing.length > 0 ? `benched: ${report.missing.join(", ")}. The provider does not serve them; replace them in the pool.` : report.outcomes.every((outcome) => outcome.ok) ? "every model that was asked answered; nothing needed re-admitting." : "nothing was re-admitted; the pool is short exactly as much as it was."
     ].join("\n");
   };
   const announce = async (report) => {
     if (!report.changed) return;
-    const message = report.cleared.length > 0 ? `Re-admitted ${report.cleared.join(", ")} \u2014 they answer again.` : `${report.kept.length} cooling model(s) re-checked, still limited.`;
+    const message = report.cleared.length > 0 ? `Re-admitted ${report.cleared.join(", ")} \u2014 they answer again.` : report.missing.length > 0 ? `Benched ${report.missing.join(", ")} \u2014 the provider does not serve them.` : `${report.kept.length} cooling model(s) re-checked, still limited.`;
     await log("info", `pool probe: ${message}`, { cleared: report.cleared, kept: report.kept });
     try {
       await client.tui?.showToast?.({
@@ -2045,47 +2463,90 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     "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));
-      const agents = cfg.agent;
-      const providers = cfg.provider;
-      const known = /* @__PURE__ */ new Set();
-      for (const [name, def] of Object.entries(cfg.agent ?? {})) if (def?.model) s.models.set(name, def.model);
-      for (const slot of slots) {
-        for (const base of BASES) {
-          const name = agentFor(base, slot.index);
-          const def = agents?.[name];
-          if (!def) {
-            await warnOnce(`variant ${name} is missing from the config; spawns of ${base} that route to slot ${slot.index} would fail`);
-            continue;
-          }
-          if (def.model && def.model !== slot.model) {
-            await warnOnce(`${name} still hard-codes ${def.model}; the resolved pool preset wins (${slot.model}). Delete the line to keep one source of truth.`);
-          }
-          def.model = slot.model;
-          known.add(name);
-          s.models.set(name, slot.model);
-        }
-        const slash = slot.model.indexOf("/");
-        const provider = slot.model.slice(0, slash);
-        const id = slot.model.slice(slash + 1);
-        const entry = providers?.[provider];
-        if (!entry) {
-          await warnOnce(`provider ${provider} is not configured in opencode.jsonc; slot ${slot.index} (${slot.model}) cannot resolve`);
+  let liveConfig;
+  const bind = async (cfg) => {
+    const slots = ensureSlots(s, (m) => void warnOnce(m));
+    const agents = cfg.agent;
+    const providers = cfg.provider;
+    const known = /* @__PURE__ */ new Set();
+    for (const [name, def] of Object.entries(cfg.agent ?? {})) if (def?.model) s.models.set(name, def.model);
+    for (const slot of slots) {
+      for (const base of BASES) {
+        const name = agentFor(base, slot.index);
+        const def = agents?.[name];
+        if (!def) {
+          await warnOnce(`variant ${name} is missing from the config; spawns of ${base} that route to slot ${slot.index} would fail`);
           continue;
         }
-        const list = entry.whitelist;
-        if (list && !list.includes(id)) {
-          list.push(id);
-          await log("info", `whitelisted ${id} on ${provider} (${s.origin} slot ${slot.index})`);
+        if (def.model && def.model !== slot.model) {
+          await warnOnce(`${name} still hard-codes ${def.model}; the resolved pool preset wins (${slot.model}). Delete the line to keep one source of truth.`);
         }
+        def.model = slot.model;
+        known.add(name);
+        s.models.set(name, slot.model);
       }
-      s.known = known;
-      await log(
-        "info",
-        `${s.origin}: bound ${known.size} variant agent(s) to ${slots.length} slot(s): ${slots.map((sl) => `${sl.index}=${sl.model} w${sl.weight}`).join(", ")}`
-      );
+      const slash = slot.model.indexOf("/");
+      const provider = slot.model.slice(0, slash);
+      const id = slot.model.slice(slash + 1);
+      const entry = providers?.[provider];
+      if (!entry) {
+        await warnOnce(`provider ${provider} is not configured in opencode.jsonc; slot ${slot.index} (${slot.model}) cannot resolve`);
+        continue;
+      }
+      const list = entry.whitelist;
+      if (list && !list.includes(id)) {
+        list.push(id);
+        await log("info", `whitelisted ${id} on ${provider} (${s.origin} slot ${slot.index})`);
+      }
+    }
+    s.known = known;
+    await log(
+      "info",
+      `${s.origin}: bound ${known.size} variant agent(s) to ${slots.length} slot(s): ${slots.map((sl) => `${sl.index}=${sl.model} w${sl.weight}`).join(", ")}`
+    );
+  };
+  const runValidation = async (models) => {
+    let report = EMPTY_REPORT;
+    try {
+      report = await probeModels(client, { state: s, directory, models });
+    } catch (error) {
+      await log("error", `pool validation failed: ${String(error)}`);
+      return EMPTY_REPORT;
+    }
+    await announce(report);
+    return report;
+  };
+  const watchMs = opts.watchMs ?? SLOT_WATCH_MS;
+  const watchDebounceMs = opts.watchDebounceMs ?? SLOT_WATCH_DEBOUNCE_MS;
+  const sources = watchMs > 0 ? slotSources(opts) : [];
+  let reloadTimer;
+  const reloadFromDisk = async () => {
+    const reload = reloadSlots(s, (m) => void warnOnce(m));
+    if (!reload.changed) return;
+    await log(
+      "info",
+      `pool changed (${reload.origin}): ${reload.slots.map((sl) => `${sl.index}=${sl.model} w${sl.weight}`).join(", ")}`
+    );
+    if (liveConfig) await bind(liveConfig);
+    await runValidation(reload.slots.map((slot) => slot.model));
+  };
+  const scheduleReload = () => {
+    if (reloadTimer) return;
+    reloadTimer = setTimeout(() => {
+      reloadTimer = void 0;
+      void reloadFromDisk();
+    }, watchDebounceMs);
+    reloadTimer.unref?.();
+  };
+  for (const source of sources) watchFile(source, { interval: watchMs, persistent: false }, scheduleReload);
+  void log(
+    "info",
+    sources.length > 0 ? `pool config watch armed: ${sources.join(", ")} every ${watchMs}ms; a change reloads the slots and validates every slot` : "pool config watch disabled (watchMs: 0)"
+  );
+  return {
+    config: async (cfg) => {
+      liveConfig = cfg;
+      await bind(cfg);
     },
     event: async ({ event }) => {
       try {
@@ -2093,24 +2554,88 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         if (event.type === "session.status") {
           const sessionID = typeof props.sessionID === "string" ? props.sessionID : void 0;
           const status2 = props.status;
-          const reason2 = status2?.action?.reason ?? "";
-          if (status2?.type === "retry" && status2.action?.provider && (reason2 === "free_tier_limit" || isLimitText(reason2))) {
-            const provider = status2.action.provider;
+          const action = status2?.action;
+          const provider = typeof action?.provider === "string" ? action.provider : void 0;
+          const reason2 = action?.reason ?? "";
+          const message = typeof status2?.message === "string" ? status2.message : "";
+          const limited2 = reason2 === "free_tier_limit" || isLimitText(reason2) || isLimitText(message);
+          if (status2?.type === "retry" && limited2) {
             if (sessionID && isProbe(s, sessionID)) {
-              await log("debug", `probe on provider ${provider} was limited (${reason2 || "rate-limited"}); not cooling the provider`);
+              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) {
-              await log("warn", `limit on provider ${provider} (${reason2 || "rate-limited"}); cooling ${cooled.length} slot(s) until ${new Date(until).toISOString().slice(11, 19)}Z`, {
-                provider,
-                until,
-                models: cooled.map((c) => c.model)
-              });
+            const own = claimFor(sessionID);
+            const outage = isUnavailableText(message) && !isQuotaReason(reason2);
+            const named = outage ? UNAVAILABLE_REASON : reason2 || limitReason(message) || "rate-limited";
+            if (provider) {
+              const until = outage ? Date.now() + UNAVAILABLE_COOLDOWN_MS : typeof status2.next === "number" && status2.next > Date.now() ? status2.next : Date.now() + HANG_FALLBACK_MS;
+              const cooled = coolProvider(s, provider, until, named);
+              if (cooled.length > 0) {
+                await log("warn", `limit on provider ${provider} (${named}); cooling ${cooled.length} slot(s) until ${new Date(until).toISOString().slice(11, 19)}Z`, {
+                  provider,
+                  until,
+                  models: cooled.map((c) => c.model)
+                });
+              }
+            } else if (own) {
+              if (outage) {
+                const transient = coolUnavailable(s, own.claim.m);
+                if (transient) await log("warn", `cooling ${own.claim.m} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${transient.reason})`);
+              } else {
+                const stated2 = statedCooldown(message);
+                const strike2 = recordStrike(s, own.claim.m, named, stated2);
+                if (strike2) {
+                  await log("warn", `limit on ${own.claim.m} (${named}); cooling it for ${Math.round((strike2.until - Date.now()) / 1e3)}s`, {
+                    model: own.claim.m,
+                    slot: own.claim.k,
+                    session: sessionID
+                  });
+                }
+              }
+            }
+            if (provider) {
+              await failOver(sessionID, provider ?? own?.claim.m ?? "?", named, { stated: void 0, cool: false });
+            } else {
+              const stated2 = outage ? void 0 : statedCooldown(message);
+              await failOver(sessionID, own?.claim.m ?? "?", named, { stated: stated2, cool: !own });
+            }
+          }
+          return;
+        }
+        if (event.type === "session.error") {
+          const sessionID = typeof props.sessionID === "string" ? props.sessionID : void 0;
+          const error = props.error;
+          const haystack2 = JSON.stringify(error) ?? "";
+          if (sessionID && isProbe(s, sessionID)) {
+            await log("debug", `probe session ${sessionID} ended with an error; not cooling anything`);
+            return;
+          }
+          const status2 = typeof error?.data?.statusCode === "number" ? error.data.statusCode : void 0;
+          const limited2 = isLimitText(haystack2) || status2 === 429;
+          const outage = isUnavailableText(haystack2);
+          if (!limited2 && !outage) return;
+          const own = claimFor(sessionID);
+          const named = outage ? UNAVAILABLE_REASON : limitReason(haystack2) ?? "rate-limited";
+          let stated2;
+          if (own) {
+            if (outage) {
+              const transient = coolUnavailable(s, own.claim.m);
+              if (transient) {
+                await log("warn", `cooling ${own.claim.m} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${transient.reason}) after a terminal error`);
+              }
+            } else {
+              stated2 = statedCooldown(haystack2) ?? retryAfterMs(error?.data?.responseHeaders);
+              const strike2 = recordStrike(s, own.claim.m, named, stated2);
+              if (strike2) {
+                await log("warn", `limit on ${own.claim.m} (${named}); cooling it for ${Math.round((strike2.until - Date.now()) / 1e3)}s from a terminal session.error`, {
+                  model: own.claim.m,
+                  slot: own.claim.k,
+                  session: sessionID
+                });
+              }
             }
-            await failOver(sessionID, provider, reason2 || "rate-limited");
           }
+          await failOver(sessionID, own?.claim.m ?? "?", named, { stated: stated2, cool: !own });
           return;
         }
         if (event.type === "session.created") {
@@ -2138,32 +2663,38 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           await log("debug", `probe of ${model} hit a limit (${isLimitText(haystack) ? "limit" : "transient"}); leaving the cooldown to the probe`);
           return;
         }
+        const ownMsg = claimFor(info.sessionID);
         if (isUnavailableText(haystack) || !limited && transientGateway) {
           const transient = coolUnavailable(s, model);
           if (transient) await log("warn", `cooling ${model} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${transient.reason})`);
+          await failOver(info.sessionID, model, transient?.reason ?? UNAVAILABLE_REASON, { cool: false });
           return;
         }
         const stated = statedCooldown(haystack) ?? retryAfterMs(info.error.data?.responseHeaders);
-        const reason = haystack.match(/rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded/i)?.[0]?.toLowerCase().replace(/[\s_]/g, "-");
+        const reason = limitReason(haystack);
         const strike = recordStrike(s, model, reason ?? "rate-limited", stated);
         if (strike) await log("warn", `cooling ${model} for ${Math.round((strike.until - Date.now()) / 1e3)}s (${reason ?? "rate-limited"}, strike ${strike.strikes})`);
-        await failOver(info.sessionID, model, reason ?? "rate-limited");
+        await failOver(info.sessionID, model, reason ?? "rate-limited", { stated, cool: !ownMsg });
       } catch (error) {
         await log("error", `limit detection failed: ${String(error)}`);
       }
     },
     "tool.execute.before": async (input, output) => {
       if (input.tool !== "task") return;
-      const requested = output.args?.subagent_type;
-      if (typeof requested !== "string") return;
+      let requested = output.args?.subagent_type;
+      if (typeof requested !== "string") {
+        await warnOnce(
+          `task spawn has no subagent_type, so the pool cannot route it -- it will run on the caller's own model. Pass subagent_type "explore" or "implement" to use a slot.`
+        );
+        return;
+      }
       const manual = manualVariant(requested);
       if (manual) {
-        await log("warn", `refused manual spawn of a pool slot variant; spawn "${manual}" instead`, {
+        await log("warn", `rewrote a hand-named pool slot to its base; the pool owns slot choice`, {
           base: manual
         });
-        throw new Error(
-          `That agent is a pool slot variant and cannot be spawned by name. Naming it lets the caller pick the provider: it skips the round-robin rotation and the slot's ceiling, so one provider takes every concurrent claim. Spawn "${manual}" and let the pool choose the slot.`
-        );
+        requested = manual;
+        output.args.subagent_type = manual;
       }
       try {
         await reapStuck();
@@ -2176,8 +2707,6 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
             await warnOnce(`variant ${variant} missing from config; spawn left unchanged`);
             return;
           }
-          acquire(s, requested, slot, input.sessionID, claimKey(input.sessionID, input.callID));
-          output.args.subagent_type = variant;
           await log("info", `routed ${requested} to slot ${slot.index} on ${slot.model}`, {
             slot: slot.index,
             weight: slot.weight,
@@ -2185,6 +2714,8 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
             ceiling: slotCeiling(slot),
             load: (snap.counts.get(slot.model) ?? 0) + 1
           });
+          output.args.subagent_type = variant;
+          acquire(s, requested, slot, input.sessionID, claimKey(input.sessionID, input.callID));
           return;
         }
         const pinned = s.models.get(requested);
@@ -2204,22 +2735,24 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     },
     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.",
+        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 pool; if it is still limited, the existing cooldown stands; if the provider does not serve it at all, it is benched so routing stops choosing it. Pass `models` to validate those even when they are not cooling. Call it after editing the pool, 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.")
+          models: tool.schema.array(tool.schema.string()).optional().describe("Model ids to validate, as provider/model-id. Omit to probe only the models that are cooling.")
         },
         async execute(args) {
-          const report = await runProbe(args?.models);
+          const models = args?.models;
+          const report = models && models.length > 0 ? await runValidation(models) : await runProbe();
           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 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; COOLING/UNAVAILABLE = not routable. Check it before launching many parallel subagents.",
         args: {},
         async execute() {
           refreshCatalog(s, serverUrl);
           const slots = ensureSlots(s, (m) => void warnOnce(m));
           const snap = snapshot(s);
+          const pass = poolPass(s, snap);
           const now = Date.now();
           const byModel = /* @__PURE__ */ new Map();
           const add = (model, base) => {
@@ -2230,14 +2763,14 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           };
           for (const claim of snap.own.values()) add(claim.m, claim.v);
           for (const sibling of snap.siblings) for (const claim of sibling.claims) add(claim.m, claim.v);
-          const next = pickSlot(s, snap, { advance: false });
+          const next = pickSlot(s, snap);
           const line = (slot) => {
             const entry = byModel.get(slot.model);
             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 notes = [
-              strike ? `COOLING ${Math.ceil((strike.until - now) / 1e3)}s (${strike.reason}, strike ${strike.strikes})` : "",
+              strike ? `UNAVAILABLE (COOLING ${Math.ceil((strike.until - now) / 1e3)}s, ${strike.reason}, strike ${strike.strikes})` : "",
               status && status !== "active" && status !== "unknown" ? `catalog:${status}` : ""
             ].filter(Boolean);
             const marker = slot.index === next.index ? " <- next" : "";
@@ -2253,8 +2786,8 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           return {
             title: `agent-pool: ${total} task(s) in flight, ${coolingNow.length} model(s) cooling`,
             output: [
-              `shared pool over ${slots.length} model(s) from ${s.origin}; bases: ${BASES.join(", ")}
-round robin in slot order, each slot taking as many turns as its weight says, so no slot is starved while another drains (FULL = at ceiling, used only when every slot is)`,
+              `shared pool over ${slots.length} model(s) from ${s.origin}; pass ${pass}; bases: ${BASES.join(", ")}
+two ordered passes in slot order: pass 1 fills each slot to its weight, pass 2 to its ceiling, then overflow goes to the least-loaded slot (FULL = at ceiling, used only when no other slot is available and under its ceiling)`,
               ...slots.map(line),
               "",
               "by process:",
@@ -2268,8 +2801,9 @@ round robin in slot order, each slot taking as many turns as its weight says, so
               // 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(", ")}`
+              probeMs > 0 ? `cooldown probe: last ${s.lastProbe ? `${Math.max(0, Math.round((now - s.lastProbe) / 1e3))}s ago` : coolingNow.length > 0 ? "never in this process (cooldowns came from disk)" : "never (nothing has been cooling)"}, every ${Math.round(probeMs / 6e4)}m; call the pool_recheck tool (or run /pool-recheck) to ask now.` : "cooldown probe: off (probeMs: 0); call the pool_recheck tool (or run /pool-recheck) to ask now.",
+              watchMs > 0 ? `pool config watch: ${sources.join(", ")} every ${watchMs}ms; a change reloads the slot table and validates every slot.` : "pool config watch: off (watchMs: 0).",
+              coolingNow.length === 0 ? "no models cooling down." : `unavailable/cooling: ${coolingNow.map(([m, st]) => `${m} for ${Math.ceil((st.until - now) / 1e3)}s`).join(", ")}`
             ].join("\n")
           };
         }
@@ -2278,6 +2812,8 @@ round robin in slot order, each slot taking as many turns as its weight says, so
     dispose: async () => {
       clearInterval(timer);
       if (probeTimer) clearInterval(probeTimer);
+      if (reloadTimer) clearTimeout(reloadTimer);
+      for (const source of sources) unwatchFile(source, scheduleReload);
       s.own.clear();
       s.activity.clear();
       s.children.clear();
@@ -2287,8 +2823,8 @@ round robin in slot order, each slot taking as many turns as its weight says, so
 });
 
 // src/plugins/context-autoupdate.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
 import * as path2 from "node:path";
 
 // src/lib/active-backlog.ts
@@ -2439,7 +2975,7 @@ var parseJsonc = (raw) => {
 };
 
 // src/lib/writer-rule.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import * as path from "node:path";
 var CONTEXT_DIR = path.join(".opencode", "context");
 var WRITER = "context";
@@ -2479,7 +3015,7 @@ var agentsForm = (mapDir, projectRoot) => {
 var verifyWriterRule = (configPath, mapDir, projectRoot) => {
   let raw;
   try {
-    raw = readFileSync3(configPath, "utf8");
+    raw = readFileSync4(configPath, "utf8");
   } catch {
     return void 0;
   }
@@ -2580,7 +3116,7 @@ var snapshotMap = (dir) => {
     for (const name of readdirSync2(dir)) {
       const file = path2.join(dir, name);
       try {
-        const st = statSync2(file);
+        const st = statSync3(file);
         if (st.isFile()) out.set(name, `${st.size}:${st.mtimeMs}`);
       } catch {
       }
@@ -2597,15 +3133,15 @@ var changedSince = (before, dir) => {
   return changed;
 };
 var RETAIN_TRANSCRIPTS = 20;
-var transcriptDir = () => process.env.LACODE_TRANSCRIPT_DIR ?? path2.join(homedir2(), ".local", "share", "opencode", "lacode", "cartographer");
+var transcriptDir = () => process.env.LACODE_TRANSCRIPT_DIR ?? path2.join(homedir3(), ".local", "share", "opencode", "lacode", "cartographer");
 var retireSession = async (client, directory, sessionID, mode, log) => {
   try {
     const transcript = await client.session.messages({ path: { id: sessionID }, query: { directory } }).then((r) => r.data).catch(() => void 0);
     const dir = transcriptDir();
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync3(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));
+    writeFileSync3(file, JSON.stringify({ sessionID, mode, messages: transcript ?? null }, null, 2));
     pruneTranscripts(dir);
     const gone = async () => await client.session.get({ path: { id: sessionID }, query: { directory } }).then((r) => r.data).catch(() => void 0) === void 0;
     await client.session.delete({ path: { id: sessionID }, query: { directory } }).catch(() => void 0);
@@ -2626,7 +3162,7 @@ var pruneTranscripts = (dir) => {
     const entries = readdirSync2(dir).filter((name) => name.endsWith(".json")).sort();
     for (const name of entries.slice(0, Math.max(0, entries.length - RETAIN_TRANSCRIPTS))) {
       try {
-        unlinkSync2(path2.join(dir, name));
+        unlinkSync3(path2.join(dir, name));
       } catch {
       }
     }
@@ -2655,9 +3191,9 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
   const normalizeActiveBacklog = async () => {
     try {
       if (!existsSync2(activeBacklogPath)) return { removed: 0 };
-      const before = readFileSync4(activeBacklogPath, "utf8");
+      const before = readFileSync5(activeBacklogPath, "utf8");
       const { text, removed } = normalizeBacklog(before);
-      if (text !== before) writeFileSync2(activeBacklogPath, text);
+      if (text !== before) writeFileSync3(activeBacklogPath, text);
       if (removed.length > 0) {
         await log("info", `active backlog: dropped ${removed.length} task(s) finished more than a week ago`, {
           removed: removed.length
@@ -2695,7 +3231,7 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
     "",
     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". Also keep `.opencode/context/active.md` current: record work that is in flight, and mark a task finished \u2014 with the date it finished \u2014 when it is.'
+    'Follow the incremental-update procedure in your system prompt. Update a context file only if this work introduced or revealed information that will materially help future agents: a new boundary or module, a new or moved canonical entry point, a changed workflow, a new convention, an architectural decision, a new dependency between subsystems, a renamed or moved subsystem, or an invariant not yet recorded. Do not edit documentation merely because source files changed. If nothing material changed, make no edits and report "no update needed". Also keep `.opencode/context/active.md` current: record work that is in flight, and mark a task finished \u2014 with the date it finished \u2014 when it is.'
   ].join("\n");
   return {
     event: async ({ event }) => {
@@ -2809,12 +3345,330 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
   };
 });
 
+// src/plugins/image-paste.ts
+import { createHash, randomUUID } from "node:crypto";
+import { globSync, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename2, join as join6 } from "node:path";
+
+// src/lib/clipboard.ts
+import { spawnSync } from "node:child_process";
+import { readFile, rm } from "node:fs/promises";
+var RUN_TIMEOUT_MS = 3e3;
+var defaultRun = async (cmd, args) => {
+  try {
+    const result = spawnSync(cmd, args, {
+      timeout: RUN_TIMEOUT_MS,
+      killSignal: "SIGKILL",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stderr = result.stderr ? result.stderr.toString().trim() : "";
+    const detail = result.error ? String(result.error.code ?? result.error.message) : "";
+    return {
+      ok: result.status === 0,
+      stdout: result.stdout ?? Buffer.alloc(0),
+      stderr: [stderr, detail].filter(Boolean).join("\n")
+    };
+  } catch (error) {
+    return { ok: false, stdout: Buffer.alloc(0), stderr: String(error) };
+  }
+};
+var defaultHave = (cmd) => {
+  try {
+    return spawnSync("sh", ["-c", `command -v ${cmd}`], { encoding: "utf8" }).status === 0;
+  } catch {
+    return false;
+  }
+};
+var hasImageSignature = (bytes) => {
+  const head = bytes.toString("latin1", 0, 12);
+  if (head.startsWith("\x89PNG")) return true;
+  if (head.startsWith("\xFF\xD8\xFF")) return true;
+  if (head.startsWith("GIF8")) return true;
+  if (head.startsWith("RIFF") && head.slice(8, 12) === "WEBP") return true;
+  return false;
+};
+var validImage = (result) => {
+  if (!result.ok || result.stdout.length === 0) return null;
+  return hasImageSignature(result.stdout) ? result.stdout : null;
+};
+var linuxCandidates = (env) => {
+  const xclip = { cmd: "xclip", args: ["-selection", "clipboard", "-t", "image/png", "-o"] };
+  const wlPaste = { cmd: "wl-paste", args: ["--type", "image/png"] };
+  const wayland = Boolean(env.WAYLAND_DISPLAY) || env.XDG_SESSION_TYPE === "wayland";
+  return wayland ? [wlPaste, xclip] : [xclip, wlPaste];
+};
+var WINDOWS_SCRIPT = [
+  "Add-Type -AssemblyName System.Windows.Forms",
+  "Add-Type -AssemblyName System.Drawing",
+  "$img = [System.Windows.Forms.Clipboard]::GetImage()",
+  "if ($null -eq $img) { exit 1 }",
+  "$path = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), [System.IO.Path]::GetRandomFileName()) + '.png'",
+  "$img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png)",
+  "Write-Output $path"
+].join("\n");
+var readWindows = async (run) => {
+  const result = await run("powershell", ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_SCRIPT]);
+  if (!result.ok) return null;
+  const path4 = result.stdout.toString("utf8").replace(/^\uFEFF/, "").trim();
+  if (!path4) return null;
+  try {
+    return validImage({ ok: true, stdout: await readFile(path4) });
+  } finally {
+    await rm(path4, { force: true }).catch(() => {
+    });
+  }
+};
+async function readClipboardImage(deps = {}) {
+  try {
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const run = deps.run ?? defaultRun;
+    const have = deps.have ?? defaultHave;
+    if (platform === "darwin") {
+      if (!have("pngpaste")) return null;
+      return validImage(await run("pngpaste", ["-"]));
+    }
+    if (platform === "win32") {
+      return await readWindows(run);
+    }
+    if (platform === "linux") {
+      for (const candidate of linuxCandidates(env)) {
+        if (!have(candidate.cmd)) continue;
+        const bytes = validImage(await run(candidate.cmd, candidate.args));
+        if (bytes) return bytes;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/plugins/image-paste.ts
+var DEFAULT_MAX_BYTES = 4 * 1024 * 1024;
+function resolveMaxBytes(opts) {
+  if (typeof opts.maxBytes === "number" && Number.isFinite(opts.maxBytes)) return opts.maxBytes;
+  const parsed = Number.parseInt(process.env.LACODE_IMAGE_MAX_BYTES ?? "", 10);
+  return Number.isNaN(parsed) ? DEFAULT_MAX_BYTES : parsed;
+}
+var DEFAULT_MAX_IMAGES = 10;
+var MAX_TOTAL_BYTES = 20 * 1024 * 1024;
+function resolveMaxImages(opts) {
+  if (typeof opts.maxImages === "number" && Number.isFinite(opts.maxImages)) return opts.maxImages;
+  const parsed = Number.parseInt(process.env.LACODE_IMAGE_MAX_IMAGES ?? "", 10);
+  return Number.isNaN(parsed) ? DEFAULT_MAX_IMAGES : parsed;
+}
+function detectImageKind(bytes) {
+  if (bytes.length >= 4 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return { mime: "image/png", ext: "png" };
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return { mime: "image/jpeg", ext: "jpg" };
+  }
+  if (bytes.length >= 4 && bytes.toString("latin1", 0, 4) === "GIF8") {
+    return { mime: "image/gif", ext: "gif" };
+  }
+  if (bytes.length >= 12 && bytes.toString("latin1", 0, 4) === "RIFF" && bytes.toString("latin1", 8, 12) === "WEBP") {
+    return { mime: "image/webp", ext: "webp" };
+  }
+  return null;
+}
+function splitArguments(input) {
+  const out = [];
+  let current = "";
+  let quote = null;
+  for (const ch of input) {
+    if (quote !== null) {
+      if (ch === quote) quote = null;
+      else current += ch;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current !== "") out.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current !== "") out.push(current);
+  return out;
+}
+function expandTilde(p) {
+  if (p === "~") return homedir4();
+  if (p.startsWith("~/")) return join6(homedir4(), p.slice(2));
+  return p;
+}
+function expandGlob(p) {
+  try {
+    const matches = globSync(p);
+    if (matches.length > 0) return [...matches].sort();
+  } catch {
+  }
+  return [p];
+}
+function storeImage(bytes, dir, sessionID, label) {
+  const kind = detectImageKind(bytes);
+  if (kind === null) return null;
+  const hash = createHash("sha256").update(bytes).digest("hex");
+  mkdirSync4(dir, { recursive: true });
+  const target = join6(dir, `${hash}.${kind.ext}`);
+  const tmp = `${target}.tmp`;
+  writeFileSync4(tmp, bytes, { mode: 384 });
+  renameSync3(tmp, target);
+  const part = {
+    id: randomUUID(),
+    sessionID,
+    messageID: randomUUID(),
+    type: "file",
+    mime: kind.mime,
+    filename: `${label}-${hash.slice(0, 8)}.${kind.ext}`,
+    url: `data:${kind.mime};base64,${bytes.toString("base64")}`
+  };
+  return { part, hash };
+}
+function warn(input, message) {
+  input.client.app.log({ body: { service: "image-paste", level: "warn", message } }).catch(() => {
+  });
+}
+async function toast(input, message) {
+  try {
+    await input.client.tui.showToast({ body: { title: "lacode", message, variant: "warning" } });
+  } catch {
+  }
+}
+async function imagePasteHooks(input, options, deps) {
+  try {
+    const opts = options ?? {};
+    if (opts.enabled === false) return {};
+    const maxBytes = resolveMaxBytes(opts);
+    const maxImages = resolveMaxImages(opts);
+    const dir = opts.dir ?? process.env.LACODE_IMAGE_DIR ?? join6(homedir4(), ".local/share/opencode/lacode/images");
+    const readClipboard = (deps ?? {}).readClipboard ?? readClipboardImage;
+    return {
+      "command.execute.before": async (cmd, output) => {
+        try {
+          if (cmd.command === "image-in-cb") {
+            const bytes = await readClipboard();
+            if (bytes === null) {
+              warn(input, "No image on the clipboard");
+              await toast(input, "No image on the clipboard");
+              return;
+            }
+            if (bytes.length > maxBytes) {
+              const message = `image too large: ${bytes.length} bytes, max ${maxBytes}`;
+              warn(input, message);
+              await toast(input, message);
+              return;
+            }
+            const stored = storeImage(bytes, dir, cmd.sessionID, "clipboard");
+            if (stored === null) {
+              warn(input, "unsupported clipboard image format (expected PNG, JPEG, GIF or WebP)");
+              await toast(input, "unsupported clipboard image format (expected PNG, JPEG, GIF or WebP)");
+              return;
+            }
+            const firstText = output.parts.findIndex((p) => p.type === "text");
+            if (firstText === -1) output.parts.push(stored.part);
+            else output.parts.splice(firstText, 0, stored.part);
+            return;
+          }
+          if (cmd.command === "image") {
+            const rawArgs = typeof cmd.arguments === "string" ? cmd.arguments : "";
+            const resolved = [];
+            for (const arg of splitArguments(rawArgs)) resolved.push(...expandGlob(expandTilde(arg)));
+            const parts = [];
+            const seen = /* @__PURE__ */ new Set();
+            let totalBytes = 0;
+            const skipped = [];
+            for (const filePath of resolved) {
+              const name = basename2(filePath);
+              let size;
+              try {
+                const stat = statSync4(filePath);
+                if (!stat.isFile()) {
+                  skipped.push(name);
+                  continue;
+                }
+                size = stat.size;
+              } catch {
+                skipped.push(name);
+                continue;
+              }
+              if (size > maxBytes) {
+                skipped.push(name);
+                continue;
+              }
+              let bytes;
+              try {
+                bytes = readFileSync6(filePath);
+              } catch {
+                skipped.push(name);
+                continue;
+              }
+              if (detectImageKind(bytes) === null) {
+                skipped.push(name);
+                continue;
+              }
+              const hash = createHash("sha256").update(bytes).digest("hex");
+              if (seen.has(hash)) continue;
+              if (parts.length >= maxImages || totalBytes + bytes.length > MAX_TOTAL_BYTES) {
+                skipped.push(name);
+                continue;
+              }
+              const stored = storeImage(bytes, dir, cmd.sessionID, name.replace(/\.[^.]+$/, "") || "image");
+              if (stored === null) {
+                skipped.push(name);
+                continue;
+              }
+              seen.add(hash);
+              parts.push(stored.part);
+              totalBytes += bytes.length;
+            }
+            if (skipped.length > 0) {
+              const message = `skipped ${skipped.length} image file${skipped.length === 1 ? "" : "s"}: ${skipped.slice(0, 3).join(", ")}${skipped.length > 3 ? ", \u2026" : ""}`;
+              warn(input, message);
+              await toast(input, message);
+            }
+            if (parts.length > 0) {
+              const firstText = output.parts.findIndex((p) => p.type === "text");
+              if (firstText === -1) output.parts.push(...parts);
+              else output.parts.splice(firstText, 0, ...parts);
+            }
+            return;
+          }
+        } catch (error) {
+          try {
+            input.client.app.log({ body: { service: "image-paste", level: "error", message: `image-paste failed: ${String(error)}` } }).catch(() => {
+            });
+          } catch {
+          }
+        }
+      }
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/lib/prompt-guard.ts
+var SLOT = new RegExp(`\\b(${BASES.join("|")})(?:-[1-9][0-9]*)+\\b`, "g");
+function scrubSlotNames(text) {
+  return text.replace(SLOT, "$1");
+}
+
 // src/plugins/notify.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
 import * as path3 from "node:path";
 
 // src/lib/notify.ts
+import { closeSync as closeSync2, mkdirSync as mkdirSync5, openSync as openSync2, readFileSync as readFileSync7, renameSync as renameSync4, statSync as statSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5, writeSync as writeSync2 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join7 } from "node:path";
 var INTERNAL_TITLE_PREFIXES = [
   // context-autoupdate spawns the cartographer through the session API, with no
   // parentID, so it looks exactly like a root session going idle. Notifying for
@@ -2834,6 +3688,8 @@ var helperArgv = (helper, title, message, urgency, icon, sound) => {
 };
 var PERMISSION_REPLIES = ["once", "always", "reject"];
 var REQUEST_ID_ENV = "LACODE_REQUEST_ID";
+var NOTIFY_SESSION_ENV = "LACODE_NOTIFY_SESSION";
+var NOTIFY_CLOSE_ENV = "LACODE_NOTIFY_CLOSE";
 var safeStringify = (value) => {
   try {
     return JSON.stringify(value) ?? void 0;
@@ -2905,7 +3761,11 @@ var shouldNotify = (input) => {
   }
   const notification = {
     notify: true,
-    title: `opencode \u2014 ${title}`,
+    // The session's name on its own, with nothing in front of it. The popup's
+    // header is the notification's APP name, and that is "LaCode" -- so a
+    // prefix here would only repeat the app, and it would repeat it wrongly:
+    // the app is not "opencode".
+    title,
     message: notifyMessage(outcome, detail),
     urgency: outcome === "error" ? "critical" : "normal"
   };
@@ -2987,6 +3847,178 @@ var Notifier = class {
     return this.lastSent.size;
   }
 };
+var notificationStateDir = () => process.env.LACODE_NOTIFY_DIR ?? join7(homedir5(), ".local", "share", "opencode", "lacode", "notify");
+var safeCorrelationKey = (correlationKey) => correlationKey.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 64);
+var CLAIM_WINDOW_MS = 5e3;
+var isPidAlive2 = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+var claimFile = (sessionID, kind) => join7(notificationStateDir(), `claim.${safeCorrelationKey(`${sessionID}.${kind}`)}`);
+var claimNotification = (sessionID, kind) => {
+  const path4 = claimFile(sessionID, kind);
+  try {
+    mkdirSync5(notificationStateDir(), { recursive: true });
+  } catch {
+    return true;
+  }
+  const take = () => {
+    try {
+      const fd = openSync2(path4, "wx");
+      try {
+        writeSync2(fd, String(process.pid));
+      } finally {
+        closeSync2(fd);
+      }
+      return "taken";
+    } catch (error) {
+      return error.code === "EEXIST" ? "held" : "impossible";
+    }
+  };
+  const first = take();
+  if (first !== "held") {
+    return true;
+  }
+  const judge = () => {
+    let raw;
+    try {
+      raw = readFileSync7(path4, "utf8").trim();
+    } catch (error) {
+      return error.code === "ENOENT" ? "gone" : "unknown";
+    }
+    let holder;
+    const empty = raw === "";
+    if (!empty) {
+      const parsed = Number.parseInt(raw, 10);
+      holder = Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+    }
+    if (holder === process.pid) return "ours";
+    let age = Number.POSITIVE_INFINITY;
+    try {
+      age = Date.now() - statSync5(path4).mtimeMs;
+    } catch {
+      return "gone";
+    }
+    if (empty && age < CLAIM_WINDOW_MS) {
+      return "held";
+    }
+    if (holder !== void 0 && isPidAlive2(holder) && age < CLAIM_WINDOW_MS) {
+      return "held";
+    }
+    return "stale";
+  };
+  const judged = judge();
+  if (judged === "ours") return true;
+  if (judged === "held") return false;
+  if (judged === "unknown") return true;
+  if (judged === "gone") return take() !== "held";
+  const lockPath = `${path4}.takeover`;
+  const takeOver = () => {
+    const create = () => {
+      try {
+        const fd = openSync2(lockPath, "wx");
+        try {
+          writeSync2(fd, String(process.pid));
+        } finally {
+          closeSync2(fd);
+        }
+        return () => {
+          try {
+            unlinkSync4(lockPath);
+          } catch {
+          }
+        };
+      } catch (error) {
+        return error.code === "EEXIST" ? void 0 : () => {
+        };
+      }
+    };
+    const release3 = create();
+    if (release3 !== void 0) return release3;
+    let lockHolder;
+    let lockAge = Number.POSITIVE_INFINITY;
+    try {
+      const parsed = Number.parseInt(readFileSync7(lockPath, "utf8").trim(), 10);
+      lockHolder = Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+      lockAge = Date.now() - statSync5(lockPath).mtimeMs;
+    } catch {
+      return create();
+    }
+    if (lockAge < CLAIM_WINDOW_MS && (lockHolder === void 0 || isPidAlive2(lockHolder))) {
+      return void 0;
+    }
+    try {
+      unlinkSync4(lockPath);
+    } catch {
+      return void 0;
+    }
+    return create();
+  };
+  const release2 = takeOver();
+  if (release2 === void 0) return false;
+  try {
+    const current = judge();
+    if (current === "ours") return true;
+    if (current === "held") return false;
+    if (current === "unknown") return true;
+    try {
+      unlinkSync4(path4);
+    } catch {
+    }
+    return take() !== "held";
+  } finally {
+    release2();
+  }
+};
+var releaseNotificationClaim = (sessionID, kind) => {
+  const path4 = claimFile(sessionID, kind);
+  try {
+    const parsed = Number.parseInt(readFileSync7(path4, "utf8").trim(), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) return;
+    if (parsed !== process.pid) return;
+    unlinkSync4(path4);
+  } catch {
+  }
+};
+var completionFile = (sessionID) => join7(notificationStateDir(), `completion.${safeCorrelationKey(sessionID)}`);
+var claimCompletion = (sessionID, kind) => {
+  const path4 = completionFile(sessionID);
+  try {
+    mkdirSync5(notificationStateDir(), { recursive: true });
+    const fd = openSync2(path4, "wx");
+    try {
+      writeFileSync5(fd, `${process.pid} ${kind}
+`);
+    } finally {
+      closeSync2(fd);
+    }
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    return true;
+  }
+};
+var releaseCompletion = (sessionID) => {
+  try {
+    unlinkSync4(completionFile(sessionID));
+  } catch {
+  }
+};
+var markCompletion = (sessionID, kind) => {
+  try {
+    mkdirSync5(notificationStateDir(), { recursive: true });
+    const path4 = completionFile(sessionID);
+    const tmp = `${path4}.${process.pid}.tmp`;
+    writeFileSync5(tmp, `${process.pid} ${kind}
+`);
+    renameSync4(tmp, path4);
+  } catch {
+  }
+};
 
 // src/plugins/notify.ts
 var SERVICE3 = "notify";
@@ -2995,6 +4027,9 @@ var MAX_INFLIGHT_HELPERS = 4;
 var HELPER_TIMEOUT_MS = 3e4;
 var ACTION_TIMEOUT_MS = 10 * 6e4 + 3e4;
 var MAX_TRACKED_SESSIONS = 500;
+var MIN_VISIBLE_MS = 5e3;
+var PERMISSION_SETTLE_MS = 250;
+var UNANSWERABLE_REQUEST = "";
 var SOUND_ENV = "LACODE_SOUND";
 var SOUND_OFF_VALUES = ["0", "false", "off", "no"];
 var findHelper = () => {
@@ -3020,7 +4055,9 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
   const active = /* @__PURE__ */ new Set();
   const titles = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Set();
-  const permissions = /* @__PURE__ */ new Set();
+  const permissions = /* @__PURE__ */ new Map();
+  const pendingPermissionPopups = /* @__PURE__ */ new Map();
+  const live = /* @__PURE__ */ new Map();
   let warnedHelper = false;
   let inflight = 0;
   const rememberActive = (sessionID) => {
@@ -3031,17 +4068,43 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
     titles.set(id, title);
     while (titles.size > MAX_TRACKED_SESSIONS) titles.delete(titles.keys().next().value);
   };
+  const rememberLive = (sessionID, popup) => {
+    const previous = live.get(sessionID);
+    if (previous?.timer) clearTimeout(previous.timer);
+    live.set(sessionID, popup);
+    while (live.size > MAX_TRACKED_SESSIONS) {
+      const oldest = live.keys().next().value;
+      const forgotten = live.get(oldest);
+      if (forgotten?.timer) clearTimeout(forgotten.timer);
+      live.delete(oldest);
+    }
+  };
+  const forgetLive = (sessionID) => {
+    const popup = live.get(sessionID);
+    if (popup?.timer) clearTimeout(popup.timer);
+    live.delete(sessionID);
+  };
+  const rememberPermissions = (sessionID, requests) => {
+    permissions.set(sessionID, requests);
+    while (permissions.size > MAX_TRACKED_SESSIONS) {
+      const oldest = permissions.keys().next().value;
+      permissions.delete(oldest);
+    }
+  };
+  const forgetPermission = (sessionID, requestID) => {
+    const outstanding = permissions.get(sessionID);
+    if (!outstanding) return;
+    outstanding.delete(requestID);
+    if (outstanding.size === 0) permissions.delete(sessionID);
+  };
+  const forgetPermissionPopup = (sessionID) => {
+    const timer = pendingPermissionPopups.get(sessionID);
+    if (timer) clearTimeout(timer);
+    pendingPermissionPopups.delete(sessionID);
+  };
   const log = (level, message, extra) => client.app.log({ body: { service: SERVICE3, level, message, extra } }).catch(() => {
   });
-  const answerPermission = async (sessionID, requestID, action) => {
-    const response = PERMISSION_REPLIES.find((candidate) => candidate === action);
-    if (!response) {
-      void log("warn", `notification action ignored: ${JSON.stringify(action)} is not a permission reply`, {
-        sessionID,
-        requestID
-      });
-      return;
-    }
+  const replyPermission = async (sessionID, requestID, response) => {
     const errorStatus = (error) => {
       const candidate = error;
       const status2 = candidate?.response?.status ?? candidate?.cause?.status ?? candidate?.status;
@@ -3054,6 +4117,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
     const status = "result" in reply ? reply.result.response?.status : errorStatus(reply.error);
     if (status === 404) {
       void log("debug", "permission already answered", { sessionID, requestID });
+      forgetPermission(sessionID, requestID);
       return;
     }
     if ("error" in reply) {
@@ -3070,13 +4134,27 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       });
       return;
     }
+    forgetPermission(sessionID, requestID);
     void log("info", "permission answered from the notification", { sessionID, requestID, response });
   };
+  const answerPermission = async (sessionID, requestIDs, action) => {
+    const response = PERMISSION_REPLIES.find((candidate) => candidate === action);
+    if (!response) {
+      void log("warn", `notification action ignored: ${JSON.stringify(action)} is not a permission reply`, {
+        sessionID,
+        requestIDs
+      });
+      return;
+    }
+    for (const requestID of requestIDs) {
+      await replyPermission(sessionID, requestID, response);
+    }
+  };
   const fetchInfo = async (sessionID) => {
     const info = await client.session.get({ path: { id: sessionID }, query: { directory } }).then((result) => result.data).catch(() => void 0);
     return info;
   };
-  const deliverViaHelper = (title, message, urgency, sound, requestID) => new Promise((resolve3) => {
+  const deliverViaHelper = (title, message, urgency, sound, requestID, sessionID) => 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})` });
@@ -3091,15 +4169,17 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       resolve3({ ok: false, detail: "no oc-notify helper found" });
       return;
     }
+    const childEnv = { ...process.env, ...sessionID ? { [NOTIFY_SESSION_ENV]: sessionID } : {} };
     const actionable = Boolean(requestID);
     const timeoutMs = actionable ? ACTION_TIMEOUT_MS : helperTimeoutMs;
-    const child = actionable ? spawn(helper, helperArgv(helper, title, message, urgency, "utilities-terminal", sound), {
+    const child = actionable ? spawn2(helper, helperArgv(helper, title, message, urgency, "utilities-terminal", sound), {
       stdio: ["ignore", "pipe", "pipe"],
       detached: false,
-      env: { ...process.env, [REQUEST_ID_ENV]: requestID }
-    }) : spawn(helper, helperArgv(helper, title, message, urgency, "utilities-terminal", sound), {
+      env: { ...childEnv, [REQUEST_ID_ENV]: requestID }
+    }) : spawn2(helper, helperArgv(helper, title, message, urgency, "utilities-terminal", sound), {
       stdio: ["ignore", "ignore", "pipe"],
-      detached: true
+      detached: true,
+      env: childEnv
     });
     inflight++;
     let settled = false;
@@ -3147,6 +4227,88 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
     if (!actionable) child.unref();
   });
   const deliver = deps.deliver ?? deliverViaHelper;
+  const closeViaHelper = (sessionID) => {
+    try {
+      const helper = findHelper();
+      if (!helper) {
+        if (!warnedHelper) {
+          warnedHelper = true;
+          void log("warn", "no oc-notify helper found; run 'bin/oc-sync' to install one");
+        }
+        return;
+      }
+      const child = spawn2(helper, helperArgv(helper, "opencode", "", "normal", "utilities-terminal", "none"), {
+        stdio: ["ignore", "ignore", "pipe"],
+        detached: true,
+        env: { ...process.env, [NOTIFY_CLOSE_ENV]: sessionID }
+      });
+      child.on("error", (error) => {
+        void log("warn", `notification close failed: ${String(error)}`, { sessionID });
+      });
+      child.on("exit", (code) => {
+        if (code !== 0) void log("warn", `notification not closed: helper exit ${code}`, { sessionID });
+      });
+      child.unref();
+    } catch (error) {
+      void log("warn", `notification close failed: ${String(error)}`, { sessionID });
+    }
+  };
+  const close = deps.close ?? closeViaHelper;
+  const dismiss = (sessionID) => {
+    const popup = live.get(sessionID);
+    if (!popup) return;
+    if (popup.timer) {
+      clearTimeout(popup.timer);
+      popup.timer = void 0;
+    }
+    popup.raisedAt = Date.now();
+    const failed = (error) => void log("warn", `notification dismiss failed: ${String(error)}`, { sessionID });
+    try {
+      const outcome = close(sessionID);
+      if (outcome && typeof outcome.catch === "function") void outcome.catch(failed);
+    } catch (error) {
+      failed(error);
+    }
+  };
+  const scheduleDismiss = (sessionID) => {
+    const popup = live.get(sessionID);
+    if (!popup) return;
+    if (popup.timer) return;
+    const delay = Math.max(0, popup.raisedAt + MIN_VISIBLE_MS - Date.now());
+    const timer = setTimeout(() => dismiss(sessionID), delay);
+    timer.unref?.();
+    popup.timer = timer;
+  };
+  const noteInteraction = (sessionID) => {
+    const popup = live.get(sessionID);
+    if (!popup) return;
+    popup.interacted = true;
+    scheduleDismiss(sessionID);
+  };
+  const claimReleases = /* @__PURE__ */ new Map();
+  const scheduleClaimRelease = (sessionID, kind) => {
+    const key = `${kind}:${sessionID}`;
+    if (claimReleases.has(key)) return;
+    const timer = setTimeout(() => {
+      claimReleases.delete(key);
+      releaseNotificationClaim(sessionID, kind);
+    }, COOLDOWN_MS2);
+    timer.unref?.();
+    claimReleases.set(key, timer);
+  };
+  const raisePermissionPopup = (sessionID, requestID, headline) => {
+    forgetPermissionPopup(sessionID);
+    const timer = setTimeout(() => {
+      if (pendingPermissionPopups.get(sessionID) !== timer) return;
+      pendingPermissionPopups.delete(sessionID);
+      const outstanding = permissions.get(sessionID);
+      if (!outstanding || outstanding.size === 0) return;
+      const detail = outstanding.size > 1 ? `${outstanding.size} requests` : headline;
+      void announce(sessionID, "permission", detail || void 0, requestID);
+    }, PERMISSION_SETTLE_MS);
+    timer.unref?.();
+    pendingPermissionPopups.set(sessionID, timer);
+  };
   const announce = async (sessionID, outcome, detail, requestID) => {
     try {
       const info = await fetchInfo(sessionID);
@@ -3180,10 +4342,38 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
         void log("debug", "suppressed: cooldown", { sessionID });
         return;
       }
+      if (outcome === "done") {
+        if (!claimCompletion(sessionID, "done")) {
+          void log("debug", "suppressed: completion already announced", { sessionID });
+          return;
+        }
+      } else if (!claimNotification(sessionID, kind)) {
+        void log("debug", "suppressed: another process is raising this", { sessionID, kind });
+        return;
+      } else if (outcome === "error") {
+        markCompletion(sessionID, "error");
+      }
       const message = isRemote ? `${decision.message} (remote)` : decision.message;
       const sound = soundOn && NOTIFY_OUTCOMES.includes(outcome) ? outcome : "none";
-      const sent = await deliver(decision.title, message, decision.urgency, sound, requestID);
-      if (sent.action && requestID) await answerPermission(sessionID, requestID, sent.action);
+      const previous = live.get(sessionID);
+      const popup = { raisedAt: Date.now(), interacted: previous?.interacted ?? false };
+      rememberLive(sessionID, popup);
+      if (popup.interacted) scheduleDismiss(sessionID);
+      let sent = { ok: false };
+      try {
+        sent = await deliver(decision.title, message, decision.urgency, sound, requestID, sessionID);
+      } catch (error) {
+        if (outcome === "done" || outcome === "error") releaseCompletion(sessionID);
+        throw error;
+      } finally {
+        if (outcome !== "done") scheduleClaimRelease(sessionID, kind);
+      }
+      if ((outcome === "done" || outcome === "error") && !sent.ok) releaseCompletion(sessionID);
+      if (sent.action && requestID) {
+        const outstanding = permissions.get(sessionID);
+        const ids = outstanding ? [...outstanding].filter((id) => id !== UNANSWERABLE_REQUEST) : [];
+        await answerPermission(sessionID, ids.length > 0 ? ids : [requestID], sent.action);
+      }
       const answered = Boolean(sent.action);
       void log(answered || sent.ok ? "info" : "error", answered ? "permission answered from the notification" : sent.ok ? "notified" : "notification failed", {
         sessionID,
@@ -3200,7 +4390,15 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       try {
         if (event.type === "session.status") {
           const { sessionID: sessionID2, status } = event.properties;
-          if (status.type === "busy" && sessionID2) rememberActive(sessionID2);
+          if (status.type === "busy" && sessionID2) {
+            rememberActive(sessionID2);
+            releaseCompletion(sessionID2);
+          }
+          return;
+        }
+        if (event.type === "message.updated") {
+          const info = event.properties.info;
+          if (info?.role === "user" && info.sessionID) noteInteraction(info.sessionID);
           return;
         }
         if (event.type === "session.updated") {
@@ -3220,22 +4418,34 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
         }
         if (event.type === "question.replied" || event.type === "question.rejected") {
           const sessionID2 = event.properties?.sessionID;
-          if (sessionID2) pending.delete(sessionID2);
+          if (sessionID2) {
+            pending.delete(sessionID2);
+            noteInteraction(sessionID2);
+          }
           return;
         }
         if (event.type === "permission.asked") {
           const properties = event.properties;
           const sessionID2 = properties?.sessionID;
           if (!sessionID2) return;
-          permissions.add(sessionID2);
-          rememberActive(sessionID2);
           const requestID = typeof properties?.id === "string" && properties.id ? properties.id : void 0;
-          void announce(sessionID2, "permission", permissionHeadline(properties) || void 0, requestID);
+          const outstanding = permissions.get(sessionID2) ?? /* @__PURE__ */ new Set();
+          const first = outstanding.size === 0;
+          outstanding.add(requestID ?? UNANSWERABLE_REQUEST);
+          rememberPermissions(sessionID2, outstanding);
+          rememberActive(sessionID2);
+          if (!first) return;
+          raisePermissionPopup(sessionID2, requestID, permissionHeadline(properties));
           return;
         }
         if (event.type === "permission.replied") {
           const sessionID2 = event.properties?.sessionID;
-          if (sessionID2) permissions.delete(sessionID2);
+          if (sessionID2) {
+            const requestID = event.properties?.requestID;
+            if (requestID) forgetPermission(sessionID2, requestID);
+            else permissions.delete(sessionID2);
+            noteInteraction(sessionID2);
+          }
           return;
         }
         if (event.type === "session.error") {
@@ -3259,6 +4469,9 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
             titles.delete(sessionID2);
             pending.delete(sessionID2);
             permissions.delete(sessionID2);
+            forgetLive(sessionID2);
+            forgetPermissionPopup(sessionID2);
+            releaseCompletion(sessionID2);
           }
           return;
         }
@@ -3709,10 +4922,10 @@ var omniRouteHooks = async (input, options, deps = {}) => {
   };
   let started = null;
   const initialize = () => started ??= probe();
-  const injectProvider = async (cfg, warn) => {
+  const injectProvider = async (cfg, warn2) => {
     const providers = cfg.provider ??= {};
     if (providers.omniroute !== void 0) {
-      await warn("omniroute provider is already defined in your config; lacode left it untouched");
+      await warn2("omniroute provider is already defined in your config; lacode left it untouched");
       return;
     }
     const exposed = selector.candidates();
@@ -3754,267 +4967,6 @@ var omniRouteHooks = async (input, options, deps = {}) => {
   };
 };
 
-// src/lib/selfupdate.ts
-import { spawn as spawn2 } from "node:child_process";
-import { closeSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync5, 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;
-var FETCH_TIMEOUT_MS = 4e3;
-var INSTALL_TIMEOUT_MS = 12e4;
-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(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) {
-  const parse = (v) => v.split("-")[0].split("+")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
-  const left = parse(a);
-  const right = parse(b);
-  for (let i = 0; i < 3; i++) {
-    const l = left[i] ?? 0;
-    const r = right[i] ?? 0;
-    if (l !== r) return l > r ? 1 : -1;
-  }
-  return 0;
-}
-function readInstalledVersion(packageRoot, read = (path4) => {
-  try {
-    return readFileSync5(path4, "utf8");
-  } catch {
-    return void 0;
-  }
-}) {
-  try {
-    const raw = read(join6(packageRoot, "package.json"));
-    if (raw === void 0) return void 0;
-    const manifest = JSON.parse(raw);
-    if (manifest.name !== PACKAGE_NAME) return void 0;
-    return typeof manifest.version === "string" ? manifest.version : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function resolveCacheRoot(packageRoot, exists = (p) => {
-  try {
-    return statSync3(p).isFile();
-  } catch {
-    return false;
-  }
-}) {
-  const tail = join6("node_modules", "@lawaty", "lacode");
-  if (!packageRoot.endsWith(tail)) return void 0;
-  const cacheRoot = resolve2(packageRoot, "..", "..", "..");
-  if (!exists(join6(cacheRoot, "package.json"))) return void 0;
-  return cacheRoot;
-}
-function resolveOpencodeBin(execPath = process.execPath, env = process.env, exists = (p) => {
-  try {
-    return statSync3(p).isFile();
-  } catch {
-    return false;
-  }
-}) {
-  if (execPath && /(^|[\\/])opencode(\.exe)?$/.test(execPath)) return execPath;
-  for (const dir of (env.PATH ?? "").split(":")) {
-    if (!dir) continue;
-    const candidate = join6(dir, "opencode");
-    if (exists(candidate)) return candidate;
-  }
-  const fallback = join6(homedir3(), ".opencode", "bin", "opencode");
-  return exists(fallback) ? fallback : void 0;
-}
-async function fetchLatest(fetchImpl = fetch, timeoutMs = FETCH_TIMEOUT_MS) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetchImpl(REGISTRY_LATEST, { signal: controller.signal });
-    if (!response.ok) return void 0;
-    const body = await response.json();
-    return typeof body.version === "string" ? body.version : void 0;
-  } catch {
-    return void 0;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function readState(path4 = STATE_PATH) {
-  try {
-    return JSON.parse(readFileSync5(path4, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeState(state2, path4 = STATE_PATH) {
-  try {
-    mkdirSync3(dirname3(path4), { recursive: true });
-    writeFileSync3(path4, JSON.stringify(state2));
-  } catch {
-  }
-}
-var isDue = (state2, now, interval = CHECK_INTERVAL_MS) => typeof state2.checkedAt !== "number" || now - state2.checkedAt >= interval;
-var isProcessAlive = (pid) => {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-};
-function acquireLock(path4 = LOCK_PATH, now = Date.now()) {
-  const claim = () => {
-    const fd = openSync(path4, "wx");
-    writeSync(fd, String(process.pid));
-    closeSync(fd);
-    return () => {
-      try {
-        unlinkSync3(path4);
-      } catch {
-      }
-    };
-  };
-  try {
-    mkdirSync3(dirname3(path4), { recursive: true });
-    return claim();
-  } catch {
-    let orphaned = false;
-    try {
-      const pid = Number.parseInt(readFileSync5(path4, "utf8").trim(), 10);
-      orphaned = !Number.isFinite(pid) || pid <= 0 || !isProcessAlive(pid);
-    } catch {
-      orphaned = true;
-    }
-    if (!orphaned) {
-      try {
-        orphaned = now - statSync3(path4).mtimeMs > LOCK_STALE_MS;
-      } catch {
-        orphaned = true;
-      }
-    }
-    if (!orphaned) return void 0;
-    try {
-      unlinkSync3(path4);
-    } catch {
-      return void 0;
-    }
-    try {
-      return claim();
-    } catch {
-      return void 0;
-    }
-  }
-}
-async function checkForUpdate(opts) {
-  const installed = readInstalledVersion(opts.packageRoot);
-  const latest = await fetchLatest(opts.fetchImpl);
-  return {
-    installed,
-    latest,
-    newer: Boolean(installed && latest && compareSemver(latest, installed) > 0),
-    cacheRoot: resolveCacheRoot(opts.packageRoot, opts.exists),
-    bin: resolveOpencodeBin(opts.execPath, opts.env, opts.exists)
-  };
-}
-async function refreshCache(opts) {
-  const { cacheRoot, bin, latest } = opts;
-  const spawnImpl = opts.spawnImpl ?? spawn2;
-  const timeoutMs = opts.timeoutMs ?? INSTALL_TIMEOUT_MS;
-  const fresh = join6(cacheRoot, "node_modules", "@lawaty", "lacode");
-  const aside = `${cacheRoot}.stale-${Date.now()}`;
-  try {
-    rmSync(aside, { recursive: true, force: true });
-    renameSync2(cacheRoot, aside);
-  } catch (error) {
-    return { ok: false, detail: `could not set the old cache aside: ${String(error)}` };
-  }
-  const exited = await new Promise((settle) => {
-    let done = false;
-    const finish = (value) => {
-      if (done) return;
-      done = true;
-      clearTimeout(timer);
-      settle(value);
-    };
-    const child = spawnImpl(bin, ["plugin", PACKAGE_NAME, "-g"], {
-      env: { ...process.env, [CHILD_ENV]: "1" },
-      stdio: "ignore"
-    });
-    const timer = setTimeout(() => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-      finish(false);
-    }, timeoutMs);
-    child.on("error", () => finish(false));
-    child.on("exit", (code) => finish(code === 0));
-  });
-  const installed = readInstalledVersion(fresh);
-  const ok = exited && installed === latest;
-  if (ok) {
-    try {
-      rmSync(aside, { recursive: true, force: true });
-    } catch {
-    }
-  } else {
-    try {
-      renameSync2(aside, cacheRoot);
-    } catch {
-    }
-  }
-  return {
-    ok,
-    detail: ok ? `installed ${installed}` : `installer exited ${exited ? "0" : "non-zero"}, cache now ${installed ?? "missing"}`
-  };
-}
-async function maybeSelfUpdate(opts) {
-  const env = opts.env ?? process.env;
-  if (opts.enabled === false || env[CHILD_ENV] === "1" || env[OPT_OUT_ENV] === "1" || inTestRunner(env)) {
-    return { action: "disabled" };
-  }
-  const now = (opts.now ?? Date.now)();
-  const statePath = opts.statePath ?? STATE_PATH;
-  const state2 = readState(statePath);
-  if (!isDue(state2, now, opts.intervalMs ?? CHECK_INTERVAL_MS)) return { action: "skipped", detail: "checked recently" };
-  const release2 = acquireLock(opts.lockPath, now);
-  if (!release2) return { action: "skipped", detail: "another process is updating" };
-  try {
-    const check = await checkForUpdate(opts);
-    if (!check.installed) return { action: "skipped", detail: "no installed version" };
-    if (!check.latest) {
-      writeState({ ...state2, checkedAt: now }, statePath);
-      return { action: "skipped", detail: "registry unreachable" };
-    }
-    if (!check.newer) {
-      writeState({ ...state2, checkedAt: now, latest: check.latest }, statePath);
-      return { action: "current", detail: `${check.installed} is current` };
-    }
-    if (!check.cacheRoot) {
-      writeState({ ...state2, checkedAt: now, latest: check.latest }, statePath);
-      return { action: "skipped", detail: "not an opencode cache install" };
-    }
-    if (!check.bin) {
-      writeState({ ...state2, checkedAt: now, latest: check.latest }, statePath);
-      opts.log?.("warn", `LaCode ${check.latest} is available but no opencode binary was found to install it`);
-      return { action: "failed", detail: "no opencode binary" };
-    }
-    const result = await refreshCache({ cacheRoot: check.cacheRoot, bin: check.bin, latest: check.latest, spawnImpl: opts.spawnImpl });
-    if (result.ok) {
-      writeState({ ...state2, checkedAt: now, latest: check.latest, updatedTo: check.latest }, statePath);
-      opts.log?.("info", `LaCode updated ${check.installed} -> ${check.latest}; restart opencode to apply`);
-      return { action: "updated", detail: `${check.installed} -> ${check.latest}` };
-    }
-    writeState({ ...state2, checkedAt: now, latest: check.latest }, statePath);
-    opts.log?.("warn", `LaCode update to ${check.latest} failed: ${result.detail}`);
-    return { action: "failed", detail: result.detail };
-  } finally {
-    release2();
-  }
-}
-
 // src/plugins/selfupdate.ts
 async function selfUpdateHooks(input, options) {
   const opts = options ?? {};
@@ -4036,11 +4988,24 @@ var inertHooks = {
   dispose: async () => {
   }
 };
+var promptDriftWarned = false;
 var LaCode = (async (input, options) => {
   const opts = options ?? {};
   if (opts.enabled === false) return inertHooks;
   const log = (level, message, extra) => input.client.app.log({ body: { service: "lacode", level, message, extra } }).catch(() => {
   });
+  const warnPromptDrift = async () => {
+    if (promptDriftWarned) return;
+    promptDriftWarned = true;
+    await log("warn", "a system prompt named a pool slot variant; stripped it before the model saw it. Remove the literal from the prompt source.");
+  };
+  let version;
+  try {
+    version = readInstalledVersion(PACKAGE_ROOT);
+  } catch {
+    version = void 0;
+  }
+  await log("info", version ? `lacode ${version} started` : "lacode started");
   const settled = async (label, make) => {
     try {
       return await make();
@@ -4055,6 +5020,7 @@ var LaCode = (async (input, options) => {
   const notifier = await settled("notify", () => notifyHooks(input, options)) ?? inertHooks;
   const selfupdate = await settled("self-update", () => selfUpdateHooks(input, options)) ?? inertHooks;
   const omniroute = await settled("omniroute", () => omniRouteHooks(input, options)) ?? inertHooks;
+  const imagepaste = await settled("image-paste", () => imagePasteHooks(input, opts.imagePaste)) ?? inertHooks;
   const config = async (cfg) => {
     try {
       const injected = applyAgents(cfg, agentSet);
@@ -4089,12 +5055,30 @@ var LaCode = (async (input, options) => {
     "tool.execute.before": pool["tool.execute.before"],
     "tool.execute.after": pool["tool.execute.after"],
     tool: pool.tool,
+    "command.execute.before": imagepaste["command.execute.before"],
     dispose: async () => {
       await pool.dispose?.();
       await autoupdate.dispose?.();
       await notifier.dispose?.();
       await selfupdate.dispose?.();
       await omniroute.dispose?.();
+      await imagepaste.dispose?.();
+    },
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (!Array.isArray(output?.system)) return;
+      let changed = false;
+      for (let i = 0; i < output.system.length; i++) {
+        const text = output.system[i];
+        if (typeof text !== "string") continue;
+        const scrubbed = scrubSlotNames(text);
+        if (scrubbed !== text) {
+          output.system[i] = scrubbed;
+          changed = true;
+        }
+      }
+      if (changed) {
+        await warnPromptDrift();
+      }
     }
   };
 });