amicus 4.5.3 → 4.6.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "amicus",
-  "version": "4.5.3",
+  "version": "4.6.0",
   "description": "Multi-model LLM Council + parallel AI window for Claude Code. Run structured council reviews across Gemini, GPT, DeepSeek and more — or fork a conversation to any model and fold the results back.",
   "author": {
     "name": "Christian Wagner"

package/CHANGELOG.md

@@ -3,6 +3,103 @@
 All notable changes to Amicus are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow semver.
 
+## [Unreleased]
+
+## [4.6.0] - 2026-08-02
+
+### Added (v4.6 milestone — the degrade announcement invariant, plans 1-4)
+
+- **The ten-channel degrade announcement contract.** A council run can no longer degrade its
+  exit code without announcing what was lost: every loss routes through one sink
+  (`src/council/run-degrade.js`, the only code allowed to flip `degraded.value` — enforced by a
+  source-scan invariant test) and lands with mandatory *what/why/effect* on stderr,
+  `run.json.degrades[]`, `verdict.json.degrades[]`, and the report's new **"What was lost"**
+  section, all rendered in one voice.
+- **`verdict.seatLoss` is now derived from the degrade records** (closes #84) — a dead critic
+  *leg* finally flips `criticSeated`, and `seatLoss` can no longer disagree with `degrades[]`.
+  The v4.5.2 seatLoss shape is unchanged (its tests passed byte-unedited).
+- **Stage-2 judge legs get `runStats` rows** (closes #83) — per-leg cost attribution for ~38%
+  of a run's spend that had none, judge-tagged in the report's cost table.
+- **`doctor` speaks the same language**: `doctor --json` gains additive `degrades[]`;
+  `doctor --fix` prints `Recovered:` lines for every repair; the engine hints state causes as
+  **unverified** instead of asserting an antivirus guess.
+- **The Workspace is discoverable from the CLI**: `watch` usage names `--ui` (closes #80), and
+  a CLI council run with Electron present prints how to open the live Workspace (closes #81 —
+  the silence half; auto-open parity remains a product decision).
+
+### Changed (v4.6 — deliberate behavior changes)
+
+- **A dropped preset member now degrades the run to exit 2 on every transport** (was: exit 0
+  with a `--json`-blind stderr notice). The loss is announced per-member with its reason.
+- **A shared-server acquisition failure now exits degraded (2)** (was: stderr + run.json only,
+  exit 0) — the per-wave fallback is the racy configuration and the run says so.
+- **Reported cost totals rise** for identical runs versus v4.5.x: judge legs now appear in
+  `runStats`. Consumers keying `runStats` by model must exclude `role: 'judge'` (as the
+  ledger's reliability join now does).
+- In-run degrade notices hedge the exit-code claim truthfully ("will exit degraded (2)");
+  `engineMissing`/`reinstallEngineAv` hint prose changed to the unverified voice (commands
+  byte-identical).
+
+### Fixed (v4.6)
+
+- **A dead Stage-1 leg was announced on no surface at all** (closes #85) — the only trace was
+  its absence from the stage entry's `taskIds`. Now named everywhere, with a regression pin.
+- **The Stage-5 verdict rebuild silently destroyed `seatLoss`/`degrades[]`** (closes #87) —
+  `tally.json` carries neither, so the decisions flow dropped both; now preserved from the run
+  folder's verdict the same way the chair's synthesis already was, on both CLI and MCP.
+- **`watch --ui` against an `--out-dir` run failed with a symptom, not a cause** (closes #82) —
+  the error now names the launch-directory pointer and the working invocation.
+
+### Fixed
+
+- **`/amicus:council` lost all of its frontmatter at load time.** `commands/council.md`'s
+  `argument-hint` value began with `[material, path, or URL] [...]`, which YAML reads as a flow
+  sequence followed by a second, unexpected `[` — the whole block failed to parse, so the command
+  loaded with empty metadata: no description, no argument hint, and `disable-model-invocation:
+  true` silently dropped (the command was model-invocable, the opposite of the intent). The value
+  is now single-quoted. Present since `3900429` (Phase 9a, 2026-07-02); `claude plugin validate
+  .claude-plugin/plugin.json` failed on it, non-strict, that entire time.
+- **The preflight that should have caught it was validating the wrong file.** With `.claude-plugin/`
+  holding both manifests, `claude plugin validate .` resolves the *marketplace* manifest and
+  reports `✔ Validation passed` without ever inspecting the plugin. `docs/DISTRIBUTION.md` §2 now
+  documents the path trap, prescribes `claude plugin validate .claude-plugin/plugin.json`, and
+  records why `--strict` is expected to fail here (the deliberately retained root-`CLAUDE.md`
+  warning).
+
+### Changed
+
+- **`tests/plugin-commands.test.js` now YAML-parses frontmatter** for `commands/council.md` and
+  both skills, asserting `description`, `argument-hint` (as a *string*), and
+  `disable-model-invocation: true` survive parsing. The previous
+  `expect(md).toContain('argument-hint:')` substring checks passed happily against a file that
+  could not parse. `yaml` added as a devDependency for this.
+
+## [4.5.4] - 2026-08-01
+
+### Fixed
+
+- **README: corrected a false claim about Electron and install channels.** The install section
+  said "the standalone Electron window is npm-only." That is not true — the Council Workspace
+  auto-open gate (`src/sidecar/workspace-auto-open.js`) keys on `client === 'code-local'` plus
+  Electron presence, **not** on install channel, so a plugin-channel user in Claude Code local
+  does get the window. Removed.
+
+### Changed
+
+- **README now leads with npm as the recommended install**, with a per-channel comparison table.
+  The accurate reason npm is preferable for the interactive experience: the plugin's MCP config
+  sets `AMICUS_SKIP_POSTINSTALL=1`, and `scripts/postinstall.js` returns early on that — *before*
+  `provisionElectron()`. So the plugin channel gets no `amicus` on `PATH` (every window-opening
+  command becomes an `npx` call), no Electron provisioning or cache-heal, no reachable
+  `amicus doctor --fix` when the GUI breaks, and a fresh npx cache directory on every release.
+  The plugin block keeps its genuine strengths — native registration and the slash commands the
+  npm paths don't have — alongside an accurate statement of the tradeoff.
+- **README documents the single-MCP-registration behavior** when both channels are installed.
+  Config, API keys, and session history are shared, but the MCP server is one registration named
+  `amicus` that resolves to whichever install registered most recently — so the copy the CLI runs
+  and the copy Claude's MCP tools run can differ. This is the #76 confusion; `amicus doctor`
+  reports the MCP launch path and `--fix` repairs that copy in place.
+
 ## [4.5.3] - 2026-08-01
 
 ### Fixed

package/README.md

@@ -169,26 +169,40 @@ Any flag you also type on that second line overrides just that value — a pack
 
 > **Two install channels — read this first.** Amicus ships two ways, and CLI commands look different in each:
 >
-> - **npm global** (`npm install -g amicus` or the install script) puts `amicus`/`am` on your `PATH`. Every `amicus <command>` example in this README works as written.
+> - **npm global** (`npm install -g amicus` or the install script) — **the recommended path.** Puts `amicus`/`am` on your `PATH`, so every `amicus <command>` example in this README works as written, and provisions the Electron GUI that the parallel window runs in.
 > - **Claude Code plugin** (`/plugin install amicus@bourbondog-amicus`) does **not** put a CLI on your `PATH`. CLI calls go through `npx -y amicus@latest <command>` instead — e.g. `amicus doctor` becomes `npx -y amicus@latest doctor`. In exchange, the plugin channel gets two things npm does **not**: the slash commands `/amicus:council` and `/amicus:sidecar`. **These are plugin-channel-ONLY — npm users don't get them** and drive the same skills by saying "council review this" / talking to Claude instead.
 >
+> See the [comparison table below](#1-install) for the full tradeoff — the short version is that npm is what you want for the interactive window, and the two can be installed side by side.
+>
 > **Convention used throughout this README:** plugin-channel users: prefix CLI examples with `npx -y amicus@latest` (skip the bare `amicus`/`am`). Individual code blocks are not duplicated per channel — this note is the one translation you need.
 
 ### 1. Install
 
-Pick whichever fits. Every path delivers the MCP server and both skills; the `amicus`/`am` CLI lands on your PATH with the **npm and install-script paths** (the plugin path runs the CLI on demand via `npx -y amicus@latest <command>`):
+Every path delivers the MCP server and both skills. They differ in what else you get:
 
-**As a Claude Code plugin** — the most native path if you use Claude Code:
+| | **npm / install script** | **Claude Code plugin** |
+|---|---|---|
+| `amicus` / `am` on your `PATH` | ✅ | ❌ — every call is `npx -y amicus@latest <command>` |
+| **Interactive Electron window** (`amicus start`, `watch --ui`) | ✅ provisioned at install | ⚠️ best-effort — see below |
+| Self-heal when the GUI breaks (`amicus doctor --fix`) | ✅ | ❌ no CLI to run it with |
+| MCP server + both skills | ✅ | ✅ |
+| Slash commands `/amicus:council`, `/amicus:sidecar` | ❌ | ✅ |
 
-```text
-/plugin marketplace add BourbonDog/amicus
-/plugin install amicus@bourbondog-amicus
-/reload-plugins
+---
+
+#### With npm — recommended
+
+The canonical path, and the one that gets you the full interactive experience (needs [Node.js](https://nodejs.org) ≥ 18):
+
+```bash
+npm install -g amicus
 ```
 
-Claude Code registers the MCP server and both skills for you — nothing to configure. It also gets you two slash commands the npm/install-script paths don't: **`/amicus:council`** (run a full council review) and **`/amicus:sidecar`** (fork a conversation to another model). (The plugin does not put `amicus` on your PATH — CLI calls go through `npx -y amicus@latest <command>`; the standalone Electron window is npm-only; and the first council/sidecar call downloads the OpenCode engine.)
+This is the path to pick unless you specifically want the plugin's slash commands. It puts `amicus`/`am` on your `PATH` — which is what the **parallel window** is driven by — and its postinstall provisions the Electron GUI, with `amicus doctor --fix` to repair it in place if anything goes wrong later.
+
+#### With the install script
 
-**With the install script** — macOS, Linux, or Windows (needs [Node.js](https://nodejs.org) ≥ 18):
+Same result as npm, one command — macOS, Linux, or Windows (needs [Node.js](https://nodejs.org) ≥ 18):
 
 ```bash
 # macOS / Linux
@@ -200,12 +214,26 @@ curl -fsSL https://raw.githubusercontent.com/BourbonDog/amicus/main/install.sh |
 irm https://raw.githubusercontent.com/BourbonDog/amicus/main/install.ps1 | iex
 ```
 
-**With npm** — the canonical path (needs [Node.js](https://nodejs.org) ≥ 18):
+#### As a Claude Code plugin
 
-```bash
-npm install -g amicus
+The most native *registration* path if you use Claude Code, and the only one with slash commands:
+
+```text
+/plugin marketplace add BourbonDog/amicus
+/plugin install amicus@bourbondog-amicus
+/reload-plugins
 ```
 
+Claude Code registers the MCP server and both skills for you — nothing to configure. You also get **`/amicus:council`** (run a full council review) and **`/amicus:sidecar`** (fork a conversation to another model), which the npm paths don't have.
+
+> **Know the tradeoff before you pick this.** The plugin does not put `amicus` on your `PATH`, so every CLI call goes through `npx -y amicus@latest <command>` — including the ones that open the interactive window. It also skips amicus's postinstall, which is what provisions and self-heals the Electron GUI. The window still works when Electron lands in the npx cache, and the Council Workspace still auto-opens on a council run from Claude Code — but nothing repairs it when Electron *doesn't* land, and each new release re-resolves into a fresh cache directory. **If you want the parallel window as a daily driver, install with npm.**
+>
+> (Also: the first council/sidecar call downloads the OpenCode engine.)
+
+**Running both is supported** — and is what you want if you like the slash commands *and* the window. Install with npm for the CLI and the GUI, then add the plugin for `/amicus:council`. Your config, API keys, and session history live outside either install and are shared automatically.
+
+> One thing to know if you do: the MCP server is a **single registration named `amicus`**, so it resolves to one install — whichever registered most recently, which is usually the plugin's `npx -y amicus@latest mcp`. That's harmless (both serve the same tools), but it means the copy your CLI runs and the copy Claude's MCP tools run can differ. `amicus doctor` reports the MCP launch path explicitly and `--fix` repairs that copy in place, so if a GUI or engine problem ever shows up in Claude but not in your terminal, that's the first thing to check.
+
 For the **npm** and **install-script** paths, a postinstall auto-configures everything — no manual registration:
 
 - Registers the **MCP server** in Claude Code and in Claude Desktop / Cowork, so the Amicus tools appear natively.
@@ -413,7 +441,7 @@ $ amicus status demo123 --json
   "taskId": "demo123",
   "status": "complete",
   "elapsed": "5m 0s",
-  "version": "4.5.3",
+  "version": "4.6.0",
   "model": "google/gemini-2.5-flash",
   "phase": "terminal"
 }

package/commands/council.md

@@ -1,6 +1,6 @@
 ---
 description: Run a structured multi-model LLM council review of the given material — wraps the second-opinion skill (independent reviews → anonymous cross-review → non-Claude chair verdict → accept/deny decisions).
-argument-hint: [material, path, or URL] [analysis request + criteria] [optional elements — e.g. "with a critic seat", "debate mode", "expert lenses", "chair verdict scale"]
+argument-hint: '[material, path, or URL] [analysis request + criteria] [optional elements — e.g. "with a critic seat", "debate mode", "expert lenses", "chair verdict scale"]'
 disable-model-invocation: true
 ---
 

package/docs/DISTRIBUTION.md

@@ -50,17 +50,36 @@ users only see a version bump when we bump it, not on every commit. Treat
 ### Preflight (run before every submission or major post-listing update)
 
 ```bash
-claude plugin validate . --strict
+claude plugin validate .claude-plugin/plugin.json    # the PLUGIN check — see the path trap below
+claude plugin validate .                             # the marketplace manifest (separate check)
 claude --plugin-dir .   # smoke: /amicus:council, /amicus:sidecar, /amicus:second-opinion, MCP tools
 npm test
 ```
 
-- `claude plugin validate . --strict` is the same structural check the
-  review pipeline runs; `--strict` promotes unrecognized-field warnings to
-  errors so nothing slips through that CI would later flag. It needs the
-  Claude Code CLI installed locally — it is **not** wired into this repo's
-  CI (runners have no `claude` auth), so `tests/plugin-manifest.test.js` is
-  the CI-side proxy for manifest completeness.
+- **Path trap — `claude plugin validate .` does NOT validate the plugin.**
+  This repo's `.claude-plugin/` holds *both* `marketplace.json` and
+  `plugin.json`; given `.`, the CLI resolves the marketplace manifest, prints
+  `Validating marketplace manifest:` / `✔ Validation passed`, and never looks
+  at the plugin, its commands, or its skills. Always pass
+  `.claude-plugin/plugin.json` explicitly for the plugin check — that is the
+  surface the review pipeline evaluates. (This masked a real defect for a
+  month: `commands/council.md` shipped an unparseable `argument-hint` from
+  2026-07-02 until 2026-08-01 while `.` reported clean. Read the first line
+  of the output — it names which manifest was actually checked.)
+- `claude plugin validate` is the same structural check the review pipeline
+  runs. It needs the Claude Code CLI installed locally — it is **not** wired
+  into this repo's CI (runners have no `claude` auth), so
+  `tests/plugin-manifest.test.js` and `tests/plugin-commands.test.js` are the
+  CI-side proxies. The latter now YAML-parses the command and skill
+  frontmatter (`yaml` is a devDependency for exactly this); substring
+  assertions like `toContain('argument-hint:')` cannot see a parse failure,
+  which is how the `council.md` defect passed CI.
+- **`--strict` is expected to FAIL here, by design.** It promotes the
+  root-`CLAUDE.md` warning ("not loaded as project context") to an error. The
+  plugin root is the repo root, and `CLAUDE.md` is this repo's development
+  context — we keep it deliberately. Use the non-strict run as the gate and
+  read the warning list by eye; a *new* warning is the signal, not the
+  `CLAUDE.md` one.
 - `claude --plugin-dir .` loads the plugin from the working tree so you can
   manually confirm `/amicus:council`, `/amicus:sidecar`, and
   `/amicus:second-opinion` all appear in the command picker exactly once,
@@ -68,10 +87,18 @@ npm test
 - `npm test` must be green, specifically `tests/plugin-manifest.test.js`
   and `tests/plugin-commands.test.js`.
 
-**Known current-tree preflight result (checked 2026-07-02, `p9/distribution`
-at a1bea3c):** `claude plugin validate . --strict` passes clean, exit 0.
-(History: `--strict` previously flagged an unknown `plugin.json → bugs`
-field; that field was removed in commit `4207485`, so the warning is gone.)
+**Known current-tree preflight result (checked 2026-08-01, on
+`fix/plugin-frontmatter-validation`):**
+`claude plugin validate .claude-plugin/plugin.json` → exit 0,
+`✔ Validation passed with warnings` (the one retained root-`CLAUDE.md`
+warning). With `--strict` → exit 1 on that same warning, as documented above.
+`claude plugin validate .` → exit 0 on the marketplace manifest.
+
+History of this line: it previously read "`claude plugin validate . --strict`
+passes clean, exit 0" as of 2026-07-02 — measured against the *marketplace*
+manifest via the path trap above, while the plugin itself had a hard
+frontmatter error in `commands/council.md`. Older still: `--strict` flagged an
+unknown `plugin.json → bugs` field, removed in commit `4207485`.
 
 ### Submit
 

package/docs/usage.md

@@ -443,7 +443,7 @@ $ amicus status demo123 --json
   "taskId": "demo123",
   "status": "complete",
   "elapsed": "5m 0s",
-  "version": "4.5.3",
+  "version": "4.6.0",
   "model": "google/gemini-2.5-flash",
   "phase": "terminal"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amicus",
-  "version": "4.5.3",
+  "version": "4.6.0",
   "mcpName": "io.github.BourbonDog/amicus",
   "description": "Multi-model LLM Council + parallel AI window for Claude Code. Run structured council reviews across Gemini, GPT, DeepSeek and more — or fork a conversation to any model and fold the results back.",
   "keywords": [
@@ -95,7 +95,8 @@
     "lint-staged": "^16.3.2",
     "puppeteer": "^24.36.0",
     "sharp": "^0.35.3",
-    "ws": "^8.19.0"
+    "ws": "^8.19.0",
+    "yaml": "^2.9.0"
   },
   "engines": {
     "node": ">=22.12.0"

package/schemas/council-run.schema.json

@@ -82,6 +82,26 @@
         "at": { "type": "string" }
       }
     },
+    "degrades": {
+      "description": "v4.6 Plan 1: every degrade/heal the sink announced — additive, written by run-degrade.js.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["kind", "channel", "what", "why", "effect"],
+        "properties": {
+          "kind": { "enum": ["degrade", "heal"] },
+          "channel": { "type": "string" },
+          "what": { "type": "string" },
+          "why": { "type": "string" },
+          "effect": { "type": "string" },
+          "remedy": { "type": "string" },
+          "data": {
+            "type": "object",
+            "description": "v4.6 Plan 2: optional structured facts for derivations (e.g. dead-leg {seat,status,reason}, dead-wave {waveId,models,reason}). Prose fields stay the human surface."
+          }
+        }
+      }
+    },
     "debate": {
       "type": "object",
       "properties": {

package/schemas/council-verdict.schema.json

@@ -205,6 +205,26 @@
         "criticRequested",
         "criticSeated"
       ]
+    },
+    "degrades": {
+      "description": "v4.6 Plan 2: what this run lost — copied verbatim from the sink at verdict assembly. Additive; absent on a clean run.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["kind", "channel", "what", "why", "effect"],
+        "properties": {
+          "kind": { "enum": ["degrade", "heal"] },
+          "channel": { "type": "string" },
+          "what": { "type": "string" },
+          "why": { "type": "string" },
+          "effect": { "type": "string" },
+          "remedy": { "type": "string" },
+          "data": {
+            "type": "object",
+            "description": "v4.6 Plan 2: optional structured facts for derivations (e.g. dead-leg {seat,status,reason}, dead-wave {waveId,models,reason}). Prose fields stay the human surface."
+          }
+        }
+      }
     }
   }
 }

package/schemas/doctor.schema.json

@@ -21,7 +21,29 @@
           "name": { "type": "string" },
           "status": { "type": "string" },
           "message": { "type": ["string", "null"] },
-          "hint": { "type": ["string", "null"] }
+          "hint": { "type": ["string", "null"] },
+          "fixed": { "type": "boolean" },
+          "fixDetail": { "type": "string" }
+        }
+      }
+    },
+    "degrades": {
+      "description": "v4.6 Plan 3: failed checks and --fix repairs in the shared degrade/heal vocabulary — additive, absent when clean.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["kind", "channel", "what", "why", "effect"],
+        "properties": {
+          "kind": { "enum": ["degrade", "heal"] },
+          "channel": { "type": "string" },
+          "what": { "type": "string" },
+          "why": { "type": "string" },
+          "effect": { "type": "string" },
+          "remedy": { "type": "string" },
+          "data": {
+            "type": "object",
+            "description": "v4.6 Plan 3: optional structured facts for derivations (doctor: {checkId}). Prose fields stay the human surface."
+          }
         }
       }
     }

