amicus 4.7.0 → 4.8.0

package/src/sidecar/fanout-retry.js

@@ -73,7 +73,10 @@ function buildRetryPlan(origWaveId, project, { models } = {}) {
     } catch { /* legacy leg — fall back to briefing.md at launch time */ }
     eligible.push({ legId, model, systemPrompt, userMessage, hadSavedContext });
   }
-  return { eligible };
+  // waveMeta has been read since :51 but was discarded; retryFailedWave needs
+  // the tag BEFORE it builds fanoutOpts, and its own origMeta re-read at :176
+  // runs after runFanoutImpl at :153 — too late to influence the launch.
+  return { eligible, tag: waveMeta.tag };
 }
 
 /**
@@ -121,7 +124,7 @@ async function retryFailedWave(origWaveId, project, opts = {}) {
         // --json caller's stdout stays machine-parseable either way.
         const noopDoc = {
           ...buildWaveResult({ waveId: origWaveId, legs: [], status: 'complete' }),
-          retryOf: origWaveId, effective: [], note: 'no failed legs',
+          retryOf: origWaveId, effective: [], note: 'no failed legs', tag: plan.tag,
         };
         process.stdout.write(JSON.stringify(noopDoc, null, 2) + '\n');
       } else {
@@ -148,7 +151,16 @@ async function retryFailedWave(origWaveId, project, opts = {}) {
   // expects (parseModelsList/validateFanoutModels) — an array silently fails
   // every leg pre-flight (BAD_ARGS), matching run-launch.js:41's precedent.
   // Strip our own injection key so it is never forwarded.
-  const fanoutOpts = { ...opts, models: models.join(','), prompt: briefing, project, waveId: newWaveId, retryContexts, retryOfWaveId: origWaveId };
+  const fanoutOpts = {
+    ...opts, models: models.join(','), prompt: briefing, project, waveId: newWaveId, retryContexts, retryOfWaveId: origWaveId,
+    // v4.7.1 Task 8: inherit the ORIGINAL wave's tag — sourced from disk
+    // (plan.tag, off waveMeta) never from opts.tag/args.tag. This is placed
+    // AFTER the `...opts` spread so it wins even if a caller's opts somehow
+    // carried a tag (the CLI itself already rejects --tag + --retry-failed
+    // upstream in cli-handlers-fanout.js). Absent-not-null idiom, matching
+    // fanout.js:152's `...(options.pack ? {...} : {})`.
+    ...(plan.tag ? { tag: plan.tag } : {}),
+  };
   delete fanoutOpts.runFanout;
   const { wave, exitCode } = await runFanoutImpl(fanoutOpts);
 

package/src/sidecar/fanout-wave-io.js

@@ -75,13 +75,38 @@ async function finishWave({ wave, waveDir, waveId, project, exitCode, completedA
 /**
  * v4.3 §7.2 (moved here v4.7 PR3 Task 1): stamp council attribution onto every
  * leg — fanout-leg's appendSpend reads it; no-op for every non-council caller.
- * v4.7 F8 (Task 7) adds tag stamping in the same pass.
+ * v4.7 F8 (Task 7) adds tag stamping in the same pass. v4.8 R5 (T4.2) adds
+ * seat stamping in the same pass.
  */
 function stampLegAttribution(legs, options) {
   if (options.councilRunId || options.councilName) {
     legs.forEach(l => { l.councilRunId = options.councilRunId; l.councilName = options.councilName; });
   }
   if (options.tag) { legs.forEach(l => { l.tag = options.tag; }); }
+  // v4.8 R5: seat identity for the LIVE path. `options.seats` is the launching
+  // wave's roster, index-parallel with `options.models` by construction
+  // (run-stage1-launch.js builds `roster` and `models` from the same filter, and
+  // fanout-validate.js:66-87 pushes exactly one leg per model on BOTH its ok and
+  // its unroutable branch, so a leg that never routed still holds its slot).
+  //
+  // ⚠️ emit-when-DIFFERENT, against the seat's OWN alias — the shared predicate
+  // stated at run-stats-entry.js :: buildRunStatsEntry, which the three sites in
+  // run-assemble.js also spell. buildSeats mints `alias#N` ONLY when an alias
+  // repeats (seats.js:67), so `id !== alias` IS "the bench repeats this alias",
+  // and on a unique bench `id` IS the alias — a bare `if (s.id)` would stamp an
+  // alias-valued seat onto every leg of every run: the same wrong output shape
+  // run-assemble.js:165-169 records having already fixed once there (a
+  // wrong-comparator bug, `!== j.judge` rather than `!== alias`, with a
+  // narrower trigger — only a leg/seat alias drift, not every leg).
+  // Comparing against the seat's own alias and never against `model` also makes
+  // this immune to the two cases where `model` is NOT the alias (a leg reporting
+  // no modelInput; a padded --council member).
+  if (Array.isArray(options.seats)) {
+    legs.forEach((l, i) => {
+      const s = options.seats[i];
+      if (s && s.id !== s.alias) { l.seat = s.id; }
+    });
+  }
 }
 
 module.exports = { writeWaveMetadata, writeWaveDoc, finishWave, stampLegAttribution };

