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

package/CHANGELOG.md

@@ -9,6 +9,29 @@ commit as the changelog entry it describes.
 
 ## [Unreleased]
 
+## [2.3.0-beta.4] — status never benches, structure is the contract
+
+### Fixed
+
+- Pool: only a hard outage (a gating `go`/`free` service reporting `down`) with a structurally intact pool may skip a refresh scan. A mere `degraded` never skips, because models routinely answer while the status page says degraded. Paid-tier (`payg`) and roll-up (`inference`) components can no longer freeze the free pool.
+- Pool: the fail-closed guard now enforces structure, not just count. A selection that drops the opencode-go head or the opencode tail is refused even at full count, and the keep threshold is anchored to the contract pool size (10) instead of the current file, so repeated writes can no longer ratchet the pool down. `--force-write` overrides the guard for a genuinely changed catalogue.
+- Pool: per-request probe deadline is 12 seconds (was 45), so a flapping provider stretches a scan far less; `--timeout MS` still overrides it.
+- Pool: a failed scorer run or a refused write now schedules a 5-minute recheck like every other failed run, instead of waiting for the next 6-hour slot.
+
+## [2.3.0-beta.3] — persist autonomy modes in global config
+
+### Changed
+
+- Modes: YOLO/YKB modes now persist in the lacode plugin options inside the global `opencode.jsonc` (single config file, comment-preserving edits).
+
+### Removed
+
+- Modes: removed `~/.config/lacode/modes.json` and `LACODE_MODES_FILE` seeding.
+
+### Fixed
+
+- Build: externalized the `jsonc-parser` runtime dependency.
+
 ## [2.3.0-beta.2] — degenerate refreshes never shrink the pool
 
 ### Added
@@ -1226,6 +1249,10 @@ experimental; `latest` remains 0.4.2.
 [Unreleased]: https://github.com/lawaty/lacode/compare/v2.1.0-beta.0...HEAD
 [2.1.0-beta.0]: https://github.com/lawaty/lacode/compare/v2.0.0-beta.0...v2.1.0-beta.0
 [2.0.0-beta.0]: https://github.com/lawaty/lacode/compare/v1.3.1...v2.0.0-beta.0
+[2.3.0-beta.3]: https://github.com/lawaty/lacode/compare/v2.3.0-beta.2...v2.3.0-beta.3
+[2.3.0-beta.2]: https://github.com/lawaty/lacode/compare/v2.3.0-beta.1...v2.3.0-beta.2
+[2.3.0-beta.1]: https://github.com/lawaty/lacode/compare/v2.3.0-beta.0...v2.3.0-beta.1
+[2.3.0-beta.0]: https://github.com/lawaty/lacode/releases/tag/v2.3.0-beta.0
 [1.3.1]: https://github.com/lawaty/lacode/releases/tag/v1.3.1
 [1.3.0-beta.9]: https://github.com/lawaty/lacode/releases/tag/v1.3.0-beta.9
 [1.3.0-beta.8]: https://github.com/lawaty/lacode/releases/tag/v1.3.0-beta.8

package/README.md

@@ -156,15 +156,15 @@ option is optional:
 | `feedbackHint` | `true` | Show the one-time feedback note on the first interactive run. `false` — or `LACODE_NO_FEEDBACK_HINT=1` — turns it off. The flag lives in `~/.local/share/opencode/lacode/feedback.json`; nothing is sent anywhere. |
 | `sound` | `true` | Play a short tone with each notification, one per outcome, so you can tell a finished session from a question or a permission prompt without reading the popup. It is opt-out: `false` — or `LACODE_SOUND=0` (`false`, `off`, `no` work too, and beat the option) — turns the sound off, and anything else, a typo included, leaves it on. |
 | `omniroute` | — | Optional [OmniRoute](docs/OMNIROUTE.md) gateway integration. Absent or `{ enabled: false }` changes nothing. |
-| `yolo` | `false` | Start with YOLO mode on: permission requests that would ask are auto-approved. Explicit `deny` rules still win. Toggle live with `/yolo`. |
-| `ykb` | `false` | Start with YKB (You Know Better) mode on: the agent is told not to ask, and questions that still appear are answered with the recommended option. Toggle live with `/ykb`. |
+| `yolo` | `false` | YOLO mode: permission requests that would ask are auto-approved. Explicit `deny` rules still win. The TUI writes this option when you run `/yolo`. |
+| `ykb` | `false` | YKB (You Know Better) mode: the agent is told not to ask, and questions that still appear are answered with the recommended option. The TUI writes this option when you run `/ykb`. |
 | `watchMs` | `1000` | How often the pool files are checked for changes. `0` disables live reload. |
 | `watchDebounceMs` | `250` | Collapse a burst of editor writes into one reload. |
 | `imagePaste` | — | Image attachments: `maxBytes` (4 MiB), `maxImages` (10) and `dir`. |
 
 ## Modes
 
