@lawaty/lacode 0.11.0 → 1.0.0

package/dist/index.js

@@ -626,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}`;
@@ -802,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
 
@@ -813,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
@@ -826,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
@@ -943,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.
@@ -1272,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
@@ -1578,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.
@@ -1590,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
@@ -1666,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
@@ -1753,11 +1737,11 @@ 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 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.
 
@@ -1780,6 +1764,14 @@ $ARGUMENTS
 - 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) {
@@ -2240,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) };
@@ -2267,20 +2262,90 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     for (const [key, claim] of s.own) if (claim.g === sessionID) return { key, claim };
     return void 0;
   };
-  const failOver = async (sessionID, model, reason) => {
+  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 { 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 reapStuck = async () => {
     if (s.reaping) return;
@@ -2364,7 +2429,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     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.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` : ""}`
+        (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.` : 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");
@@ -2528,7 +2593,12 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
                 }
               }
             }
-            await failOver(sessionID, provider ?? own?.claim.m ?? "?", named);
+            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;
         }
@@ -2546,6 +2616,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           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);
@@ -2553,7 +2624,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
                 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);
+              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`, {
@@ -2564,7 +2635,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
               }
             }
           }
-          await failOver(sessionID, own?.claim.m ?? "?", named);
+          await failOver(sessionID, own?.claim.m ?? "?", named, { stated: stated2, cool: !own });
           return;
         }
         if (event.type === "session.created") {
@@ -2592,23 +2663,25 @@ 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 = 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;
+      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.`
@@ -2617,12 +2690,11 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
       }
       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();
@@ -2635,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,
@@ -2644,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);
@@ -2663,7 +2735,7 @@ 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; 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.",
+        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 validate, as provider/model-id. Omit to probe only the models that are cooling.")
         },
@@ -2674,12 +2746,13 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         }
       }),
       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) => {
@@ -2690,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" : "";
@@ -2713,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 no other slot is available and under its ceiling)`,
+              `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:",
@@ -2730,7 +2803,7 @@ round robin in slot order, each slot taking as many turns as its weight says, so
               // 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` : 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(", ")}`
+              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")
           };
         }
@@ -3158,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 }) => {
@@ -3272,15 +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 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";
+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
@@ -3459,7 +3847,7 @@ var Notifier = class {
     return this.lastSent.size;
   }
 };
-var notificationStateDir = () => process.env.LACODE_NOTIFY_DIR ?? join6(homedir4(), ".local", "share", "opencode", "lacode", "notify");
+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) => {
@@ -3470,11 +3858,11 @@ var isPidAlive2 = (pid) => {
     return error.code === "EPERM";
   }
 };
-var claimFile = (sessionID, kind) => join6(notificationStateDir(), `claim.${safeCorrelationKey(`${sessionID}.${kind}`)}`);
+var claimFile = (sessionID, kind) => join7(notificationStateDir(), `claim.${safeCorrelationKey(`${sessionID}.${kind}`)}`);
 var claimNotification = (sessionID, kind) => {
   const path4 = claimFile(sessionID, kind);
   try {
-    mkdirSync4(notificationStateDir(), { recursive: true });
+    mkdirSync5(notificationStateDir(), { recursive: true });
   } catch {
     return true;
   }
@@ -3498,7 +3886,7 @@ var claimNotification = (sessionID, kind) => {
   const judge = () => {
     let raw;
     try {
-      raw = readFileSync6(path4, "utf8").trim();
+      raw = readFileSync7(path4, "utf8").trim();
     } catch (error) {
       return error.code === "ENOENT" ? "gone" : "unknown";
     }
@@ -3511,7 +3899,7 @@ var claimNotification = (sessionID, kind) => {
     if (holder === process.pid) return "ours";
     let age = Number.POSITIVE_INFINITY;
     try {
-      age = Date.now() - statSync4(path4).mtimeMs;
+      age = Date.now() - statSync5(path4).mtimeMs;
     } catch {
       return "gone";
     }
@@ -3554,9 +3942,9 @@ var claimNotification = (sessionID, kind) => {
     let lockHolder;
     let lockAge = Number.POSITIVE_INFINITY;
     try {
-      const parsed = Number.parseInt(readFileSync6(lockPath, "utf8").trim(), 10);
+      const parsed = Number.parseInt(readFileSync7(lockPath, "utf8").trim(), 10);
       lockHolder = Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
-      lockAge = Date.now() - statSync4(lockPath).mtimeMs;
+      lockAge = Date.now() - statSync5(lockPath).mtimeMs;
     } catch {
       return create();
     }
@@ -3589,13 +3977,48 @@ var claimNotification = (sessionID, kind) => {
 var releaseNotificationClaim = (sessionID, kind) => {
   const path4 = claimFile(sessionID, kind);
   try {
-    const parsed = Number.parseInt(readFileSync6(path4, "utf8").trim(), 10);
+    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";
@@ -3919,9 +4342,16 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
         void log("debug", "suppressed: cooldown", { sessionID });
         return;
       }
-      if (!claimNotification(sessionID, kind)) {
+      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";
@@ -3932,9 +4362,13 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
       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 {
-        scheduleClaimRelease(sessionID, kind);
+        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) : [];
@@ -3958,6 +4392,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
           const { sessionID: sessionID2, status } = event.properties;
           if (status.type === "busy" && sessionID2) {
             rememberActive(sessionID2);
+            releaseCompletion(sessionID2);
           }
           return;
         }
@@ -4036,6 +4471,7 @@ var notifyHooks = (async ({ client, directory }, options, deps = {}) => {
             permissions.delete(sessionID2);
             forgetLive(sessionID2);
             forgetPermissionPopup(sessionID2);
+            releaseCompletion(sessionID2);
           }
           return;
         }
@@ -4486,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();
@@ -4552,11 +4988,17 @@ 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);
@@ -4578,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);
@@ -4612,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();
+      }
     }
   };
 });