severally-mcp 2.0.0 → 2.3.1

package/README.md

@@ -6,27 +6,37 @@
 </h1>
 
 <p align="center">
-  <em>Independent opinions, returned severally. Your agent checks each one.</em>
+  <a href="https://github.com/coz-a/severally/actions/workflows/test.yml"><img src="https://github.com/coz-a/severally/actions/workflows/test.yml/badge.svg" alt="Test"></a>
 </p>
 
 <p align="center">English | <a href="README.ja.md">日本語</a></p>
 
-A plugin that gives your AI agent consultants: Codex, Claude Code, Antigravity and OpenCode.
+A plugin that lets your AI agent ask other coding agents for independent opinions, returned separately.
 
-When the agent gets stuck in an investigation, or faces two options that look equally good, it asks the
+The consultants are Codex, Claude Code, Antigravity and OpenCode. When the agent gets stuck in an investigation, or faces two options that look equally good, it asks the
 consultants for their opinions. It checks the findings that come back itself, and carries on from what it found.
-For an important decision, such as a change that is hard to reverse, it now consults before asking you to approve
-it, and asks you only about what is yours to decide. You can also ask yourself: "ask Codex".
+For an important decision, such as a change that is hard to reverse, it consults before asking you to approve it,
+and asks you only about what is yours to decide. You can also ask yourself: "ask Codex".
 
 The plugin puts the question to several independent consultants, and returns each one's answer on its own
 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)