-Two runtime modes can be seeded from plugin options and toggled from the TUI:
+Two runtime modes live on the lacode plugin entry and can be toggled from the TUI:
 
 | Command | Effect |
 | --- | --- |
@@ -172,7 +172,15 @@ Two runtime modes can be seeded from plugin options and toggled from the TUI:
 | `/ykb` | Toggle YKB (You Know Better). The agent is told not to ask questions and to continue with its recommendation. A question that still appears is answered with its `(Recommended)` option, or its first option when none is marked. |
 | `/modes` | Show both switches. |
 
-The toggles write `~/.config/lacode/modes.json` (override with `LACODE_MODES_FILE`) and the server picks the change up on the next decision — no restart. Turning a mode on also answers requests that are already pending. The `yolo` / `ykb` plugin options only seed the file on first run; after that, the file wins. A free-text question with no options is left for the user, since there is no option to choose.
+```jsonc
+{
+  "plugin": [
+    ["@lawaty/lacode", { "yolo": true, "ykb": false }]
+  ]
+}
+```
+
+The toggles edit the `yolo` / `ykb` options on the lacode plugin entry in your global opencode config (`~/.config/opencode/opencode.jsonc`, or `$XDG_CONFIG_HOME/opencode/opencode.jsonc`), preserving comments. The server reads that file on the next decision — no restart. Turning a mode on also answers requests that are already pending. The lacode plugin entry must already exist in the global config; a project-only entry cannot be toggled. A free-text question with no options is left for the user, since there is no option to choose.
 
 ### Staying up to date
 

package/dist/index.js

