@lawaty/lacode 1.3.0-beta.6 → 1.3.0-beta.8

package/CHANGELOG.md

@@ -7,6 +7,43 @@ All notable changes to LaCode are recorded here. The format follows
 Versions come from git release commits; the npm version is bumped in the same
 commit as the changelog entry it describes.
 
+## [Unreleased]
+
+## [1.3.0-beta.8] — a blocked child is never silent
+
+### Added
+
+- **Provider compatibility: object-shaped reasoning no longer crashes a spawn.** OpenAI-compatible gateways that stream `choices[].delta.reasoning` as an object (`{ encrypted_content, content, summary }`) are normalized to the string opencode's chunk schema expects, so the spawn survives the first reasoning chunk instead of dying with `invalid_union`.
+- **Pool: the rate-limit-reset notice is on by default only for `opencode` and `opencode-go` slots.** Every other provider stays quiet unless its slot sets `notify:on` on the `pool.txt` line (or `"notify": true` in `pool.json`); `notify:off` silences an `opencode`/`opencode-go` slot, and a model listed on several lines is announced if any of its slots is on (US-34).
+
+### Changed
+
+- **Build agent prompt: delegation is now the default.** The root agent's prompt carries the delegate-first gate and hard rules requiring a `task` spawn before repository inspection or edits, with bash reserved for applying and verifying a subagent's result.
+- **`score-models`: probe `opencode`/`opencode-go` through a local `opencode serve --pure` session** instead of direct HTTP, and restrict candidates to concrete text chat/completion models (media generators, safety classifiers and OpenRouter meta-routers are skipped).
+- **Cancelled tasks now surface their reason via a toast** when the task card cannot be rewritten (no `part` sub-client or an unauthenticated PATCH), so the user still sees why the slot was aborted.
+- **Publishing now syncs the config tree too.** `postpublish` runs `scripts/sync-hosts.mjs` and then the repo's `bin/oc-sync`, so a release deploys both the registry package and the working config without a second manual step.
+
+### Fixed
+
+- **A subagent blocked on a permission or question now notifies.** Every subagent outcome used to be suppressed, so a permission prompt in another project could be completely silent; `done` and `error` remain suppressed (US-12, US-25).
+
+### Documented
+
+- **README / CONFIGURATION:** per-slot `notify` semantics and provider-based defaults (US-34).
+- **USER-STORIES:** US-34 added; US-12 and US-25 now record that a blocked subagent still notifies.
+
+## [1.3.0-beta.7] — only a rate-limit reset speaks
+
+### Changed
+
+- **The slot notice is now a rate-limit reset notice, not a generic "slot
+  ready".** It fires only when a slot that was cooling for a quota/rate-limit
+  reason becomes usable again — either because its window lapsed or a probe
+  found it answering. Outages, auth failures, missing models and other
+  non-quota cooldowns no longer raise it, which is what made it frequent. The
+  title is `LaCode: rate limit reset` and the message says the rate limit has
+  reset.
+
 ## [1.3.0-beta.6] — a recovered slot says it is ready
 
 ### Added
@@ -1060,7 +1097,8 @@ experimental; `latest` remains 0.4.2.
 
 - First published release: pooled subagents over a shared set of models.
 
-[Unreleased]: https://github.com/lawaty/lacode/compare/v1.2.0...HEAD
+[Unreleased]: https://github.com/lawaty/lacode/compare/v1.3.0-beta.8...HEAD
+[1.3.0-beta.8]: https://github.com/lawaty/lacode/releases/tag/v1.3.0-beta.8
 [1.3.0-beta.0]: https://github.com/lawaty/lacode/releases/tag/v1.3.0-beta.0
 [1.2.0]: https://github.com/lawaty/lacode/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/lawaty/lacode/compare/v1.0.0...v1.1.0

package/README.md

@@ -76,6 +76,10 @@ opencode agent list | grep -E '^(explore|implement|context)'
 You should see `explore`, `implement` and `context`, each with hidden `-1`..`-4`
 pool variants alongside. That is the whole install, and you are done.
 
+Each pool slot controls the rate-limit-reset desktop notice: it is on by
+default for `opencode` and `opencode-go` slots, and other providers need
+`notify:on` in `pool.txt` or `"notify": true` in `pool.json` to opt in.
+
 **If that prints nothing, the plugin did not load** — and opencode will not tell
 you: it starts normally, logs nothing, and the agents are simply absent. A
 plugin that fails to load is silent by design of the host, so this check is the

package/dist/agents.js

@@ -441,6 +441,48 @@ or search the web. Those tools are denied by configuration, not by convention.
 Every question of the form "what does this file do", "where is X handled", or
 "what does this error come from" belongs to an explorer, not to you.
 
