severally-mcp 2.1.0 → 2.4.0

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,25 +82,56 @@ 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.4.0 install
 ```
 
 The installer registers severally with each CLI it finds on `PATH`. Add `--dry-run` at the end to print what it
 would change without changing anything. Then restart the clients: a running session does not reload the new
 registration.
 
+If you use only Claude Code, you can install from its plugin marketplace instead: run `/plugin marketplace add coz-a/severally`
+and then `/plugin install severally@severally` in Claude Code, and restart it. The one line above is the main route,
+since it registers every CLI it finds. Details are in
+[docs/install.md](docs/install.md#from-the-claude-code-plugin-marketplace).
+
+On macOS and Linux, the default install also runs `npm install -g` to put a `severally-mcp` command on `PATH`, which
+only Codex's plugin needs. If npm cannot install it globally (for example it needs sudo, or npm's global folder is
+not on `PATH`), the installer registers Codex directly instead and says so. Nothing else is needed.
+
 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] [--allow-local-tools]
+```
+
+| 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 |
+| `--allow-local-tools` | adds severally's five local tools to Claude Code's allow list without asking; `consult_start` still asks |
+
+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, which clients have severally registered and
+whether each CLI is logged in. The login check reads the CLI's own status command and sends no prompt; running out
+of quota is not checked, and the first consultation shows it.
+
 ### Updating
 
 This line replaces your install with the latest version, with no version number to look up:
@@ -152,8 +141,8 @@ npx -y severally-mcp@latest install
 ```
 
 With `@latest`, npx asks npm for the newest version every time, so an older copy it already has is not used.
-Then restart the clients. Installed from the Claude Code plugin marketplace: see
-[docs/install.md](docs/install.md#updating). What changed in each version is in the
+If Claude Code has severally from its plugin marketplace, the same line updates that copy too (details in
+[docs/install.md](docs/install.md#updating)). Then restart the clients. What changed in each version is in the
 [releases](https://github.com/coz-a/severally/releases).
 
 ### Uninstall
@@ -182,6 +171,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 +182,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 +196,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 +212,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 +323,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 +344,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 +355,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

@@ -1,6 +1,15 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-import { main } from '../src/server.mjs';
+
+// Checked before anything else loads, so an older Node says what to do
+// instead of failing somewhere inside the server or the installer.
+const major = Number(process.versions.node.split('.')[0]);
+if (major < 22) {
+  process.stderr.write(
+    `severally: Node.js 22 or newer is needed (this is ${process.versions.node}); update Node.js and run it again\n`,
+  );
+  process.exit(1);
+}
 
 // `npx -y severally-mcp@latest install` runs the installer, so installing and
 // updating name the package once. Only the npm package has the installer
@@ -10,12 +19,18 @@ import { main } from '../src/server.mjs';
 if (process.argv[2] === 'install') {
   const installer = new URL('../scripts/install.mjs', import.meta.url);
   if (!fs.existsSync(installer)) {
-    process.stderr.write('severally: this is the installed server, not the installer; run: npx -y severally-mcp@latest install\n');
+    process.stderr.write(
+      'severally: this is the installed server, not the installer; run: npx -y severally-mcp@latest install\n',
+    );
     process.exit(1);
   }
   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 {
+  const { main } = await import('../src/server.mjs');
   main().catch((err) => {
     process.stderr.write(`severally: fatal: ${err?.stack ?? err}\n`);
     process.exit(1);

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,10 +10,12 @@ npx はパッケージを自分のキャッシュに取ってきて、そこか
 
 ## 必要なもの
 
-README に書いた Node.js 20.10 以降とログイン済みの CLI のほかに、次の条件があります。
+README に書いた Node.js 22 以降とログイン済みの CLI のほかに、次の条件があります。
 
-- macOS / Linux では、npm のグローバルな実行ファイルのディレクトリが `PATH` に入っていること。既定のプラグイン方式
-  （下記）は、Codex が起動する `severally-mcp` コマンドをそこに入れます。`--manual` を付ければ不要です。
+- macOS / Linux では、npm のグローバルのフォルダについて必要なことはありません。既定のプラグイン方式（下記）は
+  `npm install -g` で、Codex のプラグインが起動する `severally-mcp` コマンドを `PATH` に置きます。npm がグローバルに
+  入れられないとき（たとえば sudo が要る、npm のグローバルのフォルダが `PATH` に無い）は、インストーラが代わりに
+  Codex を直接登録します。ほかに必要なことはありません。`--manual` を付ければ、このコマンドは要りません。
 - Windows では、PowerShell かコマンドプロンプトからネイティブに動きます。WSL は要りません。CLI は `PATH` と
   `PATHEXT` から探します（`.exe`、`.cmd`、`.bat`、空白を含むパスにも対応します）。
 
@@ -42,7 +44,15 @@ node scripts/install.mjs
 
 ## 登録の確かめ方
 
-クライアントを再起動したあと、それぞれが severally を認識しているかを確かめます。持っていない CLI の行は飛ばしてください。
+`npx -y severally-mcp@latest status` を実行すると、相談を始めずに、まとめて確かめられます。設定ファイルが正しいか、
+この機械から使える相談相手（使えないものはその理由）、入っている写しの版がそろっているか、どのクライアントに
+severally が登録されているか、各 CLI にログインしているかを表示します。ログインの確認は、各 CLI 自身の状態確認
+コマンドを読むだけで、プロンプトは送りません。Claude Code は `claude auth status`、Codex は `codex login status` です。
+OpenCode は `opencode auth list` で保存されている認証情報の数を見ます（環境変数のキーでも動くので、保存が無くても
+警告にとどめます）。Antigravity にはそうしたコマンドが無いので「not checked」と表示します。使用枠を使い切って
+いないかは確かめません。それは最初の相談で分かります。
+
+クライアントごとに自分で確かめるときは、再起動したあとに次を実行します。持っていない CLI の行は飛ばしてください。
 
 ```bash
 # macOS / Linux（プラグイン方式）