package/src/cli-council-run-render.js

@@ -0,0 +1,51 @@
+// src/cli-council-run-render.js
+'use strict';
+
+/**
+ * @module cli-council-run-render
+ * Human-readable render of a finished `amicus council run` (the non-`--json`
+ * output path, v4.0 spec §4). Split out of cli-handlers-council-run.js (v4.6
+ * Plan 4 Task 2): that file sat at 298/300 lines and Plan 4 Task 3 adds the
+ * #81 Workspace notice, which needed the room. `renderRunHuman` is
+ * self-contained — no dependency on the handler's flag-parsing or engine
+ * dispatch — so it moves verbatim to its own leaf; the old home
+ * (cli-handlers-council-run.js) requires it back and re-exports it, so every
+ * existing import path keeps working unchanged.
+ */
+
+function renderRunHuman(run) {
+  const lines = [
+    `Council run ${run.runId}: ${run.status} (exit ${run.exitCode})`,
+    `  bench: ${(run.bench || []).join(', ')}  chair: ${run.chair}`,
+    `  dir:   ${run.options && run.options.outDir}`,
+  ];
+  // v4.4: a cost line that omits unpriced legs reads as the whole bill. The
+  // diagnosis measured council-wsgate02 printing $0.3720 for a run that really
+  // spent $0.9859. Say what we know, then say what we cannot know — and print
+  // the line even when NOTHING resolved (the old `typeof amount === 'number'`
+  // guard silently dropped it, so a fully unpriced run looked free).
+  const u = run.usage || null;
+  const unknownLegs = u && typeof u.unknownLegs === 'number'
+    ? u.unknownLegs
+    : (u && u.cost && u.cost.unpricedLegs) || 0;
+  // v4.4 Task 2: a fully-priced run can still be short. `council-wsgate01`
+  // printed an unqualified $0.2821 for a run that really spent $0.3036 — every
+  // leg `reported`, and 100% of the gap one unattributed `explore` child session.
+  const subtreeLegs = u && typeof u.subtreeUnknownLegs === 'number'
+    ? u.subtreeUnknownLegs
+    : (u && u.cost && u.cost.subtreeUnknownLegs) || 0;
+  if (u && u.cost && (typeof u.cost.amount === 'number' || unknownLegs > 0 || subtreeLegs > 0)) {
+    const known = typeof u.cost.amount === 'number' ? `$${u.cost.amount.toFixed(4)}` : '$0.0000';
+    const gaps = [];
+    if (unknownLegs > 0) { gaps.push(`${unknownLegs} leg(s) unknown`); }
+    if (subtreeLegs > 0) { gaps.push(`${subtreeLegs} leg(s) with unattributed subagent child-session spend`); }
+    const tail = gaps.length > 0
+      ? ` + ${gaps.join(' + ')} — real spend is at least this much`
+      : '';
+    lines.push(`  cost:  ${known} (${u.cost.source})${tail}`);
+  }
+  if (run.error) { lines.push(`  error: ${run.error.code}: ${run.error.message}`); }
+  return lines.join('\n') + '\n';
+}
+
+module.exports = { renderRunHuman };