+# Delegate first \u2014 this is the default
+
+Delegation is the default action, not an optimisation you reach for once a task
+looks big. Before you call ANY tool on a turn that touches the repository,
+apply this gate:
+
+1. **Finding something out?** (read a file, grep, glob, list, inspect git
+   history, understand a call site, trace an error) \u2192 spawn \`@explore\`.
+2. **Changing code?** \u2192 spawn \`@implement\` with one decided unit.
+3. **Applying a patch or output a subagent returned, or verifying it?** (run
+   tests, typecheck, lint, build, git) \u2192 you may use \`edit\`/\`write\`/\`bash\`.
+
+Only case 3 is yours. Cases 1 and 2 are delegations, and on a normal task the
+very first action of the turn is a \`task\` spawn. A turn that inspects or
+changes repository code without spawning first is a mistake, not a shortcut.
+
+If you notice you have already inspected or edited directly: stop, say so, and
+hand the remaining work to the right base. Do not keep going because the direct
+call already happened, and do not "finish quickly" what should have been
+delegated.
+
+The direct call is tempting because it saves one round trip. It is also the
+failure mode: it fills your context with source the user pays for again on every
+later turn. A delegated read returns a conclusion; a direct read returns a
+transcript.
+
+# Hard rules
+
+- The first repository action on a task is a \`task\` spawn \u2014 not \`read\`, \`grep\`,
+  \`glob\`, \`list\`, \`bash\`, \`edit\` or \`write\`.
+- Never use bash to look. \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, \`grep\`, \`rg\`,
+  \`find\`, \`ls\`, \`tree\`, \`wc\` and friends are exploration, and exploration
+  belongs to \`@explore\`. Running them yourself is the exact behaviour this role
+  exists to prevent.
+- Never make a code change yourself when \`@implement\` can make it. "It is only
+  one line" is not an exception; one line is the ideal size for a small ask.
+- Every direct inspection or edit must be either a returned result you are
+  applying or verifying, or it must be named and justified in your next
+  message. An unexplained one is a violation of this rule.
+- Subagents are not bound by this rule. \`@explore\`, \`@implement\` and \`@context\`
+  do the reading, grepping and mechanical edits.
+
 # Delegation
 
 - **Investigation \u2192 @explore.** Give it specific, focused instructions
@@ -470,17 +512,16 @@ to do the work yourself, and not a reason to stop and ask.
 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
 means retry. **Persistent or structural** \u2014 every slot cooling, the same spawn
 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. Do not escalate to \`expert\` as
-a workaround; it is opt-in by the user.
+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. 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
@@ -514,7 +555,8 @@ project. A cheap agent handed it will improvise a design, skip the verification
 you never spelled out, and return something you cannot trust.
 
 When the work does not divide into small asks it is not implementation work
-yet \u2014 send it to \`@plan\`, or keep it yourself.
+yet \u2014 use \`@explore\` to break it into a sequence of small asks, or ask the user
+to run \`@plan\`. Do not do the large work yourself.
 
 Split into one ask per task, spawn independent asks together in a single
 message so they run in parallel, and sequence only what truly depends on what.
@@ -531,6 +573,9 @@ Do NOT use bash to inspect the codebase. \`cat\`, \`head\`, \`tail\`, \`sed\`, \
 \`grep\`, \`find\`, \`ls\`, \`tree\` and friends are exploration, and exploration goes
 to @explore. Bash is for executing and verifying, not for looking.
 
+If a bash command does not run a test, typecheck, linter, build, or git
+operation, assume it is exploration and delegate it.
+
 # Repository context
 
 Before delegating a non-trivial task, tell @explore to check
@@ -553,7 +598,8 @@ report instead of editing it yourself.
 
 When you report back, say which explorer answered which question and name the
 context file(s) that actually shaped the work (or state plainly that the map was
-missing). Never paste context file contents into the report.`,
+missing). Never paste context file contents into the report.
+`,
     permission: {
       "read": "deny",
       "glob": "deny",

package/dist/index.js

@@ -39,6 +39,17 @@ var UNAVAILABLE_REASON = "endpoint-unavailable";
 var MAX_WEIGHT = 100;
 var slotCeiling = (slot) => slot.weight;
 var slotBucket = (slot) => slot.bucket ?? slot.model;
+var NOTIFY_DEFAULT_ON_PROVIDERS = /* @__PURE__ */ new Set(["opencode", "opencode-go"]);
+var notifyDefault = (model) => {
+  const slash = model.indexOf("/");
+  const provider = slash < 0 ? model : model.slice(0, slash);
+  return NOTIFY_DEFAULT_ON_PROVIDERS.has(provider);
+};
+var slotNotify = (slot) => typeof slot.notify === "boolean" ? slot.notify : notifyDefault(slot.model);
+var announcesReset = (slots, model) => {
+  const matching = slots.filter((slot) => slot.model === model);
+  return matching.length > 0 ? matching.some((slot) => slotNotify(slot)) : notifyDefault(model);
+};
 var SLOTS_WARN_AT = 64;
 var COOLDOWN_BASE_MS = 60 * 1e3;
 var COOLDOWN_MAX_MS = 15 * 60 * 1e3;
@@ -67,6 +78,19 @@ var FALLBACK_SLOTS = [
   { index: 3, model: "opencode/deepseek-v4.1-flash-free", weight: 1 },
   { index: 4, model: "opencode/glm-5.3-flash-free", weight: 1 }
 ];
+var coerceNotify = (raw, at, model, problems) => {
+  if (raw === void 0) return notifyDefault(model);
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "string") {
+    const s = raw.trim().toLowerCase();
+    if (s === "true" || s === "1" || s === "on" || s === "yes") return true;
+    if (s === "false" || s === "0" || s === "off" || s === "no") return false;
+    problems.push(`${at} (${model}): notify must be a boolean or one of on/off, got ${JSON.stringify(raw)}; keeping the provider default`);
+    return notifyDefault(model);
+  }
+  problems.push(`${at} (${model}): notify must be a boolean or one of on/off, got ${JSON.stringify(raw)}; keeping the provider default`);
+  return notifyDefault(model);
+};
 function parseSlots(parsed, origin) {
   const problems = [];
   const entries = parsed?.slots;
@@ -84,7 +108,8 @@ function parseSlots(parsed, origin) {
     if (rawBucket !== void 0 && !bucket) {
       problems.push(`${at} (${model}): bucket must be a non-empty name; using the model id`);
     }
-    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {} });
+    const notify = coerceNotify(entry.notify, at, model, problems);
+    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify });
   });
   if (slots.length > SLOTS_WARN_AT) {
     problems.push(`${origin}: ${slots.length} slots is unusually large, but every entry is kept (the pool has no slot cap)`);
@@ -103,14 +128,19 @@ function parseTextSlots(text, origin) {
     const [model, ...rest] = line.split(/\s+/);
     let weight;
     let bucket;
+    let notify;
     for (const token of rest) {
+      if (token.startsWith("notify:")) {
+        if (notify === void 0) notify = token.slice("notify:".length);
+        continue;
+      }
       if (token.startsWith("b:")) {
         if (bucket === void 0) bucket = token.slice(2);
       } else if (weight === void 0) {
         weight = token;
       }
     }
-    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket } });
+    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify } });
   }
   return parseSlots({ slots: entries }, origin);
 }
@@ -319,7 +349,7 @@ function ensureSlots(s, onWarn) {
   for (const problem of problems) onWarn(problem);
   return slots;
 }
-var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.bucket ?? ""}`).join("|")}`;
+var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.bucket ?? ""}:${slotNotify(slot) ? "1" : "0"}`).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);
@@ -1238,6 +1268,48 @@ or search the web. Those tools are denied by configuration, not by convention.
 Every question of the form "what does this file do", "where is X handled", or
 "what does this error come from" belongs to an explorer, not to you.
 