@@ -66,13 +76,14 @@ 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 からも使うなら、クローンしてインストーラも実行します（[クローンから入れる](#クローンから入れる)を参照）。
 インストーラはマーケットプレイス版を見つけると、Claude Code はそちらに任せます。マーケットプレイス版より先に
 インストーラを実行していた場合は、もう一度実行してください。そのままだと Claude Code が severally を二重に読み込みます。
-インストーラは、自分が以前に入れた Claude Code 用の写しと登録を、バックアップしてから取り除きます。
+インストーラは、自分が以前に入れた Claude Code 用の写しと登録を、バックアップしてから取り除きます。マーケットプレイス版が
+入ったあとは、同じインストーラの実行でそれも更新されます（[更新](#更新)を参照）。
 
 ## 2 つのインストール方式
 
@@ -91,30 +102,45 @@ Codex、Antigravity、OpenCode からも使うなら、クローンしてイン
 
 - サーバを依存パッケージごと `~/.severally/runtime/severally-mcp.mjs` に写します。どの登録も、クローンした
   フォルダではなく、この写しを指します。
-- プラグイン方式では、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` と
+- macOS / Linux のプラグイン方式では、runtime を `severally-runtime` というパッケージ名で npm のグローバルにも入れます。
+  これで、Codex のプラグインが起動する `severally-mcp` コマンドが入ります。以前のインストールが残した `severally-mcp`
+  という名前のグローバルなパッケージは、先に `npm uninstall -g severally-mcp` で取り除きます。npm がコマンドを
+  グローバルに入れられないとき、または `PATH` の先頭にないときも、インストーラは止まらず、代わりに Codex を直接
+  登録して、そう表示します。登録は `--manual` と同じ `codex mcp add` で、長い `consult_get` の待ちも同じです。
+  `--skip-global` を付けるとグローバルなインストールを飛ばしますが、`PATH` 上の `severally-mcp` がすでに写した
+  runtime を指している場合しか受け付けません。手動方式ではグローバルなインストールは要りません。
+- クライアントの設定は、各 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>/` にバックアップします。バックアップの名前は元のパスから付けます。
 - 方式を切り替えると、もう一方の方式で残った重複の登録を、バックアップしてから取り除きます。
 - Claude Code にマーケットプレイス版の severally がすでに入っていれば、Claude Code には登録しません。以前に
   インストーラが入れた Claude Code 用の写し（`~/.claude/skills/severally`）とユーザスコープの登録も取り除きます。
+  マーケットプレイス版の更新も行います（[更新](#更新)を参照）。
+- 最後に、Claude Code があり、`~/.claude/settings.json` が severally の手元で完結する 5 つのツールをまだ許可して
+  いなければ、足すかどうかを訊きます（次の節を参照）。このファイルのほかの部分は変えません。
 - Codex のマーケットプレイスのファイル `.agents/plugins/marketplace.json` は、このリポジトリから写します。
   公開されているマーケットプレイスは使いません。
 
 ## 外に何も送らないツールの許可の確認を省く
 
 `consult_start` 以外の 5 つのツールは手元で完結します。`consult_get`（相談が動いている間、繰り返し呼ぶ）、`consult_list`、
-`consult_cancel`、`consult_record`、`consult_export` です。どのクライアントにも許可リストに
-ツールを足すコマンドが無いので、インストーラは触りません。手で足してください。`consult_start` は確認を残します。
-ほかのベンダーに材料を送るのはこの呼び出しだからです。
+`consult_cancel`、`consult_record`、`consult_export` です。`consult_start` は確認を残します。ほかのベンダーに材料を
+送るのはこの呼び出しなので、インストーラも足しません。
 
 - **Claude Code**: Skill が、呼ばれたターンの間はこの 5 つを許可します（`allowed-tools`）。そのため相談のポーリングで
-  毎回は確認が出ません。代わりに Skill 自体の承認を 1 度求められます。後のターン（判定の記録や追加質問）でも省くには、
-  `~/.claude/settings.json` に書きます（プラグイン方式の場合。`--manual` では
-  `mcp__plugin_severally_severally__` を `mcp__severally__` に読み替えます）。
+  毎回は確認が出ません。代わりに Skill 自体の承認を 1 度求められます。後のターン（判定の記録や追加質問）でも省くために、
+  インストーラが足すかどうかを訊きます。インストールの最後に、Claude Code があり、`~/.claude/settings.json` が
+  この 5 つをまだ許可していなければ、端末で「Let Claude Code run ... without asking each time? [Y/n]」と訊きます
+  （既定は Y）。`--allow-local-tools` を付けると、訊かずに足します（スクリプトからのインストール向け）。端末が無く、
+  フラグも無いときは何も変えず、フラグを付けてやり直す方法を表示します。先に `settings.json` をバックアップし、
+  ほかの設定は残し、同じ規則を二重には足しません。規則の接頭辞は、プラグイン方式とマーケットプレイス版では
+  `mcp__plugin_severally_severally__`、手動方式では `mcp__severally__` です。手で足すときは、
+  `~/.claude/settings.json` に次を書きます（`--manual` では `mcp__plugin_severally_severally__` を
+  `mcp__severally__` に読み替えます）。
   ```json
   { "permissions": { "allow": [
     "mcp__plugin_severally_severally__consult_get", "mcp__plugin_severally_severally__consult_list",
@@ -132,6 +158,8 @@ Codex、Antigravity、OpenCode からも使うなら、クローンしてイン
 - **OpenCode** は、自分の `permission` の設定で変えていなければ、MCP ツールを確認なしで使います。
 - **Antigravity**: MCP ツールを 1 つずつ許可する規則の書き方を確かめていないので、ここでは扱いません。
 
+インストーラは、Codex・Antigravity・OpenCode の許可には触りません。
+
 ### 相談の開始の確認も省く
 
 エージェントは自分から相談します（相談するかどうかを訊かないよう Skill が指示しています）。そのため `consult_start` の
@@ -154,11 +182,15 @@ Claude Code なら許可リストに `mcp__plugin_severally_severally__consult_s
 クローンしたフォルダそのものを登録していた古いバージョンで入れた場合は、一度だけ `--force` を付けてください。既存の登録が、
 写した runtime を指すように切り替わります。付けなければ、既存の登録はそのまま残ります。
 
-マーケットプレイスから入れた場合は、Claude Code で `/plugin marketplace update severally` を実行してから再起動します。
+マーケットプレイスから入れた場合は、Claude Code にマーケットプレイス版の severally がすでに入っていれば、インストーラが
+`claude plugin marketplace update severally` と `claude plugin update severally@<マーケットプレイス名>` も実行します。
+そのため `npx -y severally-mcp@latest install` を 1 回実行すれば、すべての写しが同じバージョンになります。失敗したときは、
+Claude Code の中で実行するコマンド `/plugin marketplace update severally` を表示します。そのあと Claude Code を
+再起動してください。Claude Code だけなら、インストーラの代わりにこのコマンドを自分で実行しても構いません。
 自動の更新は既定では無効です。有効にするには、`/plugin` の Marketplaces で severally を選び、Enable auto-update を
-選びます。Codex、Antigravity、OpenCode からも使っている場合は、インストーラも実行し直してください。この 3 つは
-`~/.severally/runtime` にある別の写しを使い、どちらの写しも同じ `~/.severally/config.json` を読みます。設定の書き方が
-変わるリリースでは、両方を同じバージョンにそろえてください。`~/.severally/runtime` か `~/.claude/skills/severally` の
+選びます。Codex、Antigravity、OpenCode は `~/.severally/runtime` にある別の写しを使い、どちらの写しも同じ
+`~/.severally/config.json` を読みます。インストーラが両方を同じバージョンにそろえます。設定の書き方が変わる
+リリースでは、これが大事になります。`~/.severally/runtime` か `~/.claude/skills/severally` の
 写しが、答えているサーバと違うバージョンなら、`consult_start` の応答の `stale_install` がそれを知らせます。中身は、
 それぞれの写しのバージョンと、そろえるためのコマンドです。
 
@@ -183,7 +215,8 @@ Remove-Item -LiteralPath "$HOME/.codex/skills/severally" -Recurse -Force
 Remove-Item -LiteralPath "$HOME/.gemini/config/skills/severally" -Recurse -Force
 Remove-Item -LiteralPath "$HOME/.config/opencode/skills/severally" -Recurse -Force
 Remove-Item -LiteralPath "$HOME/.severally/runtime" -Recurse -Force
-# 以前にグローバルなコマンドを入れていた場合だけ:
+# 以前にグローバルなコマンドを入れていた場合だけ（古い名前は以前のインストール用）:
+npm.cmd uninstall -g severally-runtime
 npm.cmd uninstall -g severally-mcp
 ```
 
@@ -201,7 +234,8 @@ rm -rf ~/.gemini/config/skills/severally
 # "mcp" オブジェクトから "severally" の項目を手で消す）:
 #   ~/.config/opencode/opencode.json(c) を編集する
 rm -rf ~/.config/opencode/skills/severally
-npm uninstall -g severally-mcp
+npm uninstall -g severally-runtime
+npm uninstall -g severally-mcp    # 以前のインストールが残していた場合だけ
 rm -rf ~/.severally/runtime ~/.severally/marketplace
 ```
 
@@ -215,7 +249,8 @@ agy    mcp remove severally
 # "severally" の項目を手で消す
 rm -rf ~/.claude/skills/severally ~/.codex/skills/severally ~/.gemini/config/skills/severally \
        ~/.config/opencode/skills/severally
-# 以前にグローバルなコマンドを入れていた場合だけ:
+# 以前にグローバルなコマンドを入れていた場合だけ（古い名前は以前のインストール用）:
+npm uninstall -g severally-runtime
 npm uninstall -g severally-mcp
 rm -rf ~/.severally/runtime ~/.severally/marketplace
 ```