@@ -2282,9 +2282,9 @@ var STATE_DIR = join3(homedir2(), ".local", "share", "opencode", "lacode");
 var STATE_PATH = join3(STATE_DIR, "selfupdate.json");
 var LOCK_PATH = join3(STATE_DIR, "selfupdate.lock");
 function compareSemver(a, b) {
-  const parse = (v) => v.split("-")[0].split("+")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
-  const left = parse(a);
-  const right = parse(b);
+  const parse2 = (v) => v.split("-")[0].split("+")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const left = parse2(a);
+  const right = parse2(b);
   for (let i = 0; i < 3; i++) {
     const l = left[i] ?? 0;
     const r = right[i] ?? 0;
@@ -6167,35 +6167,82 @@ async function imagePasteHooks(input, options, deps) {
   }
 }
 
-// src/lib/modes.ts
+// src/lib/opencode-config.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync9, readFileSync as readFileSync10, renameSync as renameSync7, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname6, join as join12 } from "node:path";
-var MODES_FILE = process.env.LACODE_MODES_FILE ?? join12(homedir8(), ".config", "lacode", "modes.json");
+import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
+function globalOpencodeConfigPath() {
+  const base = process.env.XDG_CONFIG_HOME ?? join12(homedir8(), ".config");
+  const jsonc = join12(base, "opencode", "opencode.jsonc");
+  return existsSync5(jsonc) ? jsonc : join12(base, "opencode", "opencode.json");
+}
+var OpenCodeConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenCodeConfigError";
+  }
+};
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readOpencodeConfig(path4 = globalOpencodeConfigPath()) {
+  if (!existsSync5(path4)) return {};
+  const text = readFileSync10(path4, "utf8");
+  const errors = [];
+  const parsed = parse(text, errors, { allowTrailingComma: true, disallowComments: false });
+  if (errors.length > 0) {
+    const detail = errors.map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`).join(", ");
+    throw new OpenCodeConfigError(`Failed to parse ${path4}: ${detail}`);
+  }
+  if (!isPlainObject(parsed)) {
+    throw new OpenCodeConfigError(`Config root must be an object: ${path4}`);
+  }
+  return parsed;
+}
+function pluginName(entry) {
+  if (typeof entry === "string") return entry;
+  if (Array.isArray(entry) && typeof entry[0] === "string") return entry[0];
+  return void 0;
+}
+function matchesLacode(name) {
+  if (name === "@lawaty/lacode") return true;
+  const segments = name.split(/[\\/]/);
+  return segments.some((s) => s.toLowerCase() === "lacode");
+}
+function findLacodePlugin(config) {
+  const plugins = config.plugin;
+  if (!Array.isArray(plugins)) return void 0;
+  for (let index = 0; index < plugins.length; index++) {
+    const entry = plugins[index];
+    const name = pluginName(entry);
+    if (!name || !matchesLacode(name)) continue;
+    const options = Array.isArray(entry) && isPlainObject(entry[1]) ? entry[1] : void 0;
+    return { index, name, options };
+  }
+  return void 0;
+}
+function readModeOptions(config = readOpencodeConfig()) {
+  const entry = findLacodePlugin(config);
+  const options = entry?.options;
+  const yolo = typeof options?.yolo === "boolean" ? options.yolo : void 0;
+  const ykb = typeof options?.ykb === "boolean" ? options.ykb : void 0;
+  return { yolo, ykb };
+}
+
+// src/lib/modes.ts
 var YKB_INSTRUCTION = "YKB MODE (You Know Better) is ON. Do not ask the user questions, request clarification, or wait for confirmation. When a decision is needed, choose the option you would recommend, state the choice briefly, and continue until the task is complete. Stop only if you are genuinely blocked by a missing credential, an unrecoverable error, or a permission that cannot be granted.";
-var bool = (value, fallback) => typeof value === "boolean" ? value : fallback;
 function readModes(defaults = {}) {
-  const fallback = { yolo: defaults.yolo === true, ykb: defaults.ykb === true };
   try {
-    const raw = JSON.parse(readFileSync10(MODES_FILE, "utf8"));
-    return { yolo: bool(raw?.yolo, fallback.yolo), ykb: bool(raw?.ykb, fallback.ykb) };
+    const options = readModeOptions();
+    return {
+      yolo: options.yolo ?? defaults.yolo === true,
+      ykb: options.ykb ?? defaults.ykb === true
+    };
   } catch {
-    return fallback;
+    return { yolo: defaults.yolo === true, ykb: defaults.ykb === true };
   }
 }
-function writeModes(modes) {
-  const path4 = MODES_FILE;
-  mkdirSync9(dirname6(path4), { recursive: true });
-  const tmp = `${path4}.tmp`;
-  writeFileSync10(tmp, `${JSON.stringify({ yolo: modes.yolo, ykb: modes.ykb }, null, 2)}
-`);
-  renameSync7(tmp, path4);
-}
-function seedModes(defaults) {
-  if (existsSync5(MODES_FILE)) return;
-  if (defaults.yolo !== true && defaults.ykb !== true) return;
-  writeModes({ yolo: defaults.yolo === true, ykb: defaults.ykb === true });
-}
 function recommendedAnswer(question) {
   const q = question;
   const options = (Array.isArray(q?.options) ? q.options : []).filter(
@@ -6214,7 +6261,6 @@ async function modesHooks(input, options) {
   const defaults = {};
   if (typeof opts.yolo === "boolean") defaults.yolo = opts.yolo;
   if (typeof opts.ykb === "boolean") defaults.ykb = opts.ykb;
-  seedModes(defaults);
   const state2 = () => readModes(defaults);
   const warn2 = (message) => {
     input.client.app.log({ body: { service: "modes", level: "warn", message } }).catch(() => {

package/dist/tui.js

@@ -943,28 +943,129 @@ var plugin = {
 };
 var timeline_default = plugin;
 
-// src/lib/modes.ts
+// src/lib/opencode-config.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { dirname, join as join4 } from "node:path";
-var MODES_FILE = process.env.LACODE_MODES_FILE ?? join4(homedir3(), ".config", "lacode", "modes.json");
-var bool = (value, fallback) => typeof value === "boolean" ? value : fallback;
+import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
+function globalOpencodeConfigPath() {
+  const base = process.env.XDG_CONFIG_HOME ?? join4(homedir3(), ".config");
+  const jsonc = join4(base, "opencode", "opencode.jsonc");
+  return existsSync2(jsonc) ? jsonc : join4(base, "opencode", "opencode.json");
+}
+var OpenCodeConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenCodeConfigError";
+  }
+};
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readOpencodeConfig(path = globalOpencodeConfigPath()) {
+  if (!existsSync2(path)) return {};
+  const text = readFileSync3(path, "utf8");
+  const errors = [];
+  const parsed = parse(text, errors, { allowTrailingComma: true, disallowComments: false });
+  if (errors.length > 0) {
+    const detail = errors.map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`).join(", ");
+    throw new OpenCodeConfigError(`Failed to parse ${path}: ${detail}`);
+  }
+  if (!isPlainObject(parsed)) {
+    throw new OpenCodeConfigError(`Config root must be an object: ${path}`);
+  }
+  return parsed;
+}
+function pluginName(entry) {
+  if (typeof entry === "string") return entry;
+  if (Array.isArray(entry) && typeof entry[0] === "string") return entry[0];
+  return void 0;
+}
+function matchesLacode(name) {
+  if (name === "@lawaty/lacode") return true;
+  const segments = name.split(/[\\/]/);
+  return segments.some((s) => s.toLowerCase() === "lacode");
+}
+function findLacodePlugin(config) {
+  const plugins = config.plugin;
+  if (!Array.isArray(plugins)) return void 0;
+  for (let index = 0; index < plugins.length; index++) {
+    const entry = plugins[index];
+    const name = pluginName(entry);
+    if (!name || !matchesLacode(name)) continue;
+    const options = Array.isArray(entry) && isPlainObject(entry[1]) ? entry[1] : void 0;
+    return { index, name, options };
+  }
+  return void 0;
+}
+function readModeOptions(config = readOpencodeConfig()) {
+  const entry = findLacodePlugin(config);
+  const options = entry?.options;
+  const yolo = typeof options?.yolo === "boolean" ? options.yolo : void 0;
+  const ykb = typeof options?.ykb === "boolean" ? options.ykb : void 0;
+  return { yolo, ykb };
+}
+function writeModeOptions(patch, path = globalOpencodeConfigPath()) {
+  if (!existsSync2(path)) {
+    throw new OpenCodeConfigError(`Cannot write mode options: config does not exist: ${path}`);
+  }
+  let text = readFileSync3(path, "utf8");
+  const errors = [];
+  const parsed = parse(text, errors, { allowTrailingComma: true, disallowComments: false });
+  if (errors.length > 0) {
+    const detail = errors.map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`).join(", ");
+    throw new OpenCodeConfigError(`Failed to parse ${path}: ${detail}`);
+  }
+  if (!isPlainObject(parsed)) {
+    throw new OpenCodeConfigError(`Config root must be an object: ${path}`);
+  }
+  const entry = findLacodePlugin(parsed);
+  if (!entry) {
+    throw new OpenCodeConfigError(`lacode plugin entry not found in ${path}`);
+  }
+  const formattingOptions = { insertSpaces: true, tabSize: 2, eol: "\n" };
+  const pluginEntry = parsed.plugin[entry.index];
+  if (typeof pluginEntry === "string") {
+    const obj = {};
+    if (patch.yolo !== void 0) obj.yolo = patch.yolo;
+    if (patch.ykb !== void 0) obj.ykb = patch.ykb;
+    const edits = modify(text, ["plugin", entry.index], [entry.name, obj], { formattingOptions });
+    text = applyEdits(text, edits);
+  } else if (Array.isArray(pluginEntry) && !isPlainObject(pluginEntry[1])) {
+    const obj = {};
+    if (patch.yolo !== void 0) obj.yolo = patch.yolo;
+    if (patch.ykb !== void 0) obj.ykb = patch.ykb;
+    const edits = modify(text, ["plugin", entry.index, 1], obj, { formattingOptions });
+    text = applyEdits(text, edits);
+  } else {
+    const keys = ["yolo", "ykb"];
+    for (const key of keys) {
+      const value = patch[key];
+      if (value === void 0) continue;
+      const edits = modify(text, ["plugin", entry.index, 1, key], value, { formattingOptions });
+      text = applyEdits(text, edits);
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, path);
+}
+
+// src/lib/modes.ts
 function readModes(defaults = {}) {
-  const fallback = { yolo: defaults.yolo === true, ykb: defaults.ykb === true };
   try {
-    const raw = JSON.parse(readFileSync3(MODES_FILE, "utf8"));
-    return { yolo: bool(raw?.yolo, fallback.yolo), ykb: bool(raw?.ykb, fallback.ykb) };
+    const options = readModeOptions();
+    return {
+      yolo: options.yolo ?? defaults.yolo === true,
+      ykb: options.ykb ?? defaults.ykb === true
+    };
   } catch {
-    return fallback;
+    return { yolo: defaults.yolo === true, ykb: defaults.ykb === true };
   }
 }
 function writeModes(modes) {
-  const path = MODES_FILE;
-  mkdirSync(dirname(path), { recursive: true });
-  const tmp = `${path}.tmp`;
-  writeFileSync(tmp, `${JSON.stringify({ yolo: modes.yolo, ykb: modes.ykb }, null, 2)}
-`);
-  renameSync(tmp, path);
+  writeModeOptions({ yolo: modes.yolo, ykb: modes.ykb });
 }
 function toggleMode(name, defaults = {}) {
   const current = readModes(defaults);

package/docs/CONFIGURATION.md

@@ -52,7 +52,7 @@ restart.
 
 ## Modes
 
-Two runtime modes can be seeded from plugin options and toggled from the TUI:
+Two runtime modes live on the lacode plugin entry and can be toggled from the TUI:
 
 | Command | Effect |
 | --- | --- |
@@ -60,7 +60,15 @@ Two runtime modes can be seeded from plugin options and toggled from the TUI:
 | `/ykb` | Toggle YKB (You Know Better). The agent is told not to ask questions and to continue with its recommendation. A question that still appears is answered with its `(Recommended)` option, or its first option when none is marked. |
 | `/modes` | Show both switches. |
 
-The toggles write `~/.config/lacode/modes.json` (override with `LACODE_MODES_FILE`) and the server picks the change up on the next decision — no restart. Turning a mode on also answers requests that are already pending. The `yolo` / `ykb` plugin options only seed the file on first run; after that, the file wins. A free-text question with no options is left for the user, since there is no option to choose.
+```jsonc
+{
+  "plugin": [
+    ["@lawaty/lacode", { "yolo": true, "ykb": false }]
+  ]
+}
+```
+
+The toggles edit the `yolo` / `ykb` options on the lacode plugin entry in your global opencode config (`~/.config/opencode/opencode.jsonc`, or `$XDG_CONFIG_HOME/opencode/opencode.jsonc`), preserving comments. The server reads that file on the next decision — no restart. Turning a mode on also answers requests that are already pending. The lacode plugin entry must already exist in the global config; a project-only entry cannot be toggled. A free-text question with no options is left for the user, since there is no option to choose.
 
 
 ## Which models run which agent

package/docs/USER-STORIES.md

@@ -194,7 +194,9 @@ A refresh once replaced a healthy ten-slot pool with a two-slot scan because not
 **Story ID(s) for tests:** US-40
 **Acceptance criteria:**
 - [ ] Given a healthy pool and a scan that returns fewer slots than half of it (minimum four), When the refresh finishes, Then the previous pool file is left untouched, the refusal is logged, and a recheck is scheduled in 5 minutes.
-- [ ] Given opencode's serving path reports degraded on the live status and the current pool is intact, When the refresh runs, Then no scan is started, the pool is kept, and a recheck is scheduled in 5 minutes.
+- [ ] Given a scan that drops the opencode-go head or the opencode tail the current pool has, When the refresh finishes, Then the previous pool is kept even at full count, because the structure is the contract.
+- [ ] Given opencode's serving path reports a hard outage on the live status and the current pool is structurally intact, When the refresh runs, Then no scan is started, the pool is kept, and a recheck is scheduled in 5 minutes.
+- [ ] Given the status reports degraded (latency, elevated errors) rather than down, When the refresh runs, Then the scan proceeds as normal, because models routinely answer while the page says degraded.
 - [ ] Given any failed run with a stated reset hours out, When the retry is scheduled, Then the recheck still happens within 5 minutes; a sooner provider reset is honoured.
 - [ ] Given the degradation lifts, When the next 5-minute recheck runs, Then a full scan restores the pool instead of waiting for the next 6-hour slot.
 - [ ] Given a thin or missing pool, When a fuller scan completes, Then it is always written — the guard only ever blocks shrinking, never recovery.
@@ -569,15 +571,15 @@ A failed summarization used to clear the pending flag and never reschedule, so o
 ### US-37: YOLO mode approves permissions without stopping
 **As a** user running a long autonomous task, **I want** permission prompts to be approved automatically while YOLO is on, **so that** the agent keeps working instead of waiting for routine approvals, while an explicit `deny` still protects me.
 
-Permission prompts are the main thing that breaks a long autonomous run: every `ask` blocks the session until a human answers. YOLO flips that decision to `allow` at the permission hook, keeps an explicit `deny` authoritative, and answers any request that still reaches the event bus. The state is a small file the TUI writes and the server reads on the next decision, so enabling it also clears what is already pending.
+Permission prompts are the main thing that breaks a long autonomous run: every `ask` blocks the session until a human answers. YOLO flips that decision to `allow` at the permission hook, keeps an explicit `deny` authoritative, and answers any request that still reaches the event bus. The state lives in the `yolo` option on the lacode plugin entry in the global `opencode.jsonc`; the TUI writes it and the server reads it on the next decision, so enabling it also clears what is already pending.
 
 **Story ID(s) for tests:** US-37
 **Acceptance criteria:**
 - [ ] Given YOLO is on, When the runtime's permission decision is `ask`, Then it becomes `allow` without a prompt, while an existing `deny` or `allow` is left unchanged.
 - [ ] Given YOLO is off, When the runtime's permission decision is `ask`, Then it stays `ask` and still reaches the user.
 - [ ] Given a `permission.asked` event still reaches the event bus while YOLO is on and carries a request id and a session id, When the handler runs, Then the plugin replies `once` for that request; an event missing either id is ignored.
-- [ ] Given YOLO is toggled in the TUI, When the mode file changes, Then the next permission decision sees the new value without a restart, and requests already pending are answered.
-- [ ] Given `yolo: true` in the plugin options and no live mode file, When the plugin starts, Then the file is seeded; after a TUI toggle, the live file wins.
+- [ ] Given YOLO is toggled in the TUI, When the global `opencode.jsonc` changes, Then the next permission decision sees the new value without a restart, and requests already pending are answered.
+- [ ] Given the TUI toggles a mode, When it writes the global `opencode.jsonc`, Then only the `yolo` / `ykb` options on the lacode plugin entry change, comments and formatting are preserved, and the config remains the single source of truth.
 - [ ] Given the README and configuration reference, Then the `yolo` option and the `/yolo` command are documented alongside `/modes`.
 
 ### US-38: YKB mode chooses the recommendation instead of asking
@@ -654,6 +656,6 @@ The root-level suites under `tests/` are unit-style; the `tests/stories/` suites
 the behavioural layer, written one epic per file with every test name carrying
 its story id. Run everything with `npm test`.
 
-40/40 stories covered by 375 test case(s); thinnest story has 1.
+40/40 stories covered by 377 test case(s); thinnest story has 1.
 No story is untested. The scan covers the `tests/stories/` suites and the root-level
 `tests/*-test.mjs` suites.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawaty/lacode",
-  "version": "2.3.0-beta.2",
+  "version": "2.3.0-beta.4",
   "description": "Ultimate opencode setup for Go users — cost-controlled pooled subagents, hang recovery, and notifications for opencode.",
   "license": "MIT",
   "type": "module",
@@ -68,8 +68,8 @@
   },
   "peerDependencies": {
     "@opencode-ai/plugin": "1.18.34",
-    "solid-js": "*",
-    "@opentui/solid": "*"
+    "@opentui/solid": "*",
+    "solid-js": "*"
   },
   "peerDependenciesMeta": {
     "solid-js": {
@@ -85,5 +85,8 @@
   },
   "publishConfig": {
     "tag": "latest"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.1"
   }
 }

package/scripts/refresh-pool.mjs

@@ -24,6 +24,7 @@ import { homedir, userInfo } from "node:os"
 import { dirname, join, resolve } from "node:path"
 import { fileURLToPath } from "node:url"
 import { fetchProviderStatus } from "./provider-status.mjs"
+import { POOL_SIZE } from "./pool-selection.mjs"
 
 const HOME = homedir()
 export const DEFAULT_SCORES_PATH = join(HOME, ".config", "lacode", "model-scores.json")
@@ -209,23 +210,83 @@ export function poolSlotCount(text) {
   return splitHeaderAndSlots(text).slots.filter(isSlotLine).length
 }
 
+/** The pool's structural contract: an opencode-go head and an opencode tail. */
+export function poolHasHead(text) {
+  const slots = splitHeaderAndSlots(text).slots.filter(isSlotLine)
+  return slots.length > 0 && slots[0].split("#")[0].trim().startsWith("opencode-go/")
+}
+
+export function poolHasTail(text) {
+  const slots = splitHeaderAndSlots(text).slots.filter(isSlotLine)
+  if (slots.length === 0) return false
+  const last = slots[slots.length - 1].split("#")[0].trim()
+  return last.startsWith("opencode/") && /(^|\s)b:opencode(\s|$)/.test(last)
+}
+
+/**
+ * Pure scan-skip decision. Only a hard `down` on a gating opencode service may
+ * skip a scan — `degraded` never does, because models routinely answer while
+ * the page says degraded. A structurally broken pool is never skipped either:
+ * the scan is its repair path.
+ */
+export function shouldSkipScan({ providerStatus, currentPoolText }) {
+  if (!providerStatus?.ok || providerStatus.stale) {
+    return { skip: false, reason: "no trustworthy live signal; scanning" }
+  }
+  const down = Array.isArray(providerStatus.down) ? providerStatus.down : []
+  if (down.length === 0) {
+    return { skip: false, reason: "no hard outage on the live status; scanning" }
+  }
+  if (!poolHasHead(currentPoolText) || !poolHasTail(currentPoolText)) {
+    return { skip: false, reason: "pool structure already broken; scanning to repair it" }
+  }
+  return {
+    skip: true,
+    reason: `opencode status reports down: ${down.join(", ")}; keeping the current pool and rechecking in ${DEGRADED_RETRY_S / 60} minutes`,
+  }
+}
+
 /**
- * Pure fail-closed guard. A refresh must never replace a working pool with a
- * degenerate selection: when the new slot count falls below half the previous
- * pool (floored at MIN_POOL_SLOTS), the previous pool is kept. There is no
- * previous pool on a first-ever run, so there is nothing to protect and the
- * guard passes.
+ * Pure fail-closed guard. A refresh must never break the pool's structure or
+ * replace a working pool with a degenerate selection: the new pool must keep
+ * the opencode-go head and the opencode tail the current pool has, and hold at
+ * least half of POOL_SIZE. The baseline is the contract size, never the
+ * current file — a previously shrunk pool can always grow back, but no write
+ * may shrink or behead it. There is no previous pool on a first-ever run, so
+ * there is nothing to protect and the guard passes. `--force-write` is the
+ * human override for a genuinely changed catalogue.
  */
-export function shouldKeepPool({ currentPoolText, newSlotCount }) {
+export function shouldKeepPool({ currentPoolText, newSlots }) {
   const prev = poolSlotCount(currentPoolText ?? "")
   if (prev <= 0) return { keep: false, prev, threshold: 0, reason: "no previous pool to protect" }
-  const threshold = Math.max(MIN_POOL_SLOTS, Math.floor(prev / 2))
-  if (newSlotCount >= threshold) return { keep: false, prev, threshold, reason: "" }
+  const slots = Array.isArray(newSlots) ? newSlots : []
+  const threshold = Math.max(MIN_POOL_SLOTS, Math.floor(POOL_SIZE / 2))
+  if (poolHasHead(currentPoolText) && !slots.some((line) => String(line).split("#")[0].trim().startsWith("opencode-go/"))) {
+    return {
+      keep: true,
+      prev,
+      threshold,
+      reason: `new selection has no opencode-go head slot while the previous pool has one; refusing to behead the pool`,
+    }
+  }
+  const tailKept = slots.some((line) => {
+    const stripped = String(line).split("#")[0].trim()
+    return stripped.startsWith("opencode/") && /(^|\s)b:opencode(\s|$)/.test(stripped)
+  })
+  if (poolHasTail(currentPoolText) && !tailKept) {
+    return {
+      keep: true,
+      prev,
+      threshold,
+      reason: `new selection has no opencode tail slot while the previous pool has one; refusing to dock the tail`,
+    }
+  }
+  if (slots.length >= threshold) return { keep: false, prev, threshold, reason: "" }
   return {
     keep: true,
     prev,
     threshold,
-    reason: `new selection has ${newSlotCount} usable slot(s), below the keep threshold of ${threshold} (previous pool had ${prev}); refusing to shrink the pool`,
+    reason: `new selection has ${slots.length} usable slot(s), below the keep threshold of ${threshold} (contract pool size ${POOL_SIZE}); refusing to shrink the pool`,
   }
 }
 
@@ -383,15 +444,19 @@ function usage() {
   --max N           models per provider passed to the scorer (default: 50)
   --scores PATH     scores file (default: ${DEFAULT_SCORES_PATH})
   --pool PATH       pool file to read/compare/write (default: ${DEFAULT_POOL_PATH})
+  --force-write   write the new selection even when the fail-closed guard would
+                    keep the previous pool (human override for a changed catalogue)
   -h, --help        this message
 
 Degradation behaviour: before scanning, the refresh checks
-https://status.opencode.ai/api/status. When opencode's serving path reports
-degraded and the current pool is intact, the scan is skipped, the pool is kept,
-and a recheck is scheduled in 5 minutes. After a scan, a selection below half
-the previous pool (minimum ${MIN_POOL_SLOTS} slots) is never written; the previous pool
-is kept and a 5-minute recheck is scheduled. A retry is always rechecked
-within 5 minutes while anything failed, even when the stated reset is hours out.`)
+https://status.opencode.ai/api/status. Only a hard outage (a gating service
+reporting down) with a structurally intact pool skips the scan; a mere degraded
+never does, because models routinely answer while the page says degraded. After
+a scan, a selection that beheads the pool (no opencode-go head), docks the tail
+(no opencode slot), or falls below half the contract pool size (minimum ${MIN_POOL_SLOTS}
+slots) is never written; the previous pool is kept and a 5-minute recheck is
+scheduled. A retry is always rechecked within 5 minutes while anything failed,
+even when the stated reset is hours out.`)
 }
 
 async function main() {
@@ -404,6 +469,7 @@ async function main() {
   const fromScores = argv.includes("--from-scores")
   const printOnly = argv.includes("--print") || argv.includes("--dry-run")
   const noRetry = argv.includes("--no-retry")
+  const forceWrite = argv.includes("--force-write")
   const value = (flag, fallback) => {
     const hit = argv.find((a) => a === flag || a.startsWith(`${flag}=`))
     if (!hit) return fallback
@@ -423,23 +489,21 @@ async function main() {
 
   const currentPoolText = readTextFile(poolPath)
 
-  // Live degradation signal. When opencode's own serving path reports degraded
-  // and the current pool is intact, probing now can only shrink it: keep the
-  // pool untouched and recheck in 5 minutes. A thin pool is still scanned, so
-  // a first-ever run (or a previously clobbered one) can recover, and the
-  // write guard below protects it if the scan comes back degenerate.
-  let providerStatus = { ok: false, providers: [], services: [] }
+  // Live degradation signal. Only a hard `down` on opencode's serving path may
+  // skip the scan — and only when the current pool is structurally intact, so
+  // a broken pool always gets its repair scan. `degraded` never skips: models
+  // routinely answer while the page says degraded, and the write guard below
+  // protects the pool if the scan comes back degenerate.
+  let providerStatus = { ok: false, providers: [], services: [], down: [] }
   if (!printOnly) {
     try {
       providerStatus = await fetchProviderStatus()
     } catch (error) {
-      providerStatus = { ok: false, providers: [], services: [], reason: String(error?.message ?? error) }
+      providerStatus = { ok: false, providers: [], services: [], down: [], reason: String(error?.message ?? error) }
     }
-    if (providerStatus.ok && providerStatus.providers.length > 0 && poolSlotCount(currentPoolText) >= MIN_POOL_SLOTS) {
-      const detail = providerStatus.services.map((entry) => `${entry.service}=${entry.status}`).join(", ")
-      console.log(
-        `opencode status degraded (${detail}); keeping the current pool of ${poolSlotCount(currentPoolText)} slots and rechecking in ${DEGRADED_RETRY_S / 60} minutes`,
-      )
+    const skip = shouldSkipScan({ providerStatus, currentPoolText })
+    if (skip.skip) {
+      console.log(`${skip.reason}; keeping the current pool of ${poolSlotCount(currentPoolText)} slots`)
       if (!noRetry) {
         const scheduled = scheduleRetrySoon()
         console.log(
@@ -457,6 +521,14 @@ async function main() {
       runScorer(max)
     } catch (error) {
       console.error(`scorer failed; pool.txt not written: ${String(error?.message ?? error)}`)
+      if (!printOnly && !noRetry) {
+        const scheduled = scheduleRetrySoon()
+        console.log(
+          scheduled.scheduled
+            ? `scheduled degraded recheck in ${scheduled.seconds}s`
+            : `degraded recheck not scheduled: ${scheduled.reason}`,
+        )
+      }
       process.exitCode = 1
       return
     }
@@ -476,6 +548,14 @@ async function main() {
     built = buildPool({ scores, currentPoolText, now: new Date() })
   } catch (error) {
     console.error(`refresh refused (fail closed): ${String(error?.message ?? error)}`)
+    if (!printOnly && !noRetry) {
+      const scheduled = scheduleRetrySoon()
+      console.log(
+        scheduled.scheduled
+          ? `scheduled degraded recheck in ${scheduled.seconds}s`
+          : `degraded recheck not scheduled: ${scheduled.reason}`,
+      )
+    }
     process.exitCode = 1
     return
   }
@@ -491,8 +571,9 @@ async function main() {
 
   // Fail closed on a degenerate selection: keep the previous pool, say so
   // loudly, and recheck in 5 minutes instead of waiting out a long reset.
-  if (!printOnly) {
-    const kept = shouldKeepPool({ currentPoolText, newSlotCount })
+  // --force-write is the human override for a genuinely changed catalogue.
+  if (!printOnly && !forceWrite) {
+    const kept = shouldKeepPool({ currentPoolText, newSlots: built.slots })
     if (kept.keep) {
       console.error(`refresh refused (fail closed): ${kept.reason}`)
       if (!noRetry) {

package/scripts/score-models.mjs

@@ -104,7 +104,7 @@ const value = (flag, fallback) => {
   --min-context N   exclude models whose context limit is below N (default: ${MIN_CONTEXT})
   --min-score N     do not rank models scoring below N (default: ${MIN_SCORE})
   --free-only        only probe catalogue cost 0/0 models on every provider
-  --timeout MS      per-request deadline in ms (default: 45000)
+  --timeout MS      per-request deadline in ms (default: 12000)
   --delay MS        pause between requests in ms (default: 300)
   --budget-min N    stop starting new probes after N minutes and write what was
                     measured; providers not scanned keep their previous rows
@@ -129,7 +129,7 @@ const providers = providerArg ? String(providerArg).split(",").map((s) => s.trim
 const maxPerProvider = Math.max(1, Number(value("--max", "50")) || 50)
 const minContext = Math.max(0, Number(value("--min-context", String(MIN_CONTEXT))) || MIN_CONTEXT)
 const minScore = Math.max(0, Number(value("--min-score", String(MIN_SCORE))) || MIN_SCORE)
-const timeoutMs = Math.max(1_000, Number(value("--timeout", "45000")) || 45_000)
+const timeoutMs = Math.max(1_000, Number(value("--timeout", "12000")) || 12_000)
 const delayMs = Math.max(0, Number(value("--delay", "300")) || 300)
 const budgetMin = Math.max(1, Number(value("--budget-min", "30")) || 30)
 const budgetMs = budgetMin * 60_000