+# Delegate first \u2014 this is the default
+
+Delegation is the default action, not an optimisation you reach for once a task
+looks big. Before you call ANY tool on a turn that touches the repository,
+apply this gate:
+
+1. **Finding something out?** (read a file, grep, glob, list, inspect git
+   history, understand a call site, trace an error) \u2192 spawn \`@explore\`.
+2. **Changing code?** \u2192 spawn \`@implement\` with one decided unit.
+3. **Applying a patch or output a subagent returned, or verifying it?** (run
+   tests, typecheck, lint, build, git) \u2192 you may use \`edit\`/\`write\`/\`bash\`.
+
+Only case 3 is yours. Cases 1 and 2 are delegations, and on a normal task the
+very first action of the turn is a \`task\` spawn. A turn that inspects or
+changes repository code without spawning first is a mistake, not a shortcut.
+
+If you notice you have already inspected or edited directly: stop, say so, and
+hand the remaining work to the right base. Do not keep going because the direct
+call already happened, and do not "finish quickly" what should have been
+delegated.
+
+The direct call is tempting because it saves one round trip. It is also the
+failure mode: it fills your context with source the user pays for again on every
+later turn. A delegated read returns a conclusion; a direct read returns a
+transcript.
+
+# Hard rules
+
+- The first repository action on a task is a \`task\` spawn \u2014 not \`read\`, \`grep\`,
+  \`glob\`, \`list\`, \`bash\`, \`edit\` or \`write\`.
+- Never use bash to look. \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, \`grep\`, \`rg\`,
+  \`find\`, \`ls\`, \`tree\`, \`wc\` and friends are exploration, and exploration
+  belongs to \`@explore\`. Running them yourself is the exact behaviour this role
+  exists to prevent.
+- Never make a code change yourself when \`@implement\` can make it. "It is only
+  one line" is not an exception; one line is the ideal size for a small ask.
+- Every direct inspection or edit must be either a returned result you are
+  applying or verifying, or it must be named and justified in your next
+  message. An unexplained one is a violation of this rule.
+- Subagents are not bound by this rule. \`@explore\`, \`@implement\` and \`@context\`
+  do the reading, grepping and mechanical edits.
+
 # Delegation
 
 - **Investigation \u2192 @explore.** Give it specific, focused instructions
@@ -1267,17 +1339,16 @@ to do the work yourself, and not a reason to stop and ask.
 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
 means retry. **Persistent or structural** \u2014 every slot cooling, the same spawn
 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. Do not escalate to \`expert\` as
-a workaround; it is opt-in by the user.
+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. 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
@@ -1311,7 +1382,8 @@ project. A cheap agent handed it will improvise a design, skip the verification
 you never spelled out, and return something you cannot trust.
 
 When the work does not divide into small asks it is not implementation work
-yet \u2014 send it to \`@plan\`, or keep it yourself.
+yet \u2014 use \`@explore\` to break it into a sequence of small asks, or ask the user
+to run \`@plan\`. Do not do the large work yourself.
 
 Split into one ask per task, spawn independent asks together in a single
 message so they run in parallel, and sequence only what truly depends on what.
@@ -1328,6 +1400,9 @@ Do NOT use bash to inspect the codebase. \`cat\`, \`head\`, \`tail\`, \`sed\`, \
 \`grep\`, \`find\`, \`ls\`, \`tree\` and friends are exploration, and exploration goes
 to @explore. Bash is for executing and verifying, not for looking.
 
+If a bash command does not run a test, typecheck, linter, build, or git
+operation, assume it is exploration and delegate it.
+
 # Repository context
 
 Before delegating a non-trivial task, tell @explore to check
@@ -1350,7 +1425,8 @@ report instead of editing it yourself.
 
 When you report back, say which explorer answered which question and name the
 context file(s) that actually shaped the work (or state plainly that the map was
-missing). Never paste context file contents into the report.`,
+missing). Never paste context file contents into the report.
+`,
     permission: {
       "read": "deny",
       "glob": "deny",
@@ -2568,7 +2644,9 @@ var safeTitle = (raw, fallback = "session") => {
 var shouldNotify = (input) => {
   const { info, outcome, detail } = input;
   if (!info?.id) return { notify: false, reason: "no session info" };
-  if (info.parentID) return { notify: false, reason: "subagent" };
+  if (info.parentID && outcome !== "permission" && outcome !== "question") {
+    return { notify: false, reason: "subagent" };
+  }
   const sessionTitle = safeTitle(info.title);
   if (INTERNAL_TITLE_PREFIXES.some((prefix) => sessionTitle.startsWith(prefix))) {
     return { notify: false, reason: "internal session" };
@@ -3033,6 +3111,18 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
   const pendingCancelledParts = /* @__PURE__ */ new Map();
   const patchedCancelledParts = /* @__PURE__ */ new Set();
   const cancelledPrefix = "Task Cancelled by LaCode:";
+  const showAbortToast = async (report) => {
+    const toast2 = client.tui?.showToast;
+    if (typeof toast2 !== "function") return;
+    try {
+      const args = {
+        body: { message: `${cancelledPrefix} ${report.message}`, variant: "warning", duration: 8e3 }
+      };
+      if (directory) args.query = { directory };
+      await toast2(args);
+    } catch {
+    }
+  };
   const patchCancelledPart = async (part, key, report) => {
     if (patchedCancelledParts.has(key)) return;
     patchedCancelledParts.add(key);
@@ -3082,6 +3172,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         session: part.sessionID,
         callID: part.callID
       });
+      await showAbortToast(report);
     }
   };
   const noteAbort = async (key, report) => {
@@ -3300,16 +3391,17 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     if (authBenched > 0) parts.push(`benched ${authBenched} auth-failed`);
     return parts.join(", ");
   };
-  const readyMessage = (models) => models.length === 1 ? `${models[0]} is back in the pool \u2014 ready for use.` : `${models.length} slots are back in the pool \u2014 ready for use: ${models.join(", ")}.`;
+  const resetMessage = (models) => models.length === 1 ? `${models[0]} is available again \u2014 the rate limit has reset.` : `${models.length} slots are available again \u2014 their rate limits have reset: ${models.join(", ")}.`;
   const announceReady = (models) => {
-    const fresh = models.filter((model) => claimDesktopNotice(model));
+    const wanted = models.filter((model) => announcesReset(s.slots, model));
+    const fresh = wanted.filter((model) => claimDesktopNotice(model));
     if (fresh.length === 0) return;
     try {
-      notify("LaCode: slot ready", readyMessage(fresh));
+      notify("LaCode: rate limit reset", resetMessage(fresh));
     } catch {
     }
   };
-  const announce = async (report) => {
+  const announce = async (report, prior) => {
     if (!report.changed) return;
     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 });
@@ -3319,9 +3411,15 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
       });
     } catch {
     }
-    if (report.cleared.length > 0) announceReady(report.cleared);
+    const resets = report.cleared.filter((model) => isQuotaReason(prior.get(model)?.reason ?? ""));
+    if (resets.length > 0) announceReady(resets);
   };
   const runProbe = async (models) => {
+    let prior = /* @__PURE__ */ new Map();
+    try {
+      prior = readLimits(s);
+    } catch {
+    }
     let report = EMPTY_REPORT;
     try {
       report = await probeCooling(client, { state: s, directory, models });
@@ -3329,7 +3427,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
       await log("error", `pool probe failed: ${String(error)}`);
       return EMPTY_REPORT;
     }
-    await announce(report);
+    await announce(report, prior);
     return report;
   };
   const probeMs = opts.probeMs ?? PROBE_INTERVAL_MS;
@@ -3358,13 +3456,13 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     const back = [];
     for (const [model, reason] of coolingSeen) {
       if (still.has(model)) continue;
-      if (reason === AUTH_FAILURE_REASON || reason === MODEL_MISSING_REASON) continue;
+      if (!isQuotaReason(reason)) continue;
       if (!providerReady(s, model)) continue;
       back.push(model);
     }
     coolingSeen = still;
     if (back.length > 0) {
-      void log("info", `pool: ${readyMessage(back)}`, { cleared: back });
+      void log("info", `pool: ${resetMessage(back)}`, { cleared: back });
       announceReady(back);
     }
   }, expiryMs) : void 0;
@@ -3436,6 +3534,11 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
     );
   };
   const runValidation = async (models) => {
+    let prior = /* @__PURE__ */ new Map();
+    try {
+      prior = readLimits(s);
+    } catch {
+    }
     let report = EMPTY_REPORT;
     try {
       report = await probeModels(client, { state: s, directory, models });
@@ -3443,7 +3546,7 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
       await log("error", `pool validation failed: ${String(error)}`);
       return EMPTY_REPORT;
     }
-    await announce(report);
+    await announce(report, prior);
     return report;
   };
   const watchMs = opts.watchMs ?? SLOT_WATCH_MS;
@@ -6416,6 +6519,147 @@ var omniRouteHooks = async (input, options, deps = {}) => {
   };
 };
 
+// src/lib/provider-compat.ts
+var WRAPPED = /* @__PURE__ */ Symbol.for("lacode.providerCompat");
+var REASONING_FIELDS = ["reasoning", "reasoning_content"];
+var asText = (value) => typeof value === "string" ? value : "";
+var itemText = (item) => {
+  if (typeof item === "string") return item;
+  if (item && typeof item === "object") return asText(item.text);
+  return "";
+};
+function reasoningText(value) {
+  if (typeof value === "string") return value;
+  if (!value || typeof value !== "object") return "";
+  const source = value;
+  const direct = asText(source.text);
+  if (direct) return direct;
+  const summary = source.summary;
+  if (typeof summary === "string") return summary;
+  if (Array.isArray(summary)) return summary.map(itemText).join("");
+  if (summary && typeof summary === "object") return asText(summary.text);
+  const content = source.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map(itemText).join("");
+  return "";
+}
+function normalizeChunk(value) {
+  if (!value || typeof value !== "object") return false;
+  const choices = value.choices;
+  if (!Array.isArray(choices)) return false;
+  let changed = false;
+  for (const choice of choices) {
+    if (!choice || typeof choice !== "object") continue;
+    for (const key of ["delta", "message"]) {
+      const holder = choice[key];
+      if (!holder || typeof holder !== "object") continue;
+      for (const field of REASONING_FIELDS) {
+        const current = holder[field];
+        if (current === null || typeof current !== "object") continue;
+        holder[field] = reasoningText(current);
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+function normalizeSseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("data:")) return line;
+  const payload = trimmed.slice("data:".length).trim();
+  if (!payload || payload === "[DONE]") return line;
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    return line;
+  }
+  if (!normalizeChunk(parsed)) return line;
+  const newline = line.endsWith("\n") ? "\n" : "";
+  return `data: ${JSON.stringify(parsed)}${newline}`;
+}
+function createChunkNormalizer() {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffered = "";
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffered += decoder.decode(chunk, { stream: true });
+      let newline = buffered.indexOf("\n");
+      while (newline !== -1) {
+        const line = buffered.slice(0, newline + 1);
+        buffered = buffered.slice(newline + 1);
+        controller.enqueue(encoder.encode(normalizeSseLine(line)));
+        newline = buffered.indexOf("\n");
+      }
+    },
+    flush(controller) {
+      buffered += decoder.decode();
+      if (buffered) controller.enqueue(encoder.encode(normalizeSseLine(buffered)));
+    }
+  });
+}
+function wrapFetch(original) {
+  const wrapped = async (input, init2) => {
+    const response = await original(input, init2);
+    try {
+      const contentType = response.headers.get("content-type") ?? "";
+      if (!contentType.includes("text/event-stream") || !response.body) return response;
+      const headers = new Headers(response.headers);
+      headers.delete("content-length");
+      headers.delete("content-encoding");
+      headers.delete("transfer-encoding");
+      return new Response(response.body.pipeThrough(createChunkNormalizer()), {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    } catch {
+      return response;
+    }
+  };
+  wrapped[WRAPPED] = true;
+  return wrapped;
+}
+function installProviderCompat() {
+  const target = globalThis.fetch;
+  if (typeof target !== "function") return () => {
+  };
+  if (target[WRAPPED]) return () => {
+  };
+  const wrapped = wrapFetch(target);
+  globalThis.fetch = wrapped;
+  return () => {
+    if (globalThis.fetch === wrapped) {
+      ;
+      globalThis.fetch = target;
+    }
+  };
+}
+
+// src/plugins/provider-compat.ts
+var SERVICE5 = "provider-compat";
+var providerCompatHooks = async (input) => {
+  const log = (level, message) => input.client.app.log({ body: { service: SERVICE5, level, message } }).catch(() => {
+  });
+  let restore = () => {
+  };
+  try {
+    restore = installProviderCompat();
+    await log("debug", "normalizing object-shaped reasoning in provider streams");
+  } catch (error) {
+    await log("warn", `provider compat unavailable: ${String(error)}`);
+  }
+  return {
+    dispose: async () => {
+      try {
+        restore();
+      } catch {
+      }
+    }
+  };
+};
+
 // src/plugins/selfupdate.ts
 async function selfUpdateHooks(input, options) {
   const opts = options ?? {};
@@ -6808,9 +7052,9 @@ function timelineHooks(input, options) {
   const opts = options ?? {};
   const config = typeof opts.timeline === "object" && opts.timeline !== null ? opts.timeline : void 0;
   const disabled = opts.timeline === false || config?.enabled === false || process.env.LACODE_TIMELINE === "0";
-  const SERVICE5 = "timeline";
+  const SERVICE6 = "timeline";
   const poolState = state(options);
-  const log = (level, message, extra) => client.app.log({ body: { service: SERVICE5, level, message, extra } }).catch(() => {
+  const log = (level, message, extra) => client.app.log({ body: { service: SERVICE6, level, message, extra } }).catch(() => {
   });
   const debug = (...args) => {
     if (process.env.LACODE_TIMELINE_DEBUG === "1") console.error("[timeline]", ...args);
@@ -7235,6 +7479,7 @@ var LaCode = (async (input, options) => {
   const selfupdate = await settled("self-update", () => selfUpdateHooks(input, options)) ?? inertHooks;
   const feedback = await settled("feedback", () => feedbackHooks(input, options)) ?? inertHooks;
   const omniroute = await settled("omniroute", () => omniRouteHooks(input, options)) ?? inertHooks;
+  const compat = await settled("provider-compat", () => providerCompatHooks(input)) ?? inertHooks;
   const imagepaste = await settled("image-paste", () => imagePasteHooks(input, opts.imagePaste)) ?? inertHooks;
   const timeline = await settled("timeline", () => timelineHooks(input, options)) ?? inertHooks;
   const config = async (cfg) => {
@@ -7281,6 +7526,7 @@ var LaCode = (async (input, options) => {
       await selfupdate.dispose?.();
       await feedback.dispose?.();
       await omniroute.dispose?.();
+      await compat.dispose?.();
       await imagepaste.dispose?.();
       await timeline.dispose?.();
     },

package/dist/pool.js

@@ -39,6 +39,17 @@ var UNAVAILABLE_REASON = "endpoint-unavailable";
 var MAX_WEIGHT = 100;
 var slotCeiling = (slot) => slot.weight;
 var slotBucket = (slot) => slot.bucket ?? slot.model;
+var NOTIFY_DEFAULT_ON_PROVIDERS = /* @__PURE__ */ new Set(["opencode", "opencode-go"]);
+var notifyDefault = (model) => {
+  const slash = model.indexOf("/");
+  const provider = slash < 0 ? model : model.slice(0, slash);
+  return NOTIFY_DEFAULT_ON_PROVIDERS.has(provider);
+};
+var slotNotify = (slot) => typeof slot.notify === "boolean" ? slot.notify : notifyDefault(slot.model);
+var announcesReset = (slots, model) => {
+  const matching = slots.filter((slot) => slot.model === model);
+  return matching.length > 0 ? matching.some((slot) => slotNotify(slot)) : notifyDefault(model);
+};
 var SLOTS_WARN_AT = 64;
 var COOLDOWN_BASE_MS = 60 * 1e3;
 var COOLDOWN_MAX_MS = 15 * 60 * 1e3;
@@ -67,6 +78,19 @@ var FALLBACK_SLOTS = [
   { index: 3, model: "opencode/deepseek-v4.1-flash-free", weight: 1 },
   { index: 4, model: "opencode/glm-5.3-flash-free", weight: 1 }
 ];
+var coerceNotify = (raw, at, model, problems) => {
+  if (raw === void 0) return notifyDefault(model);
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "string") {
+    const s = raw.trim().toLowerCase();
+    if (s === "true" || s === "1" || s === "on" || s === "yes") return true;
+    if (s === "false" || s === "0" || s === "off" || s === "no") return false;
+    problems.push(`${at} (${model}): notify must be a boolean or one of on/off, got ${JSON.stringify(raw)}; keeping the provider default`);
+    return notifyDefault(model);
+  }
+  problems.push(`${at} (${model}): notify must be a boolean or one of on/off, got ${JSON.stringify(raw)}; keeping the provider default`);
+  return notifyDefault(model);
+};
 function parseSlots(parsed, origin) {
   const problems = [];
   const entries = parsed?.slots;
@@ -84,7 +108,8 @@ function parseSlots(parsed, origin) {
     if (rawBucket !== void 0 && !bucket) {
       problems.push(`${at} (${model}): bucket must be a non-empty name; using the model id`);
     }
-    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {} });
+    const notify = coerceNotify(entry.notify, at, model, problems);
+    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify });
   });
   if (slots.length > SLOTS_WARN_AT) {
     problems.push(`${origin}: ${slots.length} slots is unusually large, but every entry is kept (the pool has no slot cap)`);
@@ -103,14 +128,19 @@ function parseTextSlots(text, origin) {
     const [model, ...rest] = line.split(/\s+/);
     let weight;
     let bucket;
+    let notify;
     for (const token of rest) {
+      if (token.startsWith("notify:")) {
+        if (notify === void 0) notify = token.slice("notify:".length);
+        continue;
+      }
       if (token.startsWith("b:")) {
         if (bucket === void 0) bucket = token.slice(2);
       } else if (weight === void 0) {
         weight = token;
       }
     }
-    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket } });
+    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify } });
   }
   return parseSlots({ slots: entries }, origin);
 }
@@ -319,7 +349,7 @@ function ensureSlots(s, onWarn) {
   for (const problem of problems) onWarn(problem);
   return slots;
 }
-var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.bucket ?? ""}`).join("|")}`;
+var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.bucket ?? ""}:${slotNotify(slot) ? "1" : "0"}`).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);
@@ -885,6 +915,7 @@ export {
   USER_MODELS_TXT,
   acquire,
   agentFor,
+  announcesReset,
   backfillChild,
   bindChild,
   claimKey,
@@ -909,6 +940,7 @@ export {
   manualVariant,
   markProbe,
   noteActivity,
+  notifyDefault,
   parseSlotText,
   parseSlots,
   parseTextSlots,

package/docs/CONFIGURATION.md

@@ -7,7 +7,7 @@ The plugin options, where the model pool gets its slots, and exactly what LaCode
 The slot list is the first of these that yields usable slots:
 
 1. plugin options — `models` in the [tuple](../README.md#configure)
-2. `~/.config/lacode/pool.txt` — flat `model [weight]` per line, preferred
+2. `~/.config/lacode/pool.txt` — flat `model [weight] [b:<bucket>] [notify:on|off]` per line, preferred
 3. `~/.config/lacode/pool.json` (its parent directory is created for you)
 4. the bundled `presets/free-tier.json`
 5. a built-in fallback, so routing always works
@@ -33,6 +33,21 @@ A slot may also declare a shared quota bucket with `b:<name>` on the line (or a
 the sibling would spend the same exhausted window; without one, the model is its
 own bucket. `pool_status` shows each shared bucket's effective capacity.
 
+Each slot gets a `notify` flag that controls the desktop "rate-limit reset"
+notice raised when a slot that was cooling for a quota/rate-limit reason becomes
+usable again. The default is **provider-based**: on for `opencode` and
+`opencode-go` slots, off for every other provider. On a `pool.txt` line, set
+`notify:on` to opt a quiet provider's slot into the notice, or `notify:off` to
+silence an `opencode`/`opencode-go` slot; `notify:on`/`notify:off` are accepted
+explicitly. In `pool.json`, set `"notify": true` or `"notify": false`
+(booleans; `on/off/1/0/yes/no` strings are also accepted). If the same model
+appears on several lines, it is announced if **any** of its slots has `notify`
+on — to fully silence a model, set `notify:off` on all of its lines. An
+invalid `notify` value falls back to the provider default and produces a
+warning. The flag gates only the desktop reset notice, not pool routing or
+status, and pool files are hot-reloaded so changes take effect without a
+restart.
+
 
 ## Which models run which agent
 

package/docs/USER-STORIES.md

@@ -222,6 +222,7 @@ A limit does not always arrive as an error. Sometimes the provider accepts the r
 **Story ID(s) for tests:** US-12
 **Acceptance criteria:**
 - [ ] Given a question is asked, When the event fires, Then a `question` notification is delivered that includes the question's text.
+- [ ] Given a subagent session asks a question, When the question fires, Then the notification is still delivered, because the parent cannot proceed until the user answers and a blocked child is not background noise.
 - [ ] Given a session has a parked question, When the idle event that follows fires, Then no duplicate "finished" notification is sent.
 - [ ] Given a parked question is replied to, rejected, or the session errors, When that event fires, Then the pending entry is cleared and the next real completion notifies again.
 - [ ] Given a question and a completion occur inside the same cooldown window, When both are evaluated, Then they are not deduplicated against each other.
@@ -232,6 +233,7 @@ A limit does not always arrive as an error. Sometimes the provider accepts the r
 **Story ID(s) for tests:** US-25
 **Acceptance criteria:**
 - [ ] Given a permission is requested, When the `permission.asked` event fires, Then exactly one notification is delivered naming the permission type and the path or pattern being requested.
+- [ ] Given a subagent session asks for permission, When the prompt fires, Then the notification is still delivered, because the parent cannot proceed until the user answers and a suppressed subagent prompt is the silent stall this story removes.
 - [ ] Given opencode asks to reach a directory outside the worktree, When the prompt fires, Then the notification names that directory, resolved from `metadata.parentDir`/`metadata.filepath` and with the trailing glob trimmed, because a glob is not something the user can judge.
 - [ ] Given the permission is granted, denied, or dismissed, When `permission.replied` fires, Then no notification is sent — the prompt was the thing worth interrupting for, not the answer — and only the parked-session block is cleared.
 - [ ] Given a session is parked on a permission prompt, When the idle event fires, Then no "finished" notification is sent, because nothing finished.
@@ -272,6 +274,21 @@ The popup belongs to its session: working in one chat closes that chat's popup a
 - [ ] Given a permission popup is closed this way, When the permission was already answered in the terminal, Then nothing is answered twice: the close takes the popup down and answers nothing.
 - [ ] Given the notification was delivered by a session on a remote host and reached the desktop over the tunnel, When the user works in that chat, Then the popup on the desktop closes too, because the popup lives on the desktop and only the desktop knows its notification id.
 
+### US-34: A recovered slot announces itself once, and each slot can stay quiet
+**As a** user running a pool whose slots are rate-limited at different times, **I want** a slot that becomes usable again to raise one notice — and to be able to silence that notice for individual slots, **so that** I hear about capacity coming back without being told about slots I do not care about.
+
+A cooldown that was a rate limit is the one kind of recovery worth announcing: when its window lapses or a probe finds the model answering, the capacity is genuinely back. An outage, an auth failure or a missing model is not fixed by waiting, and announcing those would be noise. Several opencode processes share one pool, so the notice is claimed per model and spoken once. The notice follows the provider: `opencode` and `opencode-go` slots announce by default, every other provider is quiet, and any slot can override either way with `notify:on`/`notify:off` (or `"notify": true`/`"notify": false`). The notice names a model, so a model declared on several lines is announced if any of its lines allows it.
+
+**Story ID(s) for tests:** US-34
+**Acceptance criteria:**
+- [ ] Given a slot was cooling for a quota/rate-limit reason, When its window lapses or a probe finds it answering, Then one desktop notice with the title `LaCode: rate limit reset` names the recovered model.
+- [ ] Given a slot was cooling for an auth failure, a missing model or a short outage, When that cooldown ends, Then no reset notice is raised, because waiting does not fix those and the alert would be noise.
+- [ ] Given the same pool is shared by several opencode processes, When a slot recovers, Then exactly one process speaks, and the others stay silent.
+- [ ] Given a slot's line sets `notify:off` (or its JSON entry sets `"notify": false`), When that slot recovers, Then no reset notice is raised for it and no cross-process claim is consumed, while other enabled slots still announce.
+- [ ] Given a model appears on several lines, When it recovers, Then it is announced if any of its lines has `notify` on, and is silent only when every line opts out.
+- [ ] Given a slot sets no notify, When it recovers, Then the notice is raised for an opencode or opencode-go slot and not raised for any other provider, because those providers stay quiet unless asked.
+- [ ] Given `notify` is changed in a watched pool file, When the file is saved, Then the new setting applies without a restart.
+
 ---
 
 ## Epic E — Remote hosts over SSH
@@ -523,6 +540,7 @@ table was filled in.
 | US-25 | D | `tests/stories/d-notifications.test.mjs` |
 | US-29 | D | `tests/stories/d-notifications.test.mjs` |
 | US-30 | D | `tests/stories/d-notifications.test.mjs`, `tests/stories/e-remote-ssh.test.mjs`, `tests/oc-test.mjs` |
+| US-34 | D | `tests/pool-models-test.mjs`, `tests/pool-recheck-test.mjs` |
 | US-13 | E | `tests/stories/e-remote-ssh.test.mjs`, `tests/notify-test.mjs`, `tests/oc-test.mjs` |
 | US-14 | E | `tests/stories/e-remote-ssh.test.mjs`, `tests/oc-test.mjs` |
 | US-18 | E | `tests/stories/e-remote-ssh.test.mjs`, `tests/oc-test.mjs` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawaty/lacode",
-  "version": "1.3.0-beta.6",
+  "version": "1.3.0-beta.8",
   "description": "Ultimate opencode setup for Go users — cost-controlled pooled subagents, hang recovery, and notifications for opencode.",
   "license": "MIT",
   "type": "module",
@@ -55,7 +55,7 @@
   "scripts": {
     "build": "node scripts/build.mjs",
     "prepack": "npm run build",
-    "postpublish": "node scripts/sync-hosts.mjs",
+    "postpublish": "node scripts/sync-hosts.mjs && ./bin/oc-sync",
     "test": "node --test tests/",
     "benchmark": "node tests/benchmark/run.mjs",
     "score": "node scripts/score-models.mjs"

package/scripts/score-models.mjs

@@ -24,14 +24,14 @@
 //   * It never writes pool.txt. It prints a SUGGESTED table for you to paste; the
 //     pool stays yours to decide.
 //   * It never probes a paid model. Only cost 0/0 models from the provider's
-//     catalog are candidates.
+//     catalog are candidates (non-chat/media/safety/meta-router models are skipped).
 //
 // OUTPUT
 //   a per-provider ranked table, an overall ranking, a suggested pool.txt block,
 //   and (unless --no-write) the raw rows in ~/.config/lacode/model-scores.json so
 //   a later run can compare.
 
-import { execFileSync } from "node:child_process"
+import { execFileSync, spawn } from "node:child_process"
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { dirname, join } from "node:path"
@@ -39,6 +39,7 @@ import { dirname, join } from "node:path"
 const AUTH = join(homedir(), ".local", "share", "opencode", "auth.json")
 const OUT = join(homedir(), ".config", "lacode", "model-scores.json")
 const DEFAULT_PROVIDERS = ["opencode", "opencode-go", "openrouter", "console-openrouter"]
+const SESSION_PROVIDERS = new Set(["opencode", "opencode-go"])
 
 // ── scoring weights ─────────────────────────────────────────────────────────
 // Mechanical work prizes speed and availability over raw capability. Context is
@@ -59,8 +60,8 @@ const value = (flag, fallback) => {
   return hit.includes("=") ? hit.slice(hit.indexOf("=") + 1) : argv[argv.indexOf(hit) + 1]
 }
 
-if (has("--help") || has("-h")) {
-  console.log(`Usage: npm run score -- [options]
+  if (has("--help") || has("-h")) {
+    console.log(`Usage: npm run score -- [options]
 
   --providers a,b   providers to scan (default: ${DEFAULT_PROVIDERS.join(",")})
   --max N           probe at most N free models per provider (default: 12)
@@ -69,11 +70,14 @@ if (has("--help") || has("-h")) {
   --no-write        do not write ~/.config/lacode/model-scores.json
   -h, --help        this message
 
-Only cost 0/0 models are candidates. Credentials come from
-~/.local/share/opencode/auth.json; a provider with no entry falls back to the
-"opencode" key (which is how the console-openrouter connection authenticates).`)
-  process.exit(0)
-}
+Only cost 0/0 concrete text chat/completion models are candidates
+(non-chat/media generators, safety classifiers, and OpenRouter meta-routers are skipped).
+Credentials come from ~/.local/share/opencode/auth.json; a provider with no
+entry falls back to the "opencode" key (which is how the console-openrouter
+connection authenticates).
+opencode/opencode-go models are probed through a temporary local opencode serve --pure session, while the other providers are probed directly.`)
+    process.exit(0)
+  }
 
 const providers = String(value("--providers", DEFAULT_PROVIDERS.join(","))).split(",").map((s) => s.trim()).filter(Boolean)
 const maxPerProvider = Math.max(1, Number(value("--max", "12")) || 12)
@@ -119,6 +123,19 @@ function parseVerbose(text) {
   return rows
 }
 
+/** True for concrete text-in/text-out chat models, not media generators, classifiers, or OpenRouter meta-routers. */
+function isChatModel(model) {
+  const input = model?.capabilities?.input
+  const output = model?.capabilities?.output
+  if (input?.text === false) return false
+  if (output?.text === false) return false
+  if (output?.audio || output?.image || output?.video || output?.pdf) return false
+  const apiId = String(model?.api?.id ?? "").toLowerCase()
+  if (apiId.startsWith("openrouter/")) return false
+  if (/content[-_]safety|moderation|classifier/.test(apiId)) return false
+  return true
+}
+
 function freeModels(provider) {
   let text
   try {
@@ -135,6 +152,7 @@ function freeModels(provider) {
     .filter(({ model }) => model?.api?.url && model?.api?.id)
     .filter(({ model }) => (model.cost?.input ?? 1) === 0 && (model.cost?.output ?? 1) === 0)
     .filter(({ model }) => !model.status || model.status === "active")
+    .filter(({ model }) => isChatModel(model))
     .map(({ id, model }) => ({
       model: id,
       url: model.api.url,
@@ -166,11 +184,104 @@ const sessionHeader = (provider) =>
 // ── probing ─────────────────────────────────────────────────────────────────
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
+function failureText(error) {
+  if (!error) return "error"
+  if (typeof error === "string") return error
+  if (error?.data?.message) return error.data.message
+  if (error?.message) return error.message
+  if (error?.name) return error.name
+  try {
+    return JSON.stringify(error).slice(0, 240)
+  } catch {
+    return "error"
+  }
+}
+
+let sessionServerPromise = null
+let sessionServerProc = null
+
+function startSessionServer() {
+  if (sessionServerPromise) return sessionServerPromise
+  sessionServerPromise = new Promise((resolve, reject) => {
+    let resolved = false
+    let output = ""
+    let proc
+    try {
+      proc = spawn("opencode", ["serve", "--hostname=127.0.0.1", "--port=0", "--pure"], {
+        stdio: ["ignore", "pipe", "pipe"],
+      })
+    } catch (error) {
+      sessionServerPromise = null
+      sessionServerProc = null
+      reject(error)
+      return
+    }
+    sessionServerProc = proc
+
+    const timer = setTimeout(() => {
+      if (resolved) return
+      resolved = true
+      try {
+        proc.kill()
+      } catch {}
+      sessionServerPromise = null
+      sessionServerProc = null
+      reject(new Error("opencode serve timeout"))
+    }, 15000)
+
+    const onData = (chunk) => {
+      if (resolved) return
+      output += chunk.toString()
+      const match = output.match(/opencode server listening on (https?:\/\/\S+)/)
+      if (match) {
+        resolved = true
+        clearTimeout(timer)
+        const url = match[1].replace(/\/+$/, "")
+        resolve({ url, proc })
+      }
+    }
+    proc.stdout.on("data", onData)
+    proc.stderr.on("data", onData)
+
+    proc.on("error", (error) => {
+      if (resolved) return
+      resolved = true
+      clearTimeout(timer)
+      sessionServerPromise = null
+      sessionServerProc = null
+      reject(error)
+    })
+
+    proc.on("exit", () => {
+      if (sessionServerProc === proc) {
+        sessionServerProc = null
+        sessionServerPromise = null
+      }
+      if (resolved) return
+      resolved = true
+      clearTimeout(timer)
+      reject(new Error("opencode serve exited before ready"))
+    })
+  })
+  return sessionServerPromise
+}
+
+function stopSessionServer() {
+  if (sessionServerProc) {
+    try {
+      sessionServerProc.kill()
+    } catch {}
+    sessionServerProc = null
+  }
+  sessionServerPromise = null
+}
+process.on("exit", stopSessionServer)
+
 /**
  * One real request. Returns {ok, ms, reason}. A failure is named, never rounded
  * into a success, and `ms` is only reported for a request that actually ran.
  */
-async function probe(candidate, provider) {
+async function probeDirect(candidate, provider) {
   const key = keyFor(provider)
   if (!key) return { ok: false, ms: null, reason: "no credential in auth.json" }
 
@@ -226,6 +337,84 @@ async function probe(candidate, provider) {
   }
 }
 
+async function probeViaSession(candidate, provider) {
+  const started = performance.now()
+  let promptStarted = null
+  const directory = encodeURIComponent(process.cwd())
+  let id = null
+  let server = null
+  try {
+    server = await startSessionServer()
+    const createRes = await fetch(`${server.url}/session?directory=${directory}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ title: `score probe ${candidate.model}` }),
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    const createText = await createRes.text()
+    let createdJson = null
+    try {
+      createdJson = JSON.parse(createText)
+    } catch {}
+    if (!createRes.ok) {
+      const detail = createdJson?.error?.message ?? createdJson?.message ?? createText.slice(0, 160)
+      const ms = Math.round(performance.now() - started)
+      return { ok: false, ms, reason: `session create http ${createRes.status}: ${detail}` }
+    }
+    id = createdJson?.id ?? createdJson?.data?.id ?? null
+    if (!id) {
+      const ms = Math.round(performance.now() - started)
+      return { ok: false, ms, reason: `no session id: ${createText.slice(0, 160)}` }
+    }
+    promptStarted = performance.now()
+    const msgRes = await fetch(`${server.url}/session/${id}/message?directory=${directory}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: { providerID: provider, modelID: candidate.apiId },
+        system: "You are a connection health check. Reply with the single word: ok",
+        parts: [{ type: "text", text: "ok" }],
+      }),
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    const msgText = await msgRes.text()
+    let parsed = null
+    try {
+      parsed = JSON.parse(msgText)
+    } catch {}
+    const ms = Math.round(performance.now() - (promptStarted ?? started))
+    if (!msgRes.ok) {
+      const detail = parsed?.error?.message ?? parsed?.message ?? msgText.slice(0, 160)
+      return { ok: false, ms, reason: `http ${msgRes.status}: ${detail}` }
+    }
+    const failure = parsed?.error ?? parsed?.info?.error
+    if (failure) {
+      return { ok: false, ms, reason: failureText(failure).slice(0, 240) }
+    }
+    if (!parsed?.info) {
+      return { ok: false, ms, reason: "no response" }
+    }
+    return { ok: true, ms, reason: "answered" }
+  } catch (error) {
+    const ms = Math.round(performance.now() - (promptStarted ?? started))
+    if (error?.name === "TimeoutError") {
+      return { ok: false, ms, reason: `timeout after ${timeoutMs}ms` }
+    }
+    return { ok: false, ms, reason: failureText(error).slice(0, 240) }
+  } finally {
+    if (id && server) {
+      try {
+        await fetch(`${server.url}/session/${id}?directory=${directory}`, { method: "DELETE" })
+      } catch {}
+    }
+  }
+}
+
+async function probe(candidate, provider) {
+  if (SESSION_PROVIDERS.has(provider)) return probeViaSession(candidate, provider)
+  return probeDirect(candidate, provider)
+}
+
 // ── scoring ─────────────────────────────────────────────────────────────────
 const clamp01 = (n) => Math.max(0, Math.min(1, n))
 const logScore = (n, max) => (n && n > 0 ? clamp01(Math.log2(1 + n) / Math.log2(1 + max)) : 0)
@@ -274,6 +463,7 @@ async function main() {
     }
     results.push({ provider: entry.provider, error: null, rows })
   }
+  stopSessionServer()
 
   // Per-provider ranked tables.
   for (const entry of results) {