package/src/cli-handlers-council-run.js

@@ -13,6 +13,10 @@ const path = require('path');
 const { failJson, buildErrorDoc, ERROR_CODES } = require('./utils/error-doc');
 const { validateTaskId } = require('./utils/validators');
 const { GATEWAY_MODES } = require('./utils/model-descriptor');
+// v4.6 Plan 4 Task 2: renderRunHuman moved to its own leaf (size gate); this
+// file re-exports it below so every existing require() of this path still
+// resolves it unchanged.
+const { renderRunHuman } = require('./cli-council-run-render');
 
 const CHAIR_DEFAULT = 'deepseek';
 
@@ -40,9 +44,9 @@ function sanitizeCouncilName(name) {
 
 /**
  * Resolve bench models from --models XOR --council (mirrors handleFanout).
- * Also returns `presetName` (v4.3 Task 3, spec §7.1): the trimmed --council
- * name when that branch was taken, else null — threaded into runCouncil's
- * `councilName` option so council ledger rows can be attributed to a preset.
+ * Also returns `presetName` (v4.3 Task 3, spec §7.1: trimmed --council name,
+ * else null) and `droppedMembers`: a preset's own drops, or — bare --models —
+ * the parsed `--dropped-members` MCP→child passthrough (v4.6 Plan 4 Task 4b).
  */
 function resolveBench(args, useJson) {
   const hasModels = typeof args.models === 'string' && args.models.trim();
@@ -68,54 +72,40 @@ function resolveBench(args, useJson) {
     if (expanded.error) {
       return { fail: failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `Error: ${expanded.error}` }) };
     }
-    if (expanded.dropped && expanded.dropped.length && !useJson) {
-      process.stderr.write(`Notice: dropped unavailable council member(s): ${expanded.dropped.join(', ')}\n`);
-    }
-    // v4.5 Wave 2: threaded into runCouncil's options — the ONLY prior signal
-    // was the stderr-only Notice above, which --json mode never even prints.
+    // v4.5 Wave 2 → Plan 4 Task 4: threaded into runCouncil's options — the
+    // sink now announces each dropped member, with reason, on every transport and surface.
     return { bench: expanded.models, presetName, droppedMembers: expanded.droppedMembers || [] };
   }
