severally-mcp 2.1.0 → 2.3.1

package/README.md

@@ -22,12 +22,21 @@ The plugin puts the question to several independent consultants, and returns eac
 instead of merging them into one, because a disagreement means something too. The agent checks why they disagree
 before deciding how to take the answers.
 
+Asked whether to cache a slow product page for five minutes, three consultants answered on their own
+(see [Example](#example) for the whole run):
+
+```
+codex        do_not_proceed  the price depends on the member's tier, so the first visitor's price is served to everyone
+claude-code  do_not_proceed  whoever fills the cache first sets the price everyone else sees for 5 minutes
+antigravity  alternative     member discounts leak to other users; fix the query and a cache may not be needed
+```
+
 ## Contents
 
-- [Example](#example)
-- [How it works](#how-it-works)
+- [Background](#background)
 - [Install](#install)
   - [Requirements](#requirements)
+  - [Command line](#command-line)
   - [Updating](#updating)
   - [Uninstall](#uninstall)
 - [Usage](#usage)
@@ -35,66 +44,15 @@ before deciding how to take the answers.
   - [When the answers come back](#when-the-answers-come-back)
   - [Modes](#modes)
   - [History and records](#history-and-records)
+- [Example](#example)
+- [Recommended setup](#recommended-setup)
 - [Configuration](#configuration)
 - [What a consultant can see and do](#what-a-consultant-can-see-and-do)
 - [API](#api)
 - [Contributing](#contributing)
 - [License](#license)
 
-## Example
-
-Here is how severally changes the way the agent works, shown in one situation: the agent comes up with a change,
-and before asking you to approve it, it asks the consultants for their opinions.
-
-The example is a small online shop's API. `GET /products/:id`, which serves the product page, is slow: about
-800 ms. The API loads each product joined with its inventory and its reviews. Prices depend on the member's tier,
-and gold members get a 10% discount.
-
-The agent, running in Claude Code, comes up with a common fix: "keep each response in an in-memory Map for 5
-minutes". Before asking you "can I go ahead?", it shows the plan to three consultants: Codex, Antigravity, and a
-fresh Claude Code session (a new session of the agent's own CLI, with none of its conversation). Along with the
-plan, it hands them read-only copies of the code involved. The answers come back one per consultant, side by side
-(excerpt from a real run against a sample API):
-
-```
-codex        do_not_proceed  the price depends on the member's tier, so keyed by product id alone, the first
-                             visitor's price is served to everyone; the join inflates stock; 4 workers keep
-                             separate copies, so an order that changes stock does not clear the old value
-claude-code  do_not_proceed  whoever fills the cache first sets the price everyone else sees for 5 minutes;
-                             4 workers each keep their own copy, so stock stays stale after orders; fix the
-                             join bug first too
-antigravity  alternative     member discounts leak to other users; the 800 ms comes from joining inventory
-                             and reviews, which also skews stock; rewrite the query and it is likely fast
-                             enough without a cache
-```
-
-Each answer opens with a bottom line: `proceed`, `do_not_proceed`, `alternative` (do something else instead) or
-`undetermined`. The three found the same problems, each on its own: the price leak, the inflated stock and the
-per-worker caches. Where they differ is what comes next. Codex and Claude Code recommend fixing the query and
-then caching only the part that does not depend on the user. Antigravity says that with the query fixed, a cache
-may not be needed at all. Merge the answers into one and that difference gets buried.
-
-The agent that asked (the *lead*) reads the findings and then checks them in its own repository. Of the two
-findings, one reproduced exactly; the other turned out not to be happening yet, and that changed the response.
-
-```
-finding   the query joins inventory and reviews together, so stock is multiplied by the number of reviews
-  checked   ran the query on a test database: 5 units in stock, 4 reviews -> stock comes out as 20
-  so        fix the query before any cache
-
-finding   a gold member's 10% discount would be served to guests
-  checked   login is not wired in yet, so today everyone gets the base price.
-            the leak starts the day login is added
-  so        cache only the product data that does not depend on the user, and compute the price on each request
-```
-
-What comes back to you is not a vote of "2 against, 1 alternative". It is what was checked, what the lead
-recommends, and what has not been checked yet. Here that is whether the fixed query is fast enough without a
-cache (it needs production-like data), and how stale the stock shown after an order may be (that one is yours to
-decide). You make the call. The checked results stay next to the findings and can be exported as Markdown into
-your repository (see [History and records](#history-and-records)).
-
-## How it works
+## Background
 
 ```mermaid
 flowchart TB
@@ -124,16 +82,19 @@ What a consultant can read and do is under [What a consultant can see and do](#w
 
 ### Requirements
 
-- Node.js 20.10 or newer
+- Node.js 22 or newer
 - At least one of the four CLIs, installed and logged in. One is enough: with only Claude Code, you can still ask a
   fresh Claude Code session.
 - On macOS and Linux, npm's global executable directory on `PATH`: the default install puts a `severally-mcp`
   command there for Codex to launch. `--manual` does without it.
 
+The installer and the server are tested on Linux, macOS and Windows; the Claude Code and Codex marketplace
+routes and the real CLIs have been tried on Linux only.
+
 One line, on macOS, Linux and Windows (PowerShell or Command Prompt):
 
 ```bash
-npx -y severally-mcp@2.1.0 install
+npx -y severally-mcp@2.3.1 install
 ```
 
 The installer registers severally with each CLI it finds on `PATH`. Add `--dry-run` at the end to print what it
@@ -143,6 +104,24 @@ registration.
 Installing from the Claude Code plugin marketplace or from a clone, checking the registration, and what the
 installer changes are in [docs/install.md](docs/install.md).
 
+### Command line
+
+```bash
+npx -y severally-mcp@latest install [--dry-run] [--manual] [--force] [--skip-global]
+```
+
+| Option | What it does |
+|---|---|
+| `--dry-run` | prints what it would change, and changes nothing |
+| `--manual` | registers the MCP server and copies the Skill instead of installing the plugin (the default on Windows) |
+| `--force` | registers again where severally is already registered, instead of leaving it as it is |
+| `--skip-global` | skips the global npm install in plugin mode, when `severally-mcp` on `PATH` is already this install |
+
+What each mode changes is in [docs/install.md](docs/install.md#two-install-modes).
+
+`npx -y severally-mcp@latest status` shows what is set up without starting a consultation: the config file, the
+consultants this machine can reach, the installed copies' versions and which clients have severally registered.
+
 ### Updating
 
 This line replaces your install with the latest version, with no version number to look up:
@@ -182,6 +161,9 @@ Ask in your own words, in the chat with your agent:
 - The agent also consults without being asked: when an investigation stalls, when two options look equally
   good, and before asking you to approve a hard-to-reverse change.
 
+What comes back to you is the lead's report, not the consultants' answers as they arrived: what it checked and
+what that showed, what it recommends, and what is still unverified. The [example](#example) shows one.
+
 It is worth it for important design decisions, hard-to-reverse choices, and two or more failed attempts at the
 same bug. One consultation takes minutes and real quota, so it is not for small fixes.
 
@@ -190,9 +172,10 @@ same bug. One consultation takes minutes and real quota, so it is not for small
 Starting a consultation does not make the agent wait: it can work on something that does not depend on the
 answers, which usually arrive within one to ten minutes (Antigravity is the slowest).
 
-Every answer has the same shape: a bottom line, findings with their grounds, what the consultant could not
-determine, conditions that would change its judgement, and how to check. A consultant that fails comes back as a
-failure with the reason (`usage_limit`, `timeout` …), never as "no problems found".
+Every answer is asked for in the same shape: a bottom line, findings with their grounds, what the consultant could
+not determine, conditions that would change its judgement, and how to check. When an answer leaves part of that
+out, such as the bottom line or the grounds for a finding, it says so in a caveat. A consultant that fails comes
+back as a failure with the reason (`usage_limit`, `timeout` …), never as "no problems found".
 
 The agent checks the findings that would change the decision itself, then tells you what it checked, what it did
 not adopt, and what is still unverified.
@@ -203,7 +186,7 @@ There are three modes, chosen from what the agent hands over. You can also ask f
 Codex").
 
 - `explore`: asks without showing the plan, so the consultant answers with its own approach first
-- `review`: shows the plan and asks what is wrong with it (the example above)
+- `review`: shows the plan and asks what is wrong with it (the [example](#example))
 - `debate`: shows the plan with the opposing claims, and asks the consultant to weigh them
 
 After the first answer, the agent can send follow-ups to the same consultant: up to four by default, five rounds
@@ -219,12 +202,94 @@ repository.
 How to name consultants, how a consultation runs, and the records in detail are in
 [docs/how-it-works.md](docs/how-it-works.md).
 
+## Example
+
+Here is how severally changes the way the agent works, shown in one situation: the agent comes up with a change,
+and before asking you to approve it, it asks the consultants for their opinions.
+
+The example is a small online shop's API. `GET /products/:id`, which serves the product page, is slow: about
+800 ms. The API loads each product joined with its inventory and its reviews. Prices depend on the member's tier,
+and gold members get a 10% discount.
+
+The agent, running in Claude Code, comes up with a common fix: "keep each response in an in-memory Map for 5
+minutes". Before asking you "can I go ahead?", it shows the plan to three consultants: Codex, Antigravity, and a
+fresh Claude Code session (a new session of the agent's own CLI, with none of its conversation). Along with the
+plan, it hands them read-only copies of the code involved. The answers come back one per consultant, side by side
+(excerpt from a real run against a sample API):
+
+```
+codex        do_not_proceed  the price depends on the member's tier, so keyed by product id alone, the first
+                             visitor's price is served to everyone; the join inflates stock; 4 workers keep
+                             separate copies, so an order that changes stock does not clear the old value
+claude-code  do_not_proceed  whoever fills the cache first sets the price everyone else sees for 5 minutes;
+                             4 workers each keep their own copy, so stock stays stale after orders; fix the
+                             join bug first too
+antigravity  alternative     member discounts leak to other users; the 800 ms comes from joining inventory
+                             and reviews, which also skews stock; rewrite the query and it is likely fast
+                             enough without a cache
+```
+
+Each answer opens with a bottom line: `proceed`, `do_not_proceed`, `alternative` (do something else instead) or
+`undetermined`. The three found the same problems, each on its own: the price leak, the inflated stock and the
+per-worker caches. Where they differ is what comes next. Codex and Claude Code recommend fixing the query and
+then caching only the part that does not depend on the user. Antigravity says that with the query fixed, a cache
+may not be needed at all. Merge the answers into one and that difference gets buried.
+
+The agent that asked (the *lead*) reads the findings and then checks them in its own repository. Of the two
+findings, one reproduced exactly; the other turned out not to be happening yet, and that changed the response.
+
+```
+finding   the query joins inventory and reviews together, so stock is multiplied by the number of reviews
+  checked   ran the query on a test database: 5 units in stock, 4 reviews -> stock comes out as 20
+  so        fix the query before any cache
+
+finding   a gold member's 10% discount would be served to guests
+  checked   login is not wired in yet, so today everyone gets the base price.
+            the leak starts the day login is added
+  so        cache only the product data that does not depend on the user, and compute the price on each request
+```
+
+What comes back to you is not a vote of "2 against, 1 alternative". It is what was checked, what the lead
+recommends, and what has not been checked yet. Here that is whether the fixed query is fast enough without a
+cache (it needs production-like data), and how stale the stock shown after an order may be (that one is yours to
+decide). You make the call. The checked results stay next to the findings and can be exported as Markdown into
+your repository (see [History and records](#history-and-records)).
+
+## Recommended setup
+
+Register the strongest model of each vendor as a consultant, and do the everyday work on a cheaper model, such as
+Sonnet in Claude Code. Most of the work, such as editing code, running tests and searching, goes fine on the
+cheaper model. For the decisions where a wrong call costs the most, such as a design choice or a change that is
+hard to reverse, the lead asks the strongest models, each on its own. They spend quota only in those
+consultations, so most of the usage stays on the cheaper model, and the decisions that matter still get the
+strongest models' opinions.
+
+A `~/.severally/config.json` for this:
+
+```json
+{
+  "consultants": {
+    "opus": { "cli": "claude-code", "model": "claude-opus-5-5" },
+    "gpt": { "cli": "codex", "model": "gpt-6.1-sol" },
+    "gemini": { "cli": "antigravity", "model": "gemini-4-argon-high" }
+  }
+}
+```
+
+Model ids change as new models come out; replace them with the ones your CLIs offer. Consultants run at effort
+`high` unless you set `effort`, except on Antigravity, where the model name sets it (`gemini-4-argon-high`) and an
+`effort` key is a config mistake.
+
+Then start the lead on the cheaper model (`claude --model sonnet`, or `/model sonnet` in a running session). The
+lead consults on its own at the moments listed under [Asking](#asking), and you can ask it to ("ask everyone before
+we merge this"). Each consultant runs on its own CLI's login and quota.
+
 ## Configuration
 
 **No configuration needed by default.** At startup the server looks for the CLIs on `PATH`, and each one it finds
 becomes a consultant on its default model. To turn a CLI off or add consultants on other models, put a
 `~/.severally/config.json` in place. From a clone, `npm run init-config` writes a template. Every key is in
-[CONFIG.md](CONFIG.md), and [config.example.json](config.example.json) is a working example to copy from. Restart
+[CONFIG.md](CONFIG.md), and [config.example.json](config.example.json) is an example to adapt: its paths, models and notes are made up. Restart
 the client after changing it.
 
 To consult a model you reach with an API key (OpenRouter, or another OpenAI-compatible API) or a local model,
@@ -248,13 +313,15 @@ history is never sent. No consultant can:
 | Antigravity | yes (`view_file`) | blocked (tool hook) | none | no | yes, unless `network: "off"` |
 | OpenCode | yes (`read` / `glob` / `grep`) | blocked (permission rules) | none (its Code Mode `execute` is refused) | no | yes, unless `network: "off"` |
 
-Every consultant starts in an empty working directory, and the server does not tell it where your repository
-is. It can still read any file your user account can read, except the credential paths the table marks blocked.
+Every consultant starts in a working directory of its own that holds only copies of the files you handed it, and
+the server does not tell it where your repository is. It can still read any file your user account can read, except the credential paths the table marks blocked.
 Codex does not block by file name, so a `.env` in your repository is readable to it.
 
 **A consultant that can both read your disk and browse could carry what it read out in a URL**, for example if a
 page it opens tells it to. To prevent that, the agent passes `network: "off"`: every consultant in that round then
-has no web search or browsing. The brief, and whatever a consultant reads, still goes to that CLI's model.
+has no web search or browsing. To make that the rule for every consultation, set `"server": { "network": "off" }`
+in the [config file](CONFIG.md#server-wide-keys); a request cannot turn it back on. The brief, and whatever a
+consultant reads, still goes to that CLI's model.
 
 How each CLI is held to this is in [docs/how-it-works.md](docs/how-it-works.md#how-a-consultant-is-kept-to-reading).
 
@@ -267,9 +334,9 @@ it exposes, go to each consultant's model. Every argument is described in the to
 |---|---|
 | `consult_start` | Starts a consultation with one consultant (`target`) or several (`targets`), and returns a `job_id` or `group_id` at once |
 | `consult_get` | Waits for a consultation and returns its state or answer; with `ids`, just those points of the answer |
-| `consult_cancel` | Stops a consultation or a whole fan-out, and its consultant processes |
+| `consult_cancel` | Stops a consultation or a whole fan-out, and its consultant processes, also one another session started |
 | `consult_record` | Writes the lead's verdicts on an answer's points, and what the answer added |
-| `consult_list` | Lists recent consultations, with the usage each consultant reported |
+| `consult_list` | Lists recent consultations, earlier sessions' included, with the usage each consultant reported in this session |
 | `consult_export` | Returns a consultation, follow-ups and verdicts included, as Markdown |
 
 The arguments of `consult_start` that matter most:
@@ -278,7 +345,7 @@ The arguments of `consult_start` that matter most:
   directory in a git repository copies only the files git lists (nothing `.gitignore` excludes)
 - `context.expose_diff`: `{ repo, base? }`, a change in progress: the diff goes in the brief and the files it touches are copied
 - `network`: `"off"` takes web search and browsing away from every consultant in the round
-- `followup_to`: the `job_id` of the answer a follow-up continues, or a fan-out's `group_id` to ask every consultant in it again
+- `followup_to`: the `job_id` of the answer a follow-up continues, or a fan-out's `group_id` to ask every consultant in it again. A follow-up needs only this and `question`; the consultant, the mode and the earlier round's context carry over unless you pass them again
 
 ## Contributing
 

package/bin/severally-mcp.mjs

@@ -15,6 +15,9 @@ if (process.argv[2] === 'install') {
   }
   process.argv.splice(2, 1);
   await import(installer.href);
+} else if (process.argv[2] === 'status') {
+  const { status } = await import('../src/status.mjs');
+  process.exitCode = status();
 } else {
   main().catch((err) => {
     process.stderr.write(`severally: fatal: ${err?.stack ?? err}\n`);

package/config.example.json

@@ -0,0 +1,26 @@
+// Full key reference, and what each one does: CONFIG.md
+// This file exercises every clis and consultants key and some server keys; you do not need to
+// set them all -- most operators need only one or two. The paths, models and notes are made up:
+// replace them with your own.
+{
+  "server": { "max_rounds": 10, "timeout_ms": 900000 },
+  "clis": {
+    "codex": { "enabled": false, "note": "rate-limited until 15:00" },
+    "claude-code": {
+      "bin": "/opt/claude/bin/claude",
+      "args": ["--disallowedTools", "WebFetch"],
+      "env": { "HTTPS_PROXY": "http://proxy.internal:3128" }
+    },
+    "antigravity": { "bin": "/opt/agy/bin/agy" }
+  },
+  "consultants": {
+    "opus": { "cli": "claude-code", "model": "claude-opus-5-5", "effort": "max", "max_budget_usd": 5, "timeout_ms": 900000 },
+    "fable": { "cli": "claude-code", "model": "claude-fable-5-1" },
+    "sol": { "cli": "codex", "model": "gpt-6.1-sol" },
+    "gemini": { "cli": "antigravity", "model": "gemini-4-argon-high" },
+    "glm": { "cli": "opencode", "model": "zai-coding-plan/glm-5.3" },
+    "deepseek": { "cli": "opencode", "model": "opencode/deepseek-v4.1-flash-free", "enabled": false, "note": "trial ended" },
+    "nemotron": { "cli": "opencode", "model": "opencode/nemotron-3-ultra-free#", "vendor": "nvidia" }
+  },
+  "ranking": ["opus", "glm"]
+}

package/docs/how-it-works.ja.md

@@ -42,8 +42,8 @@ OpenCode    ──(skill)──> severally server ──> codex exec | claude -p
 - 相談の結果は、サーバを再起動したあとも、同じマシンで動くほかの severally のプロセスからも読めます。ほかのプロセスで
   実行中のものは実行中と返ります。終わる前にサーバがクラッシュや強制終了で止まったものは `interrupted` として返ります。
   サーバがふつうに終了したときは、実行中の相談を取り消しとして記録します。
-- 相談を取り消せるのは、それを実行しているプロセスだけです。ほかのプロセスから `consult_cancel` を呼ぶと、何も
-  止めなかったと返ります。
+- ほかの severally のプロセスから `consult_cancel` を呼ぶと、相談を実行しているプロセスへの取り消しの依頼を
+  残します。実行しているプロセスは 1 秒ごとにそれを確かめ、相談を止めます。
 - 主担当が自分では実行できない確認（ほかの人の答えが要るものなど）は、理由をつけてあなたに返します。
 - **あとで判断の理由を説明する必要がある決定**（インターフェース、移行、セキュリティ、並行処理）では、主担当は
   自分から、またはあなたに頼まれて、手順を足します。質問と成功の条件をはっきりさせ、課された制約と自分の仮定を
@@ -52,6 +52,8 @@ OpenCode    ──(skill)──> severally server ──> codex exec | claude -p
   ふつうの変更なので、ほかの変更と同じようにレビューします。
 - モードは、計画のない依頼が `explore`、計画のある依頼が `review`、計画と反対の主張がある依頼が `debate` になります。
   計画を含んだ最初の `explore` の依頼は、サーバが受け付けません。追加の質問は、元の相談のモードを引き継ぎます。
+  主担当が渡し直さない限り、ほかに渡したもの（相談相手、`network`、目的、制約、成功条件、事実、計画、反対の主張、
+  資料）も引き継ぎ、新しいブリーフに書き直して載せます。
   追加の質問の上限は、設定ファイルの `server.max_rounds` で変えられます。
 
 ## 記録

package/docs/how-it-works.md

@@ -43,8 +43,8 @@ OpenCode    ──(skill)──> severally server ──> codex exec | claude -p
 - A consultation stays readable after the server restarts, and from any other severally process on the machine.
   One still running elsewhere reads as running; one whose server stopped abruptly (a crash or a kill) before it
   finished comes back as `interrupted`; an ordinary shutdown records its running consultations as cancelled.
-- Only the process running a consultation can cancel it; `consult_cancel` from another one says that nothing
-  was signalled.
+- `consult_cancel` from another severally process leaves a request for the process running the consultation,
+  which checks once a second and stops it.
 - A check the lead cannot run itself, such as one that needs another person's answer, comes back to you with the
   reason.
 - **For decisions you will have to justify later** (interfaces, migrations, security, concurrency), the lead
@@ -55,7 +55,9 @@ OpenCode    ──(skill)──> severally server ──> codex exec | claude -p
   other.
 - A request with no plan is `explore`, one with a plan is `review`, and one with a plan and the opposing claims
   is `debate`. The server refuses a first `explore` request that contains the plan. A follow-up keeps the mode of
-  the consultation it continues. The follow-up limit is `server.max_rounds` in the config file.
+  the consultation it continues, and everything else it was given unless the lead passes it again: the
+  consultant, `network`, the objective, constraints, success criteria, facts, plan, opposing claims and supplied
+  material. The new brief restates them. The follow-up limit is `server.max_rounds` in the config file.
 
 ## Records
 

package/docs/install.ja.md

@@ -10,7 +10,7 @@ npx はパッケージを自分のキャッシュに取ってきて、そこか
 
 ## 必要なもの
 
-README に書いた Node.js 20.10 以降とログイン済みの CLI のほかに、次の条件があります。
+README に書いた Node.js 22 以降とログイン済みの CLI のほかに、次の条件があります。
 
 - macOS / Linux では、npm のグローバルな実行ファイルのディレクトリが `PATH` に入っていること。既定のプラグイン方式
   （下記）は、Codex が起動する `severally-mcp` コマンドをそこに入れます。`--manual` を付ければ不要です。
@@ -42,7 +42,11 @@ node scripts/install.mjs
 
 ## 登録の確かめ方
 
-クライアントを再起動したあと、それぞれが severally を認識しているかを確かめます。持っていない CLI の行は飛ばしてください。
+`npx -y severally-mcp@latest status` を実行すると、相談を始めずに、まとめて確かめられます。設定ファイルが正しいか、
+この機械から使える相談相手（使えないものはその理由）、入っている写しの版がそろっているか、どのクライアントに
+severally が登録されているかを表示します。CLI にログインしているかは確かめません。それは最初の相談で分かります。
+
+クライアントごとに自分で確かめるときは、再起動したあとに次を実行します。持っていない CLI の行は飛ばしてください。
 
 ```bash
 # macOS / Linux（プラグイン方式）
@@ -66,7 +70,7 @@ Claude Code だけで使うなら、クローンもインストーラも要り
 ```
 
 Claude Code を再起動し、`claude plugin details severally` で確かめます。プラグインはサーバを `node` で起動するので、
-Node.js 20.10 以降が `PATH` に入っている必要があります。ツールは `mcp__plugin_severally_severally__*` の名前で
+Node.js 22 以降が `PATH` に入っている必要があります。ツールは `mcp__plugin_severally_severally__*` の名前で
 現れます。この方法を実機で確かめたのは Linux だけです。
 
 Codex、Antigravity、OpenCode からも使うなら、クローンしてインストーラも実行します（[クローンから入れる](#クローンから入れる)を参照）。
@@ -94,8 +98,11 @@ Codex、Antigravity、OpenCode からも使うなら、クローンしてイン
 - プラグイン方式では、npm のグローバルなインストールも行います。これで、Codex が起動する `severally-mcp` コマンドが
   入ります。`--skip-global` を付けるとこの手順を飛ばしますが、`PATH` 上の `severally-mcp` がすでに写した runtime を
   指している場合しか受け付けません。手動方式ではグローバルなインストールは要りません。
-- クライアントの設定は、各 CLI のコマンド（`plugin add` / `mcp add`）だけで変えます。何かをする前に、各クライアントの
-  設定ファイル（`~/.claude.json`、`~/.codex/config.toml`、`~/.gemini/config/mcp_config.json` と
+- クライアントの設定は、各 CLI のコマンド（`plugin add` / `mcp add`）だけで変えます。例外は手動で登録する Codex で、
+  `config.toml` の `[mcp_servers.severally]` の表に `tool_timeout_sec = 660` の 1 行も書きます（Codex のプラグインと
+  同じ長い待ちにするためで、`codex mcp add` では設定できません）。表にすでに `tool_timeout_sec` があれば、その値を
+  残し、待ち時間もそれに合わせます。1 行を書けなければ、長い待ちなしで Codex を登録し、そう表示します。
+- 何かをする前に、各クライアントの設定ファイル（`~/.claude.json`、`~/.codex/config.toml`、`~/.gemini/config/mcp_config.json` と
   `~/.gemini/antigravity-cli/settings.json`、`~/.config/opencode/opencode.json(c)`）と既存の Skill のディレクトリを、
   `~/.severally/backups/<timestamp>/` にバックアップします。バックアップの名前は元のパスから付けます。
 - 方式を切り替えると、もう一方の方式で残った重複の登録を、バックアップしてから取り除きます。

package/docs/install.md

@@ -10,7 +10,7 @@ into that cache, so it can be cleared afterwards.
 
 ## Requirements
 
-Beyond Node.js 20.10 or newer and a logged-in CLI, as in the README:
+Beyond Node.js 22 or newer and a logged-in CLI, as in the README:
 
 - macOS/Linux: npm's global executable directory on `PATH`. The default (plugin mode, below) installs a
   `severally-mcp` command there for Codex to launch. `--manual` does without it.
@@ -42,7 +42,12 @@ run `npm run init-config` (see [Configuration](../README.md#configuration) in th
 
 ## Checking the registration
 
-After restarting the clients, check that each one sees severally. Skip the lines for CLIs you don't have:
+`npx -y severally-mcp@latest status` shows it all at once, without starting a consultation: whether the config
+file is valid, which consultants this machine can reach (and why the others cannot), whether every installed copy
+is the same version, and which clients have severally registered. It does not check that a CLI is logged in; the
+first consultation shows that.
+
+To check one client yourself, after restarting it. Skip the lines for CLIs you don't have:
 
 ```bash
 # macOS / Linux (plugin mode)
@@ -65,7 +70,7 @@ For Claude Code alone, no clone and no installer are needed. In Claude Code:
 /plugin install severally@severally
 ```
 
-Restart Claude Code and check with `claude plugin details severally`. Node.js 20.10 or newer must be on `PATH`,
+Restart Claude Code and check with `claude plugin details severally`. Node.js 22 or newer must be on `PATH`,
 since the plugin starts its server with `node`. The tools appear as `mcp__plugin_severally_severally__*`. This
 route has been tried on Linux only.
 
@@ -94,8 +99,12 @@ Windows. Pass `--manual` to use manual mode on macOS/Linux too.
 - In plugin mode it also runs a global npm install, which provides the `severally-mcp` command that Codex
   launches. `--skip-global` skips that step and is accepted only when `severally-mcp` on `PATH` already points
   at the copied runtime. Manual mode needs no global install.
-- It changes client settings only through each CLI's own commands (`plugin add` / `mcp add`). Before it does
-  anything, it backs up each client's settings file (`~/.claude.json`, `~/.codex/config.toml`,
+- It changes client settings only through each CLI's own commands (`plugin add` / `mcp add`), with one
+  exception: for a manually registered Codex it also writes one line, `tool_timeout_sec = 660`, into
+  `config.toml` under `[mcp_servers.severally]` (the same long wait the Codex plugin has; `codex mcp add` cannot
+  set it). An existing `tool_timeout_sec` there is kept, and the wait follows it. If the line cannot be written,
+  Codex is registered without the long wait and the installer says so.
+- Before it does anything, it backs up each client's settings file (`~/.claude.json`, `~/.codex/config.toml`,
   `~/.gemini/config/mcp_config.json` and `~/.gemini/antigravity-cli/settings.json`,
   `~/.config/opencode/opencode.json(c)`) and any existing Skill directory to `~/.severally/backups/<timestamp>/`,
   naming each backup after its original path.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "severally-mcp",
-  "version": "2.1.0",
+  "version": "2.3.1",
   "description": "A plugin that lets your AI agent ask other coding agents for independent opinions, returned separately.",
   "type": "module",
   "license": "Apache-2.0",
@@ -27,10 +27,12 @@
     "README.md",
     "README.ja.md",
     "CONFIG.md",
+    "config.example.json",
+    "CODE_OF_CONDUCT.md",
     "docs"
   ],
   "engines": {
-    "node": ">=20.10"
+    "node": ">=22"
   },
   "scripts": {
     "test": "node scripts/test.mjs",

package/plugins/severally/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "severally",
-  "version": "2.1.0",
+  "version": "2.3.1",
   "description": "Ask Codex, Claude Code, Antigravity or OpenCode for an independent opinion, review or structured debate, in a sandboxed child session that can read files and search the web but cannot edit files, change the system, or start other agents.",
   "author": {
     "name": "coz.a",

package/plugins/severally/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "severally",
-  "version": "2.1.0",
+  "version": "2.3.1",
   "description": "Ask Codex, Claude Code, Antigravity or OpenCode for an independent opinion, review or structured debate, in a sandboxed child session that can read files and search the web but cannot edit files, change the system, or start other agents.",
   "author": {
     "name": "coz.a",