@lawaty/lacode 0.9.0 → 0.11.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));
@@ -1713,7 +1741,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
@@ -1731,16 +1759,27 @@ The pool is ONE global slot table shared by every pooled base (explore, implemen
 
 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.
 
-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.`
   }
 };
 function applyCommands(cfg, commands = COMMANDS) {
@@ -1758,7 +1797,269 @@ function applyCommands(cfg, commands = COMMANDS) {
   return { added, kept };
 }
 
+// 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 readFileSync3(path4, "utf8");
+  } catch {
+    return void 0;
+  }
+}) {
+  try {
+    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 {
+    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";
+  }
+};
+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 {
+    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;
+    }
+  }
+}
+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
@@ -1776,8 +2077,8 @@ var failureText = (error) => {
 };
 var shortReason = (text) => {
   if (!text) return "failed";
-  const matched = text.match(/rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded/i)?.[0];
-  return matched ? matched.toLowerCase().replace(/[\s_]/g, "-") : isLimitText(text) ? "limit" : "failed";
+  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;
@@ -1824,8 +2125,12 @@ var probeOne = async (client, opts, model, leftSeconds) => {
       return settle(true, "answered", 0);
     }
     const text = failureText(failure);
-    const stated = statedCooldown(text);
-    if (stated !== void 0) recordStrike(s, model, shortReason(text), stated);
+    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,
@@ -1838,16 +2143,48 @@ var probeOne = async (client, opts, model, leftSeconds) => {
     if (deleted) unmarkProbe(s, created);
   }
 };
-async function probeCooling(client, opts) {
+async function probeModels(client, opts) {
   const s = opts.state;
   const now = opts.now ?? Date.now;
-  const empty = { outcomes: [], cleared: [], kept: [], changed: false };
+  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 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))
+  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;
@@ -1861,14 +2198,16 @@ async function probeCooling(client, opts) {
     s.lastProbe = Date.now();
   }
   const reAdmitted = outcomes.filter((o) => o.ok).map((o) => o.model);
-  const stillLimited = outcomes.filter((o) => !o.ok);
+  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 || stillLimited.some((o) => o.leftSeconds !== o.hadSeconds)
+    changed: reAdmitted.length > 0 || missing.length > 0 || stillLimited.some((o) => o.leftSeconds !== o.hadSeconds)
   };
 }
 
@@ -1877,6 +2216,8 @@ 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) => {
@@ -1921,11 +2262,18 @@ 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 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 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 entry = claimFor(sessionID);
+    if (!entry) {
+      await log("warn", `limit (${reason}) on ${model} for session ${sessionID ?? "?"}, which has no pool claim; nothing aborted`);
+      return;
+    }
+    const { key, claim } = entry;
     const kill = await abortSession(sessionID);
     release(s, key);
     await log(
@@ -2005,20 +2353,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 rotation` : 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 +2398,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 +2489,82 @@ 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
+                  });
+                }
+              }
+            }
+            await failOver(sessionID, provider ?? own?.claim.m ?? "?", named);
+          }
+          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";
+          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 {
+              const 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);
           return;
         }
         if (event.type === "session.created") {
@@ -2144,7 +2598,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           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");
@@ -2155,7 +2609,12 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     "tool.execute.before": async (input, output) => {
       if (input.tool !== "task") return;
       const requested = output.args?.subagent_type;
-      if (typeof requested !== "string") return;
+      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`, {
@@ -2204,12 +2663,13 @@ 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 rotation; 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) };
         }
       }),
@@ -2254,7 +2714,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
             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)`,
+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 no other slot is available and under its ceiling)`,
               ...slots.map(line),
               "",
               "by process:",
@@ -2268,7 +2728,8 @@ 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.",
+              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." : `cooling: ${coolingNow.map(([m, st]) => `${m} for ${Math.ceil((st.until - now) / 1e3)}s`).join(", ")}`
             ].join("\n")
           };
@@ -2278,6 +2739,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 +2750,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 +2902,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 +2942,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 +3043,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 +3060,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 +3089,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 +3118,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
@@ -2810,11 +3273,14 @@ var contextAutoUpdateHooks = (async ({ client, directory }, options) => {
 });
 
 // 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 mkdirSync4, openSync as openSync2, readFileSync as readFileSync6, statSync as statSync4, unlinkSync as unlinkSync4, writeSync as writeSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } 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
@@ -2832,6 +3298,10 @@ var helperArgv = (helper, title, message, urgency, icon, sound) => {
   const name = helper.split(/[\\/]/).pop() ?? "";
   return name === "lacode" || name === "lacode.js" ? ["notify", title, message, urgency, icon, sound] : [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;
@@ -2901,12 +3371,20 @@ var shouldNotify = (input) => {
   if (outcome === "done" && input.awaitingResponse) {
     return { notify: false, reason: "awaiting your response" };
   }
-  return {
+  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"
   };
+  if (outcome === "permission" && input.requestID) {
+    return { ...notification, actionable: { requestID: input.requestID } };
+  }
+  return notification;
 };
 var questionHeadline = (questions) => {
   const first = questions?.find((entry) => typeof entry?.question === "string" && entry.question.trim());
@@ -2981,13 +3459,154 @@ var Notifier = class {
     return this.lastSent.size;
   }
 };
+var notificationStateDir = () => process.env.LACODE_NOTIFY_DIR ?? join6(homedir4(), ".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) => join6(notificationStateDir(), `claim.${safeCorrelationKey(`${sessionID}.${kind}`)}`);
+var claimNotification = (sessionID, kind) => {
+  const path4 = claimFile(sessionID, kind);
+  try {
+    mkdirSync4(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 = readFileSync6(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() - statSync4(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(readFileSync6(lockPath, "utf8").trim(), 10);
+      lockHolder = Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+      lockAge = Date.now() - statSync4(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(readFileSync6(path4, "utf8").trim(), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) return;
+    if (parsed !== process.pid) return;
+    unlinkSync4(path4);
+  } catch {
+  }
+};
 
 // src/plugins/notify.ts
 var SERVICE3 = "notify";
 var COOLDOWN_MS2 = 5e3;
 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 = () => {
@@ -3013,7 +3632,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) => {
@@ -3024,13 +3645,93 @@ 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 replyPermission = async (sessionID, requestID, response) => {
+    const errorStatus = (error) => {
+      const candidate = error;
+      const status2 = candidate?.response?.status ?? candidate?.cause?.status ?? candidate?.status;
+      return typeof status2 === "number" ? status2 : void 0;
+    };
+    const reply = await client.postSessionIdPermissionsPermissionId({
+      path: { id: sessionID, permissionID: requestID },
+      body: { response }
+    }).then((result) => ({ result })).catch((error) => ({ error }));
+    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) {
+      void log("warn", `permission reply failed: ${errorDetail(reply.error) ?? String(reply.error)}`, {
+        sessionID,
+        requestID
+      });
+      return;
+    }
+    if (reply.result.error) {
+      void log("warn", `permission reply failed: ${errorDetail(reply.result.error) ?? String(reply.result.error)}`, {
+        sessionID,
+        requestID
+      });
+      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) => 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})` });
@@ -3045,9 +3746,17 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       resolve3({ ok: false, detail: "no oc-notify helper found" });
       return;
     }