package/src/sidecar/fanout.js

@@ -20,16 +20,10 @@ const { ERROR_CODES } = require('../utils/error-doc');
 // Task 0.5). writeWaveMetadata is re-exported below — fanout-retry.js and the
 // fanout tests import it from here.
 const { writeWaveMetadata, writeWaveDoc, finishWave, stampLegAttribution } = require('./fanout-wave-io');
-
-/**
- * Derive leg task IDs: <waveId>-1 .. <waveId>-N (matches TASK_ID_PATTERN).
- * @param {string} waveId
- * @param {number} count
- * @returns {string[]}
- */
-function deriveLegIds(waveId, count) {
-  return Array.from({ length: count }, (_, i) => `${waveId}-${i + 1}`);
-}
+// Leg-id derivation lives in ./leg-ids (v4.8 PR0 size-gate split).
+// deriveLegIds is re-exported below — mcp-server.js, fanout-retry.js and
+// the fanout tests import it from here.
+const { deriveLegIds } = require('./leg-ids');
 
 /**
  * Run a fan-out wave. Spec §4.3.

package/src/sidecar/leg-ids.js

@@ -0,0 +1,19 @@
+'use strict';
+// deriveLegIds — the <waveId>-<i+1> leg-id convention. Moved verbatim from
+// fanout.js:24-32 (v4.8 PR0 size-gate split, zero behavior; fanout.js was
+// 300/300). The shape is load-bearing: council stage-1 composes
+// `${runId}-s1` waves onto it, and ~10 suites plus a replay fixture
+// hard-code the composite. Pinned by tests/sidecar/fanout.test.js:84-93
+// through fanout.js's re-export.
+
+/**
+ * Derive leg task IDs: <waveId>-1 .. <waveId>-N (matches TASK_ID_PATTERN).
+ * @param {string} waveId
+ * @param {number} count
+ * @returns {string[]}
+ */
+function deriveLegIds(waveId, count) {
+  return Array.from({ length: count }, (_, i) => `${waveId}-${i + 1}`);
+}
+
+module.exports = { deriveLegIds };

package/src/sidecar/models-probe.js

@@ -17,7 +17,7 @@
  */
 
 /** Probe backstop override (spec D5) — a fixed constant, NOT env-configurable;
- * the env knob (AMICUS_NO_OUTPUT_BACKSTOP_MS) stays the ordinary 120s leg default. */
+ * the env knob (AMICUS_NO_OUTPUT_BACKSTOP_MS) stays the ordinary 300s leg default. */
 const PROBE_WINDOW_MS = 30000;
 
 /** Fixed tiny prompt — a probe leg only needs to prove the model answers at all. */