@@ -34,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
@@ -121,13 +80,21 @@ What a consultant can read and do is under [What a consultant can see and do](#w
 
 ## Install
 
-You need Node.js 20.10 or newer and 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.
+### Requirements
+
+- 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.0.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
@@ -137,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:
@@ -146,7 +131,9 @@ 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.
+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
+[releases](https://github.com/coz-a/severally/releases).
 
 ### Uninstall
 
@@ -174,17 +161,21 @@ 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 costs a few minutes and real quota, so it is not for small fixes.
+same bug. One consultation takes minutes and real quota, so it is not for small fixes.
 
 ### When the answers come back
 
 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 a few minutes.
+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.
@@ -195,11 +186,11 @@ 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
-in total.
+in total. A follow-up to a fan-out asks every consultant in it again, each continuing its own exchange.
 
 ### History and records
 
@@ -211,14 +202,100 @@ 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,
+install OpenCode and add the model as a consultant: see
+[CONFIG.md](CONFIG.md#api-keys-and-other-model-families-through-opencode).
+
 ## What a consultant can see and do
 
 A consultation sends the brief to that CLI's model, the same way using the CLI yourself does. Your conversation
@@ -236,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).
 
@@ -255,22 +334,24 @@ 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:
 
-- `context.expose_paths`: files and directories, by absolute path, copied read-only for the consultant
+- `context.expose_paths`: files and directories, by absolute path, copied read-only for the consultant; a
+  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
+- `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
 
 Questions and bug reports go to [Issues](https://github.com/coz-a/severally/issues). Pull requests are welcome; for
-a large change, open an issue first so we can talk it over.
+a large change, open an issue first so we can talk it over. Everyone taking part is expected to follow the
+[Code of Conduct](CODE_OF_CONDUCT.md).
 
 - `npm install`, then `npm test`. The tests run offline against stand-in CLIs and make no real API calls.
 - After changing the source or the Skill template, run `npm run build`. The built server in

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` で変えられます。
 
 ## 記録
@@ -134,7 +136,9 @@ Antigravity にはツールを制限するフラグが無いので、Antigravity
 質問がリポジトリのコードについてなら、主担当は最初の依頼で、関係するファイルを絶対パスで指定して渡します
 （`expose_paths`）。テストの出力やログのようにファイルでないものはブリーフに入れます。ブリーフに貼った抜粋は、
 ファイルの代わりではなく、ファイルに添えるものです。指定したファイルとディレクトリは、読み取り専用で相談相手の作業
-ディレクトリ（`./workspace` の下）に写します。上限は、合わせて 20 項目、500 ファイル、5 MB です。シンボリックリンクは
+ディレクトリ（`./workspace` の下）に写します。上限は、合わせて 20 項目、500 ファイル、5 MB です。git の作業ツリーの中のディレクトリは、
+git が管理するファイル（追跡しているものと、`.gitignore` で外していない未追跡のもの）だけを写すので、リポジトリのルートも
+上限に収まります。git の外では `.git` と `node_modules` を飛ばします。シンボリックリンクは
 たどらずに飛ばし、テキストファイルはブリーフと同じように認証情報を伏せ字にして、バイナリファイルはそのまま写します。
 
 変更中のコードを見せるときは、代わりにリポジトリのパスを `expose_diff` で渡せます。差分（`HEAD`、または `base` に
@@ -151,3 +155,7 @@ Antigravity にはツールを制限するフラグが無いので、Antigravity
 今の内容で写し直します。前の回から変わったかどうかを項目ごとに SHA-256 で示し、無くなったパスは飛ばして名前を挙げます。前の回の
 `expose_diff` は、差分を取り直さず、差分が触ったファイルだけを写し直します。主担当がその呼び出しで指定しない限り、
 何も写し直しません。
+
+全員に聞いた相談への追加の質問（`followup_to` に `group_id` を渡す）は、全員に同じ新しい質問を送ります。それぞれの
+相談相手は、自分のやりとりの最新の答えから続けるので、ブリーフにはその相談相手自身の前の回が入ります。まだ動いている
+相談相手、答えの無い相談相手、回数を使い切った相談相手には送らず、`consult_start` の応答の `skipped` に理由とともに挙げます。

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
 
@@ -136,7 +138,9 @@ When the question is about code in your repository, the lead hands the files ove
 absolute paths (`expose_paths`); what is not a file there, such as a test's output or a log, goes in the brief,
 and an excerpt in the brief goes alongside the files rather than instead of them. Those files and directories are
 copied read-only into the consultant's working directory (under `./workspace`): at most 20 entries, 500 files
-and 5 MB in total; symlinks are skipped rather than followed; text files are credential-masked exactly as the
+and 5 MB in total. A directory inside a git work tree copies only the files git lists, tracked or untracked but
+not ignored, so a repository root fits; outside git, `.git` and `node_modules` are skipped. Symlinks are skipped
+rather than followed; text files are credential-masked exactly as the
 brief is, binary files are copied unchanged. For a change under review the lead can pass `expose_diff` with the
 repository's path instead: the diff (against `HEAD`, or a `base` revision) goes in the brief, cut to fit the
 brief's budget (20,000 characters at most), and every file it touches, untracked ones included, is copied under
@@ -150,3 +154,7 @@ directory with no files. When it needs the earlier round's files, the lead passe
 what that round exposed is copied again as it is now: each entry is marked changed or unchanged by its SHA-256, a
 path that no longer exists is left out and named, and an earlier `expose_diff` brings back the files it touched
 rather than a new diff. Nothing is copied again unless the lead asks for it in that call.
+
+A follow-up to a fan-out (`followup_to` its `group_id`) asks every member the same new question, each continuing
+its own chain from its latest answered round, so each brief carries that consultant's own earlier rounds. A member
+that is still running, never answered or has used its rounds is not asked, and the `consult_start` response lists it under `skipped` with the reason.

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>/` にバックアップします。バックアップの名前は元のパスから付けます。
 - 方式を切り替えると、もう一方の方式で残った重複の登録を、バックアップしてから取り除きます。
@@ -106,7 +113,7 @@ Codex、Antigravity、OpenCode からも使うなら、クローンしてイン
 
 ## 外に何も送らないツールの許可の確認を省く
 
-`consult_start` 以外の 5 つのツールは手元で完結します。`consult_get`（1 回の相談で何度も呼ぶ）、`consult_list`、
+`consult_start` 以外の 5 つのツールは手元で完結します。`consult_get`（相談が動いている間、繰り返し呼ぶ）、`consult_list`、
 `consult_cancel`、`consult_record`、`consult_export` です。どのクライアントにも許可リストに
 ツールを足すコマンドが無いので、インストーラは触りません。手で足してください。`consult_start` は確認を残します。
 ほかのベンダーに材料を送るのはこの呼び出しだからです。
@@ -132,6 +139,18 @@ Codex、Antigravity、OpenCode からも使うなら、クローンしてイン
 - **OpenCode** は、自分の `permission` の設定で変えていなければ、MCP ツールを確認なしで使います。
 - **Antigravity**: MCP ツールを 1 つずつ許可する規則の書き方を確かめていないので、ここでは扱いません。
 
+### 相談の開始の確認も省く
+
+エージェントは自分から相談します（相談するかどうかを訊かないよう Skill が指示しています）。そのため `consult_start` の
+確認を残すと、エージェントが始める相談のたびに 1 回あなたの確認を待ちます。この確認は、材料が手元を離れる前の
+唯一の歯止めなので、既定では残します。省くときは、上のツールと同じ書き方で `consult_start` も足します。
+Claude Code なら許可リストに `mcp__plugin_severally_severally__consult_start` を、Codex なら `config.toml` に
+`[mcp_servers.severally.tools.consult_start]` の表を書きます（`--manual` で登録した場合。プラグイン方式では確かめていません）。
+
+そうすると、どの相談でも次のものが、あなたに訊かずに各相談相手のモデルへ送られます。ブリーフ、渡したファイル、
+相談相手が実行中に読んだものです（[相談相手が読めるものとできること](../README.ja.md#相談相手が読めるものとできること)）。
+エージェントが触れるものがすべてそのベンダーに渡ってよい環境でだけ、省いてください。
+
 ## 更新
 
 `npx -y severally-mcp@latest install` を実行します。