-    const child = spawn(helper, helperArgv(helper, title, message, urgency, "utilities-terminal", sound), {
+    const childEnv = { ...process.env, ...sessionID ? { [NOTIFY_SESSION_ENV]: sessionID } : {} };
+    const actionable = Boolean(requestID);
+    const timeoutMs = actionable ? ACTION_TIMEOUT_MS : helperTimeoutMs;
+    const child = actionable ? spawn2(helper, helperArgv(helper, title, message, urgency, "utilities-terminal", sound), {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+      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;
@@ -3064,11 +3773,15 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
         child.kill("SIGKILL");
       } catch {
       }
-      void log("warn", `notification helper timed out after ${helperTimeoutMs}ms`, { title });
-      finish({ ok: false, detail: `helper timed out after ${helperTimeoutMs}ms` });
-    }, helperTimeoutMs);
+      void log("warn", `notification helper timed out after ${timeoutMs}ms`, { title });
+      finish({ ok: false, detail: `helper timed out after ${timeoutMs}ms` });
+    }, timeoutMs);
     timer.unref?.();
+    let stdout = "";
     let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < 400) stdout += String(chunk);
+    });
     child.stderr?.on("data", (chunk) => {
       if (stderr.length < 400) stderr += String(chunk);
     });
@@ -3085,12 +3798,95 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
           message
         });
       }
-      finish({ ok, detail: noise || void 0 });
+      const action = actionable ? stdout.trim() : "";
+      finish({ ok, detail: noise || void 0, ...action ? { action } : {} });
     });
-    child.unref();
+    if (!actionable) child.unref();
   });
   const deliver = deps.deliver ?? deliverViaHelper;
-  const announce = async (sessionID, outcome, detail) => {
+  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);
       if (!info) {
@@ -3106,7 +3902,8 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
         sawMessage: active.has(sessionID),
         // Either kind of block suppresses the idle event's "finished": a session
         // parked on a permission prompt has not finished, it is waiting.
-        awaitingResponse: pending.has(sessionID) || permissions.has(sessionID)
+        awaitingResponse: pending.has(sessionID) || permissions.has(sessionID),
+        requestID
       });
       if (!decision.notify) {
         void log("debug", `suppressed: ${decision.reason}`, { sessionID });
@@ -3122,10 +3919,29 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
         void log("debug", "suppressed: cooldown", { sessionID });
         return;
       }
+      if (!claimNotification(sessionID, kind)) {
+        void log("debug", "suppressed: another process is raising this", { sessionID, kind });
+        return;
+      }
       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);
-      void log(sent.ok ? "info" : "error", sent.ok ? "notified" : "notification failed", {
+      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);
+      } finally {
+        scheduleClaimRelease(sessionID, kind);
+      }
+      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,
         outcome,
         title: decision.title,
@@ -3140,7 +3956,14 @@ 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);
+          }
+          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") {
@@ -3160,21 +3983,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);
+          const requestID = typeof properties?.id === "string" && properties.id ? properties.id : void 0;
+          const outstanding = permissions.get(sessionID2) ?? /* @__PURE__ */ new Set();
+          const first = outstanding.size === 0;
+          outstanding.add(requestID ?? UNANSWERABLE_REQUEST);
+          rememberPermissions(sessionID2, outstanding);
           rememberActive(sessionID2);
-          void announce(sessionID2, "permission", permissionHeadline(properties) || void 0);
+          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") {
@@ -3198,6 +4034,8 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
             titles.delete(sessionID2);
             pending.delete(sessionID2);
             permissions.delete(sessionID2);
+            forgetLive(sessionID2);
+            forgetPermissionPopup(sessionID2);
           }
           return;
         }
@@ -3693,267 +4531,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 ?? {};
@@ -3980,6 +4557,13 @@ var LaCode = (async (input, options) => {
   if (opts.enabled === false) return inertHooks;
   const log = (level, message, extra) => input.client.app.log({ body: { service: "lacode", level, message, extra } }).catch(() => {
   });
+  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();