-  return { bench: parseList(args.models), presetName: null, droppedMembers: [] };
+  if (args['dropped-members'] === undefined) {
+    return { bench: parseList(args.models), presetName: null, droppedMembers: [] };
+  }
+  let dm; try { dm = JSON.parse(args['dropped-members']); } catch { dm = null; }
+  if (!Array.isArray(dm) || !dm.every(d => d && typeof d.member === 'string' && typeof d.reason === 'string')) {
+    return { fail: failJson(useJson, { code: ERROR_CODES.BAD_ARGS,
+      message: 'Error: --dropped-members must be a JSON array of {member, reason} entries' }) };
+  }
+  return { bench: parseList(args.models), presetName: null, droppedMembers: dm };
 }
 
-function renderRunHuman(run) {
-  const lines = [
-    `Council run ${run.runId}: ${run.status} (exit ${run.exitCode})`,
-    `  bench: ${(run.bench || []).join(', ')}  chair: ${run.chair}`,
-    `  dir:   ${run.options && run.options.outDir}`,
-  ];
-  // v4.4: a cost line that omits unpriced legs reads as the whole bill. The
-  // diagnosis measured council-wsgate02 printing $0.3720 for a run that really
-  // spent $0.9859. Say what we know, then say what we cannot know — and print
-  // the line even when NOTHING resolved (the old `typeof amount === 'number'`
-  // guard silently dropped it, so a fully unpriced run looked free).
-  const u = run.usage || null;
-  const unknownLegs = u && typeof u.unknownLegs === 'number'
-    ? u.unknownLegs
-    : (u && u.cost && u.cost.unpricedLegs) || 0;
-  // v4.4 Task 2: a fully-priced run can still be short. `council-wsgate01`
-  // printed an unqualified $0.2821 for a run that really spent $0.3036 — every
-  // leg `reported`, and 100% of the gap one unattributed `explore` child session.
-  const subtreeLegs = u && typeof u.subtreeUnknownLegs === 'number'
-    ? u.subtreeUnknownLegs
-    : (u && u.cost && u.cost.subtreeUnknownLegs) || 0;
-  if (u && u.cost && (typeof u.cost.amount === 'number' || unknownLegs > 0 || subtreeLegs > 0)) {
-    const known = typeof u.cost.amount === 'number' ? `$${u.cost.amount.toFixed(4)}` : '$0.0000';
-    const gaps = [];
-    if (unknownLegs > 0) { gaps.push(`${unknownLegs} leg(s) unknown`); }
-    if (subtreeLegs > 0) { gaps.push(`${subtreeLegs} leg(s) with unattributed subagent child-session spend`); }
-    const tail = gaps.length > 0
-      ? ` + ${gaps.join(' + ')} — real spend is at least this much`
-      : '';
-    lines.push(`  cost:  ${known} (${u.cost.source})${tail}`);
-  }
-  if (run.error) { lines.push(`  error: ${run.error.code}: ${run.error.message}`); }
-  return lines.join('\n') + '\n';
+/**
+ * Default real helpers; tests override via depsOverride (mirrors
+ * cli-handlers-spend.js's realDeps()/depsOverride convention).
+ */
+function realDeps() {
+  return {
+    // #81 (spec §2): same pure presence probe doctor's electron checks use (src/cli-handlers-doctor.js).
+    getElectronPath: () => require('./sidecar/interactive-process').getElectronPath(),
+  };
 }
 
-/** @param {object} args parsed CLI args @returns {Promise<number>} exit code */
-async function handleCouncilRun(args) {
+/**
+ * @param {object} args parsed CLI args
+ * @param {object} [depsOverride] test seam (getElectronPath)
+ * @returns {Promise<number>} exit code
+ */
+async function handleCouncilRun(args, depsOverride = {}) {
   const useJson = !!args.json;
+  const deps = { ...realDeps(), ...depsOverride };
 
   // v4.5 Task 12 (B7/F5): resolve --pack FIRST, above the Task-5 template
   // block, so a pack-filled args.template renders through that single
@@ -243,6 +233,17 @@ async function handleCouncilRun(args) {
   const { readCache } = require('./utils/model-catalog');
   const { runCouncil } = require('./council/run');
   const cfg = loadConfig() || {};
+
+  // #81 (spec §2): the GUI's existence was announced on NO surface from the
+  // CLI path — MCP launches auto-open, the CLI stayed silent. Auto-open
+  // parity is a product decision (deliberately not taken here); the SILENCE
+  // is the spec's to fix. Presence probe only — never launches. Placed here
+  // (runId/runDir already resolved, still before the engine await) so the
+  // notice is useful WHILE the run is live, not just after it finishes.
+  if (!useJson && deps.getElectronPath()) {
+    process.stderr.write(`Notice: the Council Workspace can render this run live — open it with: amicus watch ${runId} --ui\n`);
+  }
+
   const { exitCode, run } = await runCouncil({
     briefing: promptRes.prompt, models: bench, chair, critic, lenses,
     project, runId, runDir,

package/src/cli-handlers-council.js

@@ -8,7 +8,7 @@ const { sumWaveUsage, formatCost } = require('./utils/pricing');
 const { failJson, ERROR_CODES } = require('./utils/error-doc');
 const { buildReport } = require('./council/report');
 const { validateFindings, buildValidateDoc } = require('./council/findings');
-const { buildVerdict, readOverallVerdict, writeVerdictAtomic } = require('./council/verdict');
+const { buildVerdict, readOverallVerdict, readPriorVerdictSurfaces, writeVerdictAtomic } = require('./council/verdict');
 const {
   runSave: runCouncilSave,
   runList: runCouncilList,
@@ -169,8 +169,14 @@ function runVerdict(args, useJson) {
     // one of only two homes of the chair's synthesis (the other is
     // chair-output.md); tally.json carries no copy. Recover it from the RUN
     // folder — the tally's own directory, not `-o` — before rebuilding.
-    const overallVerdict = readOverallVerdict(path.dirname(path.resolve(tallyPath)), record.meta.runId);
-    verdict = buildVerdict(record, decisions, { overallVerdict });
+    const runDir = path.dirname(path.resolve(tallyPath));
+    const overallVerdict = readOverallVerdict(runDir, record.meta.runId);
+    // #87: tally.json carries neither seatLoss nor degrades — recover both from
+    // the run folder's verdict the same way the chair line is recovered.
+    const prior = readPriorVerdictSurfaces(runDir, record.meta.runId);
+    verdict = buildVerdict(record, decisions, { overallVerdict,
+      ...(prior.seatLoss ? { seatLoss: prior.seatLoss } : {}),
+      ...(prior.degrades ? { degrades: prior.degrades } : {}) });
   }
   catch (e) {
     return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `cannot build verdict: ${e.message}`,