@@ -28,9 +28,12 @@ const PROBE_PROMPT = 'Reply with exactly: OK';
  * schema.js) per the plan's Global Constraints classification contract.
  * Precedence matters: 'complete' wins outright; otherwise a NO_OUTPUT_
  * BACKSTOP error (PR2's silent-leg detector, armed here at PROBE_WINDOW_MS
- * instead of its 120s default) is the one specific error shape that means
- * "the model accepted the request and never produced a token" rather than an
- * ordinary routing/auth/timeout failure.
+ * instead of its 300s default) is the one specific error shape that means
+ * NOTHING arrived in the window — no output, no reasoning, no tool call —
+ * rather than an ordinary routing/auth/timeout failure. ⚠️ It does NOT prove
+ * the model "accepted the request": a stalled gateway or a dropped connection
+ * fires the same backstop. `accepted-but-silent` names the classification, not
+ * a fact about the endpoint (council B1 on PR #182).
  * @param {{status?:string, error?:string|null}} leg
  * @returns {'served'|'accepted-but-silent'|'error'}
  */

package/src/sidecar/reopen-spend.js

@@ -0,0 +1,32 @@
+/**
+ * @module sidecar/reopen-spend
+ * Spend finalization for a REOPENED session (continue/resume). Split out of
+ * sidecar/continue.js to keep that file under the 300-line gate; resume.js was
+ * already reaching across for it, so the shared home is the honest one.
+ */
+
+'use strict';
+
+/**
+ * Resolve a reopened session's usage, write it onto metadata, and append one
+ * attributed ledger row. Mirrors start.js's finalize (the only sites that
+ * dropped usage - BACKLOG.md :: "continue/resume never compute per-run usage" — ⚠️ cited `BACKLOG.md:280` until T-A8 re-opened it 2026-08-17: `:280` is a docs/usage.md line, the entry is `:289`). Best-effort ledger append; never throws.
+ * @returns {{usage: object|null}}
+ */
+function finalizeSpendForReopen({ taskId, model, mode, op, result, status, project, metadata }, ctx = {}) {
+  const { resolveUsage } = require('../utils/pricing');
+  const usage = result && result.usage ? resolveUsage({ model, usageTotals: result.usage }) : null;
+  if (usage) {
+    metadata.usage = usage; // buildRunResult surfaces metadata.usage into the --json doc for free
+    try {
+      const { appendSpend } = require('../utils/spend-ledger');
+      const gateway = metadata.gateway || (String(model).startsWith('openrouter/') ? 'openrouter' : 'direct');
+      // v4.7.1 Task 7 D16: null-not-absent, the OPPOSITE convention from
+      // metadata.tag's absent-not-null (D13) — same `|| null` idiom as start.js:237.
+      appendSpend({ taskId, model, mode, usage, op, status, project, gateway, tag: metadata.tag || null }, ctx);
+    } catch { /* best-effort */ }
+  }
+  return { usage };
+}
+
+module.exports = { finalizeSpendForReopen };

package/src/sidecar/resume.js

@@ -251,7 +251,7 @@ async function resumeSidecar(options) {
     // v4.3: attribute resume spend (C9/E4). Reload metadata, write usage + append
     // a ledger row (status: statusFromResult, matching start.js — not terminal.status).
     {
-      const { finalizeSpendForReopen } = require('./continue');
+      const { finalizeSpendForReopen } = require('./reopen-spend');
       const { statusFromResult } = require('../utils/result-schema');
       const reloaded = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
       const { usage } = finalizeSpendForReopen({

package/src/sidecar/setup.js

@@ -51,7 +51,11 @@ function createDefaultConfig(defaultModel) {
   const cfg = {
     ...existing,
     default: existing.default || defaultModel,
-    aliases: { ...getDefaultAliases(), ...(existing.aliases || {}) },
+    // Same restatement as the readline gate below (fix round 3, G-2): a spread
+    // into `{}` re-materialises Object.prototype. `saveConfig` rebuilds this
+    // into its own literal anyway, so this one is defense in depth rather than
+    // a measured hole — recorded as such rather than claimed as a fix.
+    aliases: { __proto__: null, ...getDefaultAliases(), ...(existing.aliases || {}) },
   };
   saveConfig(cfg);
   logger.info('Default config ensured', {
@@ -128,7 +132,14 @@ function resolveChoice(input, picks, catalog) {
     return { modelId: input };
   }
   const cfg = loadConfig();
-  const aliases = { ...getDefaultAliases(), ...((cfg && cfg.aliases) || {}) };
+  // ⚠️ `__proto__: null` — v4.8 SI-22.4 fix round 3 (council G-2). `input` here
+  // is FREE-FORM readline text, and the gate below is `aliases[input] !==
+  // undefined`, so on a plain literal `toString` / `valueOf` / `constructor` /
+  // `hasOwnProperty` all measured TRUE and returned `{alias: input, noUpgrade:
+  // true}` — setup accepted them as existing aliases. Spreading a
+  // null-prototype object into a bare `{}` produces a PLAIN object again, so the
+  // curated-models fix does not reach this literal; the seed has to be restated.
+  const aliases = { __proto__: null, ...getDefaultAliases(), ...((cfg && cfg.aliases) || {}) };
   if (aliases[input] !== undefined) {
     return { alias: input, noUpgrade: true };
   }

package/src/utils/config.js

@@ -60,7 +60,16 @@ function saveConfig(configData) {
   if (configData && configData.aliases) {
     const cleaned = {};
     for (const [key, value] of Object.entries(configData.aliases)) {
-      if (key === 'null' || !value || typeof value !== 'string' || value === 'null') {
+      // `key === '__proto__'` — v4.8 SI-22.4 fix round 3 (council G-5). Without
+      // it the write below (`cleaned[key] = value`) hit Object.prototype's
+      // INHERITED `__proto__` setter, which ignores a string, so the alias
+      // vanished with NO "Removing invalid alias" notice — the only silent
+      // removal in this loop. Rejecting it explicitly puts it on the same
+      // footing as the `'null'` key beside it: same branch, same message.
+      // (No pollution was possible either way — only strings reach this line,
+      // and the setter ignores them — so this is an announcement fix, not a
+      // security one. Stated that way on purpose.)
+      if (key === 'null' || key === '__proto__' || !value || typeof value !== 'string' || value === 'null') {
         process.stderr.write(
           `Notice: Removing invalid alias '${key}' (value: ${JSON.stringify(value)}) from config.\n`
         );
@@ -78,7 +87,14 @@ function saveConfig(configData) {
 
 /** @returns {object} Copy of the default alias map */
 function getDefaultAliases() {
-  return { ...DEFAULT_ALIASES };
+  // ⚠️ `__proto__: null` must be RESTATED here, not inherited. A spread into a
+  // bare `{}` literal produces a plain object again, so fixing the builders in
+  // curated-models.js does NOT reach this copy — measured, not assumed. Its
+  // consumers index it: `sidecar/setup.js:479` (`getDefaultAliases()[alias]`)
+  // and `electron/setup-ui-aliases.js :: buildAliasEditorHTML`
+  // (`aliases[key] !== undefined`).
+  // Named mutant "BUILDERPROTO" covers this line too.
+  return { __proto__: null, ...DEFAULT_ALIASES };
 }
 
 /**
@@ -216,7 +232,44 @@ function checkConfigChanged(currentHash) {
 function getEffectiveAliases() {
   const config = loadConfig();
   const userAliases = (config && config.aliases) || {};
-  return { ...DEFAULT_ALIASES, ...userAliases };
+  // `__proto__: null` — v4.8 SI-22.4 fix round 2 (council B1). This table is
+  // read with BARE INDEXING by five gates, so on a normal object a member
+  // literally named 'toString' / 'constructor' / 'valueOf' / 'hasOwnProperty'
+  // resolved off Object.prototype to a truthy Function and was treated as a
+  // KNOWN ALIAS. Measured, not argued:
+  //   resolveModel('toString')                    -> the Function itself,
+  //       typeof 'function', where every caller expects a model-id STRING
+  //       (`:111` and `:142` gate on `!== undefined`, which a Function passes)
+  //   classifyCouncilMembers(['toString '], [])   -> ACCEPTED, i.e. runnable
+  // The SAME defect class this release already closed at other lookup tables —
+  // `tally.js :: VERDICTS`, `report.js :: SYMBOL`, `debate.js :: PAST_TENSE`
+  // (all `__proto__: null`), plus `street-cred.js :: perJudgeRank` and
+  // `report.js :: ROLE_SUFFIX` (both `Object.create(null)`, the same guarantee
+  // in the other spelling). The ALIAS table was not among them.
+  // ⚠️ SI-22.4 WIDENED it and that is why it is fixed here: at BASE the padded
+  // spelling ('toString ') missed the prototype and was correctly dropped;
+  // trimming before the lookup landed it on the inherited property. The
+  // unpadded spelling was already accepted, so restoring only the padded case
+  // would take more code AND deliberately preserve a known hole.
+  // ⚠️ Fixed HERE, not at the call sites — one line closes all five, each
+  // MEASURED at its own gate expression with `'toString'` (not inferred from
+  // this one): `resolveModel` `:111`/`:142` (`!== undefined` true→false) ·
+  // `classifyCouncilMembers` (accepted→dropped, end to end) ·
+  // `council/presets-cli.js:41` (`amicus council save`: unresolved false→true) ·
+  // `pack/pack-validate.js:71` (`seatOk` true→false) ·
+  // `utils/route-launch.js:205` (`isAlias` true→false).
+  // No consumer breaks: every reference either indexes (`aliases[key]`) or
+  // iterates own-enumerable keys (`Object.entries`/`Object.keys` —
+  // `buildProviderModels`, `formatAliasNames`, `mcp-tools.js :: getGuideText`,
+  // `sidecar/models.js :: aliasMarks`), and both behave identically on a
+  // null-prototype object. NOTHING calls a method ON the object — swept
+  // uncapped over `src/` and `electron/` for `aliases.<x>`, `in aliases`,
+  // `Object.values`, `JSON.stringify`, spread and `for…in`.
+  // A `__proto__` key inside the user's own config.json is copied as an ORDINARY
+  // own property by spread (never the setter), so the prototype stays null —
+  // measured on both a literal and a `JSON.parse`d source.
+  // Named mutant "PROTOALIASES": drop `__proto__: null` from the literal below.
+  return { __proto__: null, ...DEFAULT_ALIASES, ...userAliases };
 }
 
 /**
@@ -414,11 +467,42 @@ function getCouncilWithSource(name, catalog = []) {
  * at the last refresh; the leg itself fails pre-flight with the actionable
  * local_endpoint_unreachable error if it is truly down). Only a NON-EMPTY
  * catalog that omits the resolved id is a definitive drop.
- * @param {string[]} members raw council members (aliases or provider/model ids)
+ *
+ * WHITESPACE (v4.8 SI-22.4). Each member is TRIMMED before it is classified,
+ * closing a divergence: `--models` already trimmed
+ * (`sidecar/fanout-validate.js :: parseModelsList`, and `cli-council-run-bench.js
+ * :: parseList` on the council surface) while `--council` did not, so the same
+ * stray space was benign on one flag and, here, converted a typo into a dropped
+ * member and a degraded (2) exit. ⚠️ The dominant effect is RESURRECTION, not
+ * de-duplication: a padded member that is dropped today starts RUNNING, which
+ * is a new paid leg. Where the trim makes two members collide, the bench
+ * becomes a real twin and `seats.js :: buildSeats` mints `alias#N` for both.
+ * An all-whitespace member trims to `''`, which no alias table names, so gate 1
+ * below drops it — the `.filter(Boolean)` half of `parseModelsList`'s shape,
+ * reached without a third `reason` string (see the tripwire note below).
+ * @param {string[]} members council members as configured — aliases or
+ *   provider/model ids, trimmed per member here. ⚠️ This is the only place the
+ *   preset READ path trims — NOT the only place the preset path trims at all,
+ *   and NOT the only trim a member meets. The WRITE side already trimmed:
+ *   `council/presets-cli.js:34` (`amicus council save`) stores
+ *   `.split(',').map(m => m.trim()).filter(Boolean)`, and the only other writer
+ *   of `cfg.councils` in `src/` (`sidecar/setup.js:593`, the seeded `free`
+ *   council) composes its members from generated/existing alias KEYS, which
+ *   cannot carry user padding. So a padded member in `cfg.councils` comes from
+ *   a hand-edited `config.json`, and that is the case this trim serves.
+ *   Downstream, both council
+ *   surfaces re-join the expanded bench and re-parse it downstream —
+ *   `cli-handlers-fanout.js:91` → `:119` → `sidecar/fanout.js ::
+ *   validateFanoutModels` → `parseModelsList`, and `mcp-council-run.js:177` →
+ *   the spawned child's `cli-council-run-bench.js :: parseList` — so a member
+ *   that somehow kept padding past this point would still be trimmed there
  * @param {Array<{id:string}>} [catalog]
  * @returns {{models:string[], dropped:string[], droppedMembers:Array<{member:string, reason:string}>}}
  *   `dropped` is the flat member-ref list (unchanged shape, pre-v4.5-Wave-2
  *   callers keep working); `droppedMembers` additively pairs each with WHY.
+ *   ⚠️ Both report the member RAW — untrimmed, byte-for-byte as configured
+ *   (v4.8 SI-22.4, R22.4-2) — so a user can find the offending string in their
+ *   own config. Only `models` carries the trimmed value.
  *
  *   Standing note (D18, v4.7 PR5): each `droppedMembers` entry is `{member, reason}`
  *   (that is the real key — BACKLOG.md's description of this shape had drifted to
@@ -442,18 +526,29 @@ function classifyCouncilMembers(members, catalog = []) {
   const models = [];
   const dropped = [];
   const droppedMembers = [];
-  for (const member of members) {
+  for (const raw of members) {
+    // v4.8 SI-22.4. Trim BEFORE gate 1 below, never after: a padded ALIAS
+    // ('gpt ') must reach the alias table as written in the table, and a padded
+    // full id ('openai/gpt-5 ') must reach the catalog lookup clean. Trimming
+    // downstream of either gate would leave both misses in place. Non-strings
+    // pass through untouched so their `.includes` still throws exactly as it
+    // did before this line existed. Named mutant "NOTRIM": drop the `.trim()`.
+    const member = typeof raw === 'string' ? raw.trim() : raw;
     const id = member.includes('/') ? member : aliases[member];
+    // R22.4-2: `models` gets the TRIMMED value, `dropped`/`droppedMembers` get
+    // `raw` — a member still dropped after trimming is reported as the user
+    // wrote it, or they cannot grep their own config for it. Named mutant
+    // "TRIMDROPPED": report `member` instead of `raw` in the two drop branches.
     if (!id) { // alias no longer resolves
-      dropped.push(member);
-      droppedMembers.push({ member, reason: 'alias no longer resolves to a known model' });
+      dropped.push(raw);
+      droppedMembers.push({ member: raw, reason: 'alias no longer resolves to a known model' });
       continue;
     }
     const vendor = typeof id === 'string' ? id.split('/')[0] : '';
     if (isLocalProvider(vendor)) { models.push(member); continue; }
     if (known.size > 0 && !known.has(id)) { // delisted model
-      dropped.push(member);
-      droppedMembers.push({ member, reason: 'resolved id is not present in the cached model catalog' });
+      dropped.push(raw);
+      droppedMembers.push({ member: raw, reason: 'resolved id is not present in the cached model catalog' });
       continue;
     }
     models.push(member);
@@ -465,8 +560,11 @@ function classifyCouncilMembers(members, catalog = []) {
  * Expand a saved council into a runnable members list, degrading gracefully.
  * Unresolvable aliases and delisted ids are dropped with a warning rather than
  * fail-fast-aborting the whole wave (classification: classifyCouncilMembers
- * above). Returns members RAW (alias or id) — leg-time validation resolves
- * them again.
+ * above). Returns members UNRESOLVED (the alias or id as configured, never the
+ * id an alias maps to) — leg-time validation resolves them again. ⚠️ Not
+ * byte-identical to the configured string since v4.8 SI-22.4: classification
+ * trims each member, so `models[i]` is the configured member minus any
+ * surrounding whitespace. `dropped`/`droppedMembers` still carry it raw.
  *
  * Resolution order: user config (`config.councils`) is checked first; when
  * `name` is absent there, the built-in benches (`free`/`budget`/`frontier`)

package/src/utils/curated-models.js

@@ -111,6 +111,13 @@ const CARDLESS = [
   { alias: 'grok', routes: { openrouter: 'openrouter/x-ai/grok-4.3' } },
   { alias: 'kimi', routes: { openrouter: 'openrouter/moonshotai/kimi-k2.6' } },
   { alias: 'seed', routes: { openrouter: 'openrouter/bytedance-seed/seed-2.0-lite' } },
+  // inkling added 2026-08-14: the council-review workflow's default bench
+  // names it, and a workflow can only use aliases this table ships — a CI
+  // runner has no user config, so a locally-defined alias resolves to
+  // nothing there. Pinned to the full model, not `inkling-small`: the bench
+  // seat wants the flagship's judgment. `:batch` is deliberately not pinned
+  // (deferred completion is wrong for an interactive council leg).
+  { alias: 'inkling', routes: { openrouter: 'openrouter/thinkingmachines/inkling' } },
 ];
 
 /**
@@ -242,7 +249,14 @@ function directFormProvenance() {
  * without corrupting divergent-vendor ids (e.g. Anthropic's dash format).
  */
 function toGatewayRoutes() {
-  const out = {};
+  // `__proto__: null` — v4.8 SI-22.4 round 3 (G-1). Read by BARE INDEXING
+  // downstream, so a plain `{}` let an alias named 'toString'/'constructor'/
+  // 'valueOf'/'hasOwnProperty' resolve off Object.prototype to a truthy
+  // Function — including on the auto-repair path (`alias-resolver.js ::
+  // autoRepairAlias`), which `getEffectiveAliases`'s own fix could never reach.
+  // Full measurement + why THREE seeds were needed:
+  // tests/council/preset-trim-mutants.js :: BUILDERPROTO (the named mutant).
+  const out = { __proto__: null };
   for (const f of FAMILIES) { out[f.alias] = gatewayRoutesFor(f.vendorPath, f.fallback); }
   for (const e of CARDLESS) { out[e.alias] = gatewayRoutesFor(vendorOf(e.routes.openrouter), e.routes); }
   return out;
@@ -262,7 +276,8 @@ function toGatewayRoutes() {
  * shipped defaults.
  */
 function toDefaultAliases() {
-  const out = {};
+  // `__proto__: null` — see toGatewayRoutes above. Becomes DEFAULT_ALIASES.
+  const out = { __proto__: null };
   for (const [alias, routes] of Object.entries(toGatewayRoutes())) {
     out[alias] = routes.direct || routes.openrouter;
   }

package/src/utils/degrade.js

@@ -17,6 +17,11 @@ const DEGRADE_CHANNELS = Object.freeze(new Set([
   'dropped-members', 'chair-skipped-cost-ceiling', 'chair-failed',
   'thin-cross-review', 'debate-degraded', 'inexact-under-ceiling',
   'stage1-retry',
+  // v4.8: the seat<->leg join failed. THREE shapes, one channel: a launched seat whose wave
+  // returned legs but none its own; a returned leg matching no roster slot; and (T5.5, `-rv` only)
+  // a leg that DID match a slot but whose join key names no judge the wave launched.
+  // Never a guess — silent mis-attribution is the failure seat identity exists to kill (§4.4).
+  'seat-unbound',
   'internal',
   // doctor channels
   'doctor-check-failed', 'doctor-fix',

package/src/utils/doctor-engine-check.js

@@ -48,6 +48,38 @@ function evaluateEngineInstalls(d) {
 
   const broken = npxCopies.filter((i) => !i.engineOk);
   if (broken.length === 0) {
+    // Version skew (#133): a PRESENT engine can still be the wrong one. The
+    // npx copies and the global install resolve independently and at different
+    // times, and two versions writing one shared opencode.db is what produced
+    // #133's SQLiteError. Compare npx against global ONLY — a genuine source
+    // checkout's engine legitimately differs, so including it would fire red
+    // on every developer machine and in CI (E-1c). Unresolved versions never
+    // signal skew; absence of evidence is not evidence.
+    // WARN, never ERROR: doctor --fix has no skew branch, so an error would be
+    // unfixable, and this file already downgrades to warn at the ambiguous-npx
+    // branch below whenever the copy npx will select is ambiguous.
+    //
+    // Review round 2, finding 1: `kind === 'global'` alone is NOT the whole
+    // baseline. On the documented end-user invocation — `amicus doctor` run
+    // from the globally-installed copy — the running process IS the global
+    // install, so engine-install-scan.js's own dedup drops the separate
+    // `global` record and only `kind:'running'` survives, carrying
+    // `isGlobal: true` instead (see scanEngineInstalls). Without the
+    // `|| i.isGlobal` clause, the skew check was structurally unable to fire
+    // for exactly the users who filed #133. A TRUE source checkout (running,
+    // no isGlobal) is still excluded, as intended.
+    const globalV = (installs.find((i) => i.kind === 'global' || i.isGlobal) || {}).engineVersion;
+    const skewed = globalV
+      ? npxCopies.filter((i) => i.engineVersion && i.engineVersion !== globalV)
+      : [];
+    if (skewed.length > 0) {
+      const detail = skewed.map((i) => `${i.pkgDir} has ${i.engineVersion}`).join('; ');
+      return {
+        id, name, status: 'warn',
+        message: `engine version skew — global install has ${globalV}; ${detail}`,
+        hint: HINTS.engineVersionSkew,
+      };
+    }
     return {
       id, name, status: 'ok',
       message: `engine present in ${npxCopies.length} npx-cache ${plural(npxCopies.length, 'copy', 'copies')}`,