severally-mcp 2.1.0 → 2.3.1

package/src/schema.mjs

@@ -6,7 +6,7 @@ import { z } from 'zod';
 import path from 'node:path';
 import {
   POLICY, CALLER_INPUTS, MODES, STANCES, artifactKinds,
-  resolveCaller, availableConsultants, consultantAvailable, unavailableReason,
+  resolveCaller, availableConsultants, consultantAvailable, unavailableReason, brokenConsultant,
 } from './policy.mjs';
 import { normalizeName, resolveConsultant } from './consultants.mjs';
 
@@ -42,10 +42,10 @@ const gitRevision = z.string().trim().min(1).max(200)
 
 export const contextSchema = z
   .object({
-    facts: z.array(trimmed(L.factMax, 'context.facts[]')).max(L.factsMax).default([]),
+    facts: z.array(trimmed(L.factMax, 'context.facts[]')).max(L.factsMax).optional(),
     proposal: z.string().trim().max(L.proposalMax).nullish(),
-    counterpoints: z.array(trimmed(L.counterpointMax, 'context.counterpoints[]')).max(L.counterpointsMax).default([]),
-    artifacts: z.array(artifactSchema).max(L.artifactsMax).default([]),
+    counterpoints: z.array(trimmed(L.counterpointMax, 'context.counterpoints[]')).max(L.counterpointsMax).optional(),
+    artifacts: z.array(artifactSchema).max(L.artifactsMax).optional(),
     expose_paths: z.array(exposedPathSchema).max(L.exposePathsMax).default([]),
     // The lead's uncommitted (or since-`base`) change: its diff goes in the
     // brief and the files it touches are copied, under workspace/repo/ at
@@ -55,6 +55,9 @@ export const contextSchema = z
     // round exposed. Never implied -- what reaches another vendor's model is
     // what the lead named in this call.
     expose_from_parent: z.boolean().optional(),
+    // Read as the request's own: a lead often nests them beside the facts.
+    constraints: z.array(trimmed(L.constraintMax, 'context.constraints[]')).max(L.constraintsMax).optional(),
+    success_criteria: z.array(trimmed(L.constraintMax, 'context.success_criteria[]')).max(L.constraintsMax).optional(),
   })
   .strict();
 
@@ -100,13 +103,13 @@ export const requestSchema = z
     // "off" takes web search and browsing away from every consultant in this
     // round, for a brief that must not leave the machine through a URL. The
     // consultant still reads the brief and the disk; it reaches nothing else.
-    network: z.enum(NETWORK_MODES).default('on'),
+    network: z.enum(NETWORK_MODES).optional(),
     question: trimmed(L.questionMax, 'question'),
     // Optional: most consultations state what they are after in the question
     // itself, and a second field that repeats it is friction, not information.
     objective: trimmed(L.objectiveMax, 'objective').nullish(),
-    success_criteria: z.array(trimmed(L.constraintMax, 'success_criteria[]')).max(L.constraintsMax).default([]),
-    constraints: z.array(trimmed(L.constraintMax, 'constraints[]')).max(L.constraintsMax).default([]),
+    success_criteria: z.array(trimmed(L.constraintMax, 'success_criteria[]')).max(L.constraintsMax).optional(),
+    constraints: z.array(trimmed(L.constraintMax, 'constraints[]')).max(L.constraintsMax).optional(),
     // prefault, not default: zod 4 returns a default as is, skipping the inner defaults (expose_paths among them).
     context: contextSchema.prefault({}),
     // Written by the lead before the consultant is launched, kept on this
@@ -157,6 +160,21 @@ export function parseRequest(raw, { isFollowup = false, parentMode = null, group
     throw new RequestError(`request failed validation: ${issues.join('; ')}`, 'invalid_request', issues);
   }
   const req = parsed.data;
+  // Left without a default in the schema, so that a follow-up can tell a list
+  // it left out (inherited from the round before, jobs.mjs) from one it
+  // emptied on purpose: the tool layer applies the schema's defaults first.
+  for (const k of ['constraints', 'success_criteria']) {
+    if (req.context[k] === undefined) continue;
+    if (req[k] !== undefined) {
+      throw new RequestError(`pass ${k} once: at the top of the request or inside context, not both`, 'invalid_request');
+    }
+    req[k] = req.context[k];
+    delete req.context[k];
+  }
+  req.network ??= 'on';
+  req.success_criteria ??= [];
+  req.constraints ??= [];
+  for (const k of ['facts', 'counterpoints', 'artifacts']) req.context[k] ??= [];
   const hasSingle = req.target !== undefined && req.target !== null;
   const hasMany = Array.isArray(req.targets) && req.targets.length > 0;
   if (hasSingle && hasMany) {
@@ -192,6 +210,9 @@ export function parseRequest(raw, { isFollowup = false, parentMode = null, group
     chosen = named.map((name) => {
       let r = resolveConsultant(name, reachable, POLICY.ranking);
       if (r.none) r = resolveConsultant(name, POLICY.consultants, POLICY.ranking);
+      if (r.none && brokenConsultant(name)) {
+        throw new RequestError(`consultant ${JSON.stringify(name)} is not available: ${brokenConsultant(name)}; available: ${listed()}`, 'target_unavailable');
+      }
       if (r.none) {
         throw new RequestError(`no consultant answers to ${JSON.stringify(name)}; available: ${listed()}`, 'unknown_target');
       }
@@ -278,7 +299,8 @@ export function parseRequest(raw, { isFollowup = false, parentMode = null, group
   if (req.context.facts.length === 0 && req.context.artifacts.length === 0 && req.context.expose_paths.length === 0
     && !req.context.expose_diff && !req.context.expose_from_parent) {
     throw new RequestError(
-      'provide at least one entry in context.facts, context.artifacts or context.expose_paths: the consultant starts in an empty working directory and is not told where your repository is, so every fact it needs must be in the request',
+      'provide at least one entry in context.facts, context.artifacts or context.expose_paths: the consultant starts in an empty working directory and is not told where your repository is, so every fact it needs must be in the request'
+        + (isFollowup ? '; on a follow-up, context.expose_from_parent: true copies again the files the earlier round was shown' : ''),
       'context_required',
     );
   }

package/src/server.mjs

@@ -4,12 +4,12 @@ import path from 'node:path';
 import { z } from 'zod';
 import { McpServer } from '@modelcontextprotocol/server';
 import { serveStdio } from '@modelcontextprotocol/server/stdio';
-import { POLICY, VERDICTS, availableConsultants, configProblem, limitsSummary } from './policy.mjs';
+import { POLICY, VERDICTS, availableConsultants, configProblem, configWarnings, limitsSummary } from './policy.mjs';
 import { requestSchema, RequestError } from './schema.mjs';
 import { JobManager, pointsOf } from './jobs.mjs';
 import { exportChain, ExportError } from './export.mjs';
 
-export const SEVERALLY_VERSION = '2.1.0';
+export const SEVERALLY_VERSION = '2.3.1';
 
 // consult_get waits this long when no wait_ms is given: a call that forgot it
 // would otherwise return at once and be repeated. Up to 45 s, under the 60 s
@@ -70,87 +70,53 @@ Budget is 1 initial round plus at most ${POLICY.maxRounds - 1} follow-ups per ch
 spent only on the specific points where you and the consultant actually diverge. Agreement is not evidence:
 check the grounds behind a point before you adopt it, and record what you adopted, rejected or held, and why.`;
 
-const startDescription = `Start a consultation with another agent (or several, via targets). Returns a job_id (or a group_id for several) immediately; the work runs in the background.
+const startDescription = `Start a consultation with another agent (or several, via targets). Returns a job_id (or a group_id for several) at once; the work runs in the background.
 
 target: which consultant to ask. This machine can reach (name: CLI, model):
 ${availableConsultants().map((c) => `          ${c.name}: ${c.cli}, ${c.model}`).join('\n') || '          (none -- no consultant CLI is installed)'}
-        Pass the name the user used: a consultant's name, its CLI ("codex", "agy"), its vendor ("openai") or
-        its model ("glm", "claude opus", "gpt-6.1"). A name that fits several consultants goes to the
-        operator's ranking first, then to the higher tier (opus over sonnet) and the newer version; when
-        nothing separates them it is refused with the candidates -- ask the user which one, do not guess.
-        A consultant that is not listed above is refused up front, so do not retry it -- say which ones
-        are available instead.
-        Consulting your own CLI on a fresh session is encouraged -- it sheds this session's history and
-        drift -- and the result is marked as same lineage.
-targets: ask several consultants the same question at once (mutually exclusive with target, no duplicates).
-        targets: ["all"] asks every consultant listed above; "all" cannot be mixed with names.
-        Every member gets the byte-identical brief (on a follow-up, plus its own earlier rounds) and one
-        group_id; poll it with consult_get({ group_id }). Each member takes one slot of the concurrency cap,
-        and a fan-out that would go over it is refused before any member starts.
-        A follow-up (followup_to) to a job names that one consultant. followup_to a group_id, with no target or
-        targets, asks every member of that fan-out the same new question, each on its own chain from its latest
-        round; a member that is still running, never answered or has used its rounds is skipped and listed.
-caller: optional -- the CLI you are running in ("codex" / "claude-code" / "antigravity" / "opencode"), so the
-        server can annotate a same-vendor consultation.
-caller_model: optional -- the model you are running on (e.g. "claude-opus-5"), self-declared and never checked.
-        With it, a same-vendor caveat can say "same lineage, different model" and the record keeps who asked
-        whom; it never changes which model the consultant runs.
-initiator: optional -- "user" when the user asked for this consultation; leave it out when you started it
-        yourself. Self-declared, never checked, gates nothing; it lets the record tell the two apart.
-mode: optional. Left out, it is read from context: no proposal is explore, a proposal is review, a proposal
-        with counterpoints is debate; a follow-up keeps its chain's mode. To gather opinions without showing
-        yours, leave context.proposal empty.
-  explore - hand over objective/constraints/facts and withhold your own preferred solution, to get independent
-            options, alternative problem framings and blind spots. context.proposal MUST be empty on round 1.
-  review  - hand over your current proposal AND the reasoning behind it, to get weaknesses, counterexamples,
-            concrete improvements and the conditions under which it holds. context.proposal is required.
-  debate  - hand over the disputed point, your position (context.proposal), the other side's claims
-            (context.counterpoints) and the extra evidence, to get what would change the judgement, how to test
-            it, and which disagreements remain. Both are required.
-
-The consultant starts in an empty working directory and is not told where your repository is, so it sees your
-code only if you hand it over in this call. When the question is about code in a repository on this machine,
-name the files it is about by absolute path in context.expose_paths: those files and directories are copied
-read-only into its working directory (under ./workspace) and are then the only part of your repository it has.
-At most 20 entries, 500 files and 5 MB in total; symlinks and protected files are skipped rather than copied,
-and text files are credential-masked exactly as the brief is. A directory inside a git work tree copies only the
-files git lists (tracked, or untracked and not ignored), so a repository root fits; outside git, .git and
-node_modules are skipped. A follow-up starts in a fresh working directory
-with no files: pass context.expose_from_parent: true to copy again, as they are now, the paths the round it follows
-exposed (a changed or vanished entry is marked; an earlier expose_diff brings back the files it touched, not the
-diff), and add expose_paths for anything new. It is never implied: leave it off when the follow-up does not need them. Put the facts it needs into context.facts, and keep
-context.artifacts for what is not a file here (test output, a log); an excerpt there goes alongside the
-exposed files, not instead of them. For a change you are making, pass
-context.expose_diff: { repo: "<absolute repository path>", base?: "<revision, default HEAD>" } instead or as
-well: the diff goes in the brief and every file it touches is copied under ./workspace/repo/ at its repository
-path. Model, permissions, round count, timeout and size
-caps are fixed by this server and cannot be raised from a request.
-
-network: optional -- "on" (default) or "off". "off" takes web search and browsing away from every consultant
-        in this round: use it when the brief holds material that must not leave the machine through a URL.
-        Whatever the setting, consultants are refused credential and history paths (~/.ssh, cloud keys, other
-        tools' sessions, severally's own history, .env files) where the CLI can enforce it; each answer's
-        \`boundary\` says what held for that consultant.
-
-prediction: optional -- { expected, worry }: the bottom line you expect back and, in one sentence, what you are
-        most worried about. Stored with the consultation and NEVER sent to the consultant. It can only be
-        written here, before the consultant runs, so that afterwards you cannot rewrite what you thought
-        beforehand; consult_record takes the other half (reflection) once you have read the answer.`;
+        Pass the word the user used: a name, a CLI ("codex", "agy"), a vendor or a model ("claude opus"). One
+        that fits several, unresolved by the operator's ranking, tier and version, is refused with the
+        candidates (target_ambiguous); one not listed is refused (target_unavailable). Your own CLI on a fresh
+        session is a valid consultant, marked same lineage.
+targets: several consultants, the same question (not with target, no duplicates); targets: ["all"] is every
+        consultant listed above. Every member gets the byte-identical brief (a follow-up adds its own earlier rounds) and one group_id, for consult_get
+        and consult_cancel. A fan-out over the concurrency cap is refused before any member starts.
+followup_to: the job_id of the answer to continue, or a group_id to ask every member of that fan-out again
+        (each on its own chain; a member that cannot take one is skipped and listed). A follow-up needs only
+        followup_to and question: the consultant, mode, network, objective, constraints, success_criteria,
+        facts, proposal, counterpoints and artifacts are the earlier round's unless you pass them, and one you pass,
+        even empty, replaces it. Files are not carried over: context.expose_from_parent: true copies again,
+        as they are now, what the earlier round exposed. A job's follow-up cannot change the consultant.
+mode: optional, read from context when left out: no proposal is explore, a proposal is review, a proposal with
+        counterpoints is debate. review and debate need context.proposal (your plan and its reasoning); debate
+        also needs context.counterpoints (the other side's claims); explore refuses a proposal on round 1.
+context: the consultant starts in an empty working directory and is not told where your repository is, so
+        give it at least one of: facts, artifacts (material that is not a file here: test output, a log),
+        expose_paths (absolute paths copied read-only under ./workspace; a directory in a git work tree copies
+        the files git lists; at most 20 entries, 500 files, 5 MB; symlinks and protected files are skipped,
+        text is credential-masked like the brief), expose_diff: { repo, base? } (the diff in the brief, the
+        files it touches under ./workspace/repo/).
+network: "on" (default) or "off" (no web search or browsing for any consultant this round). Credential and
+        history paths are refused either way where the CLI can enforce it; each answer's \`boundary\` says what held.
+caller, caller_model: the CLI and model you run on (self-declared), for the same-vendor caveat and the record.
+initiator: "user" when the user asked for this; leave it out when you started it yourself.
+prediction: { expected, worry }, kept and never sent; it can only be written here, before the answer.
+Model, permissions, rounds, timeout and size caps are fixed by this server.`;
 
 // One consultation's record: the single form of consult_record, and each
 // element of its `records`.
 const recordShape = {
-  job_id: z.string().min(1).describe('the consultation to record against -- the job_id consult_get returned for it'),
+  job_id: z.string().min(1).describe('the job_id consult_get returned'),
   entries: z.array(z.object({
-    id: z.string().min(1).describe('the point this verdict is about: f1, u1, c1 ... as returned in the result'),
+    id: z.string().min(1).describe('f1, u1, c1 ... from the result'),
     verdict: z.enum(VERDICTS),
-    effect: z.string().max(4000).optional().describe('what it changed about your decision, or why it is still unverified'),
-    note: z.string().max(4000).optional().describe('what you checked and what you found'),
+    effect: z.string().max(4000).optional().describe('what it changed, or why it is unverified'),
+    note: z.string().max(4000).optional().describe('what you checked and found'),
   })).min(1).max(100).optional(),
   reflection: z.object({
-    delta: z.string().min(1).max(4000).describe('what the answer added over what you already expected -- including "nothing new", which is a real outcome'),
-    related_item_ids: z.array(z.string().min(1)).max(50).optional().describe('the points this is about: f1, u1, c1 ...'),
-  }).optional().describe('written after you have read the answer. There is deliberately no hit/miss label: a point you predicted can still arrive with the evidence that settles it, and a surprise can still be wrong.'),
+    delta: z.string().min(1).max(4000).describe('what the answer added over what you expected ("nothing new" counts)'),
+    related_item_ids: z.array(z.string().min(1)).max(50).optional().describe('f1, u1, c1 ...'),
+  }).optional().describe('written after reading the answer'),
 };
 
 export function createServer(manager = new JobManager()) {
@@ -192,24 +158,17 @@ export function createServer(manager = new JobManager()) {
       title: 'Get consultation status or result',
       annotations: { readOnlyHint: true, openWorldHint: false },
       description:
-        `Fetch the state of a consultation. It waits up to ${DEFAULT_WAIT_MS} ms for it to finish before ` +
-        'answering, a limit set to stay under this client\'s tool-call timeout; wait_ms sets another wait, and ' +
-        'wait_ms: 0 answers at once. While it waits it sends a progress notification every 15 s if you asked ' +
-        'for them, and a call you cancel stops waiting. A typical consultation takes one to ten minutes; call ' +
-        'this again while it runs, and pass a shorter wait_ms when you have independent work to do in between. ' +
-        'A completed job carries the structured ' +
-        'answer; a failed one carries failure.kind (timeout, auth, usage_limit, rate_limited, model_unavailable, ' +
-        'invalid_output, cli_error, spawn_error, interrupted) — that is "no advice was obtained", which is different from advice that arrived ' +
-        'with thin evidence (see quality.evidence_basis). ' +
-        'Pass group_id instead of job_id to fetch a fan-out; the wait then covers every consultant in it. ' +
-        'A fan-out comes back sized to read in one go: each member is its status, failure and job_id, and ' +
-        '`comparison.by_target` holds every consultant\'s stance, summary and findings (with their ids) side by ' +
-        'side, cut to fixed lengths where `truncated` says so. consult_get({ job_id, ids: ["f2", "u1"] }) on a ' +
-        'member returns just those points, each whole with its grounds and your verdict (`recorded`): fetch every point you ' +
-        'mean to adopt, that decides your call, that rests on thin grounds, or that every consultant assumes -- ' +
-        'not only where they diverge. consult_get({ job_id }) returns the whole answer. A finished ' +
-        'consultation names its brief (size, sha256, round file) rather than repeating it; detail: "full" ' +
-        'returns the brief, and for a fan-out every member\'s full answer.',
+        `Fetch a consultation's state or answer. It waits up to ${DEFAULT_WAIT_MS} ms (under this client's tool-call ` +
+        'timeout) for it to finish; wait_ms sets another wait, 0 answers at once. While waiting it sends a progress ' +
+        'notification every 15 s when asked; a cancelled call stops waiting. Most take one to ten minutes: call ' +
+        'again while status is running. completed carries the structured answer; failed carries ' +
+        'failure.kind (timeout, auth, usage_limit, rate_limited, model_unavailable, invalid_output, cli_error, ' +
+        'spawn_error, interrupted), meaning no advice was obtained -- not the same as advice with thin evidence ' +
+        '(quality.evidence_basis, quality.caveat). group_id fetches a fan-out: each member\'s status, failure and ' +
+        'job_id, and `comparison.by_target` with every stance, summary and finding id side by side, cut where ' +
+        '`truncated` says so. ids: ["f2", "u1"] with a job_id returns just those points, whole, with their grounds ' +
+        'and your verdict (`recorded`). A finished consultation names its brief rather than repeating it; detail: ' +
+        '"full" returns the brief, and for a fan-out every member\'s full answer.',
       inputSchema: z.object({
         job_id: z.string().min(1).optional(),
         group_id: z.string().min(1).optional(),
@@ -264,7 +223,8 @@ export function createServer(manager = new JobManager()) {
       annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: false },
       description:
         'Stop a running consultation and kill the consultant process and everything it spawned. ' +
-        'Pass group_id instead of job_id to stop every consultant in a fan-out.',
+        'Pass group_id instead of job_id to stop every consultant in a fan-out. One another severally server runs '
+        + 'is asked to stop, and that server stops it within a second.',
       inputSchema: z.object({
         job_id: z.string().min(1).optional(),
         group_id: z.string().min(1).optional(),
@@ -288,31 +248,21 @@ export function createServer(manager = new JobManager()) {
       title: 'Record what checking a point showed',
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description:
-        'Write your own verdict against one or more points of an answer, after you have checked them in the '
-        + 'repository. Ids come from the result: findings are f1, f2 ..., unknowns u1 ..., next_checks c1 ... . '
-        + 'verdict says what checking showed -- "confirmed" (it holds here), "not_applicable" (true in general, '
-        + 'not for this codebase), "unverifiable" (cannot be settled with what you can reach), "unverified" (not '
-        + 'checked yet, and say in effect why not). It does not say whether you adopted the point. effect is what '
-        + 'it changed about your decision; note is the evidence you used. A follow-up to this job shows the '
-        + 'consultant each point\'s verdict and effect (credential-masked, like the brief), never the note. '
-        + 'Recording the same id again replaces '
-        + 'that entry. This server stores what you write and counts the verdicts; it never infers one, and never '
-        + 'decides a consultation was worth it. The entry is saved beside the answer and the brief in '
-        + '~/.severally/history, which is what makes the decision readable a month from now; the job is '
-        + 'read back from that history, so a consultation from an earlier session can still be recorded against. '
-        + 'It answers with counts (the verdicts tallied, and how many points now carry one); consult_get reads '
-        + 'the entries back. Pass `reflection` to record what the answer added over what you already expected, when the '
-        + 'consultation was started with a `prediction`. A prediction itself cannot be written here: it goes '
-        + 'in consult_start, before the consultant runs, which is the only thing that makes it a prediction. '
-        + 'For a fan-out, record every member in one call: records: [{ job_id, entries, reflection? }, ...] in '
-        + 'place of job_id/entries/reflection. Every record is checked first; if any job or id is wrong, nothing is '
-        + 'written and each bad one is named. A job whose write fails is listed under results with its error, '
-        + 'not counted as saved.',
+        'Write your verdict on points of an answer after checking them: ids f1 ... (findings), u1 ... (unknowns), '
+        + 'c1 ... (next_checks). verdict is what checking showed -- confirmed (holds here), not_applicable (true in '
+        + 'general, not here), unverifiable, unverified (not checked yet; say why in effect) -- not whether you adopted '
+        + 'it. effect is what it changed about your decision, note the evidence. A follow-up shows the consultant each '
+        + 'verdict and effect (credential-masked), never the note. The same id again replaces the entry. Saved beside '
+        + 'the answer in ~/.severally/history, so a job from an earlier session can be recorded against; the server '
+        + 'never infers a verdict. Answers with counts; consult_get reads the entries back. reflection records what the '
+        + 'answer added over your consult_start prediction. records: [{ job_id, entries, reflection? }, ...] records '
+        + 'every member of a fan-out in one call; all are checked first and nothing is written if any job or id is '
+        + 'wrong. A job whose write fails is listed under results with its error.',
       inputSchema: z.object({
         ...recordShape,
         job_id: recordShape.job_id.optional(),
         records: z.array(z.object(recordShape)).min(1).max(POLICY.maxConcurrent).optional()
-          .describe('several consultations at once -- one per member of a fan-out -- instead of job_id/entries/reflection'),
+          .describe('one per fan-out member, instead of job_id/entries/reflection'),
       }),
     },
     async ({ job_id, entries, reflection, records }) => {
@@ -342,12 +292,10 @@ export function createServer(manager = new JobManager()) {
       title: 'Export a consultation as a record to commit',
       annotations: { readOnlyHint: true, openWorldHint: false },
       description:
-        'Render one consultation (chain_id) or one fan-out (group_id) as Markdown: the brief as it was sent, '
-        + 'each consultant\'s answer as it came back, and the verdicts recorded against each point -- with the '
-        + 'ones nobody checked marked as unchecked. Nothing is summarised across consultants and nothing is '
-        + 'scored. The text is returned, not written: put it wherever the decision belongs in the repository '
-        + '(a decision record next to the code it is about), which is the only place a teammate will find it. '
-        + 'Reads the on-disk history, so a consultation from an earlier session can still be exported.',
+        'Render one consultation (chain_id) or fan-out (group_id) as Markdown: the brief as sent, each answer as '
+        + 'it came back, and the verdicts on each point, unchecked ones marked. Nothing is summarised or scored. '
+        + 'The text is returned, not written: put it beside the code the decision is about. Reads the history, so '
+        + 'an earlier session\'s consultation can be exported.',
       inputSchema: z.object({
         chain_id: z.string().min(1).optional(),
         group_id: z.string().min(1).optional(),
@@ -369,10 +317,9 @@ export function createServer(manager = new JobManager()) {
       title: 'List recent consultations',
       annotations: { readOnlyHint: true, openWorldHint: false },
       description:
-        'Recent consultations from this session, newest first, with their status, one-line summary and who '
-        + 'asked for them (initiator), and usage_totals: the token (and, where the CLI reports one, cost) figures each consultant reported this '
-        + 'session, summed per consultant over every attempt, automatic re-runs included. A figure a CLI does not '
-        + 'report is not counted as zero; it is named under not_reported.',
+        'Recent consultations, earlier sessions\' too (this_session is false), newest first, with their ids, '
+        + 'status, summary and verdicts; and usage_totals, the tokens (and cost) each consultant reported this session, '
+        + 'retries included. A figure a CLI does not report is named under not_reported, not counted as zero.',
       inputSchema: z.object({ limit: z.number().int().min(1).max(100).optional() }),
     },
     async ({ limit }) => ok({
@@ -390,6 +337,7 @@ export async function main() {
   // consult_start: the operator may be the only one who reads stderr.
   const problem = configProblem();
   if (problem) process.stderr.write(`severally: config needs fixing; every consultation will be refused until it is -- ${problem}\n`);
+  for (const w of configWarnings()) process.stderr.write(`severally: config mistake; the consultant or CLI it is in stays unused until it is fixed -- ${w}\n`);
   if (availableConsultants().length === 0) {
     process.stderr.write(
       'severally: no consultant CLI found on PATH (codex / claude / agy / opencode); every consultation will be refused\n',

package/src/status.mjs

@@ -0,0 +1,63 @@
+// `severally-mcp status`: what this machine has set up, read without starting a
+// consultation, so it spends no quota. It says what it can see and no more: a
+// CLI being registered and installed does not show it is logged in, and that is
+// reported as not checked rather than as working.
+import { POLICY, configProblem, configWarnings, unavailableReason, consultantAvailable, brokenConsultantNames, brokenConsultant } from './policy.mjs';
+import { SEVERALLY_VERSION, staleInstall } from './server.mjs';
+import { findCommand, execCommandSync } from './platform.mjs';
+
+// How each client lists severally, plugin installs first. A command that exits 0
+// and names severally counts as registered.
+const CLIENTS = [
+  { label: 'Claude Code', cmd: 'claude', checks: [['plugin', 'list'], ['mcp', 'get', 'severally']] },
+  { label: 'Codex', cmd: 'codex', checks: [['plugin', 'list'], ['mcp', 'get', 'severally']] },
+  { label: 'Antigravity', cmd: 'agy', checks: [['mcp', 'list']] },
+  { label: 'OpenCode', cmd: 'opencode', checks: [['mcp', 'list']] },
+];
+
+// "registered": the client's own listing names severally (it may still be
+// turned off there). "not registered": the client answered, without it.
+// No answer at all (a timeout, a failure to start): unknown.
+function registration({ cmd, checks }) {
+  if (!findCommand(cmd)) return 'not installed';
+  let ran = false;
+  for (const args of checks) {
+    try {
+      const out = execCommandSync(cmd, args, { encoding: 'utf8', timeout: 20_000, stdio: ['ignore', 'pipe', 'pipe'] });
+      ran = true;
+      if (/(^|[\s@:])severally([\s@:]|$)/m.test(out)) return 'registered (listed by the client)';
+    } catch (err) {
+      // It ran and said no (`mcp get` of a missing server exits non-zero); a
+      // timeout or a failure to start says nothing either way.
+      if (typeof err.status === 'number') ran = true;
+    }
+  }
+  return ran ? 'not registered' : `could not tell (${cmd} ${checks.map((a) => a.join(' ')).join(' / ')} failed)`;
+}
+
+export function status() {
+  const lines = [`severally ${SEVERALLY_VERSION}`, ''];
+  const problem = configProblem();
+  lines.push(`config: ${problem ? `needs fixing, every consultation is refused until it is -- ${problem}` : 'ok'}`);
+  for (const w of configWarnings()) lines.push(`  mistake (only that consultant or CLI is out of use): ${w}`);
+  lines.push(`network: ${POLICY.network === 'off' ? 'off for every consultation (server.network)' : 'per request'}`, '');
+
+  lines.push('consultants:');
+  for (const c of POLICY.consultants) {
+    lines.push(`  ${c.name}: ${c.cli}, ${c.model}  ${consultantAvailable(c) ? 'available' : `not available: ${unavailableReason(c)}`}`);
+  }
+  for (const name of brokenConsultantNames()) lines.push(`  ${name}: not available: ${brokenConsultant(name)}`);
+  lines.push('');
+
+  const stale = staleInstall();
+  lines.push(stale
+    ? `copies: ${Object.entries(stale.copies).map(([k, v]) => `${k} ${v}${stale.behind.includes(k) ? ' (behind)' : ''}`).join(', ')}\n  ${stale.fix}`
+    : 'copies: every installed copy is this version', '');
+
+  lines.push('clients:');
+  for (const client of CLIENTS) lines.push(`  ${client.label.padEnd(12)} ${registration(client)}`);
+  lines.push('', 'login: not checked -- an installed, registered CLI may still be logged out or out of quota; '
+    + 'the first consultation is what shows it');
+  process.stdout.write(`${lines.join('\n')}\n`);
+  return problem ? 1 : 0;
+}

package/src/store.mjs

@@ -63,6 +63,21 @@ function indexRow(jobId) {
   return null;
 }
 
+/** Every row of the history index, in the order written; a damaged line is skipped. */
+export function indexRows() {
+  return readIfExists(path.join(POLICY.home, 'history', 'index.jsonl')).split('\n').flatMap((line) => {
+    try {
+      const row = line.trim() ? JSON.parse(line) : null;
+      return row && typeof row === 'object' && JOB_ID.test(row.job_id) ? [row] : [];
+    } catch { return []; }
+  });
+}
+
+/** The round file an index row points at, or null. */
+export function loadRoundAt(row) {
+  try { return JSON.parse(fs.readFileSync(roundPath(row.chain_id, row.round), 'utf8')); } catch { return null; }
+}
+
 export const roundPath = (chainId, round) =>
   path.join(POLICY.home, 'history', chainId, `round-${String(round).padStart(2, '0')}.json`);
 
@@ -199,13 +214,28 @@ function withSeatLock(fn) {
 export function takeSeats(seats, cap, held) {
   return withSeatLock(() => {
     const live = [];
-    for (const name of fs.readdirSync(seatsDir())) {
+    const names = fs.readdirSync(seatsDir());
+    // A cancel asked for after its consultation ended has no seat left to go with.
+    for (const name of names.filter((n) => n.endsWith('.cancel'))) {
+      if (!names.includes(name.replace(/\.cancel$/, '.json'))) try { fs.rmSync(path.join(seatsDir(), name), { force: true }); } catch { /* best effort */ }
+    }
+    for (const name of names) {
       if (!name.endsWith('.json')) continue;
       let seat = null;
       try { seat = JSON.parse(fs.readFileSync(path.join(seatsDir(), name), 'utf8')); } catch { /* half-written or damaged: free */ }
       if (seat && held(seat)) live.push(seat);
       else try { fs.rmSync(path.join(seatsDir(), name), { force: true }); } catch { /* best effort */ }
     }
+    // A chain runs one round at a time, across processes: a live seat on the
+    // same chain, or a round file already at the number chosen, means another
+    // server continued it first.
+    for (const mine of seats.filter((x) => x.chain_id)) {
+      let other = live.find((x) => x.chain_id === mine.chain_id);
+      if (!other && fs.existsSync(roundPath(mine.chain_id, mine.round))) {
+        try { other = { job_id: JSON.parse(fs.readFileSync(roundPath(mine.chain_id, mine.round), 'utf8')).job_id, round: mine.round }; } catch { other = { job_id: '(unreadable)', round: mine.round }; }
+      }
+      if (other) return { ok: false, chainBusy: { live: other, mine } };
+    }
     if (live.length + seats.length > cap) {
       return { ok: false, live: live.length, elsewhere: live.filter((x) => x.owner?.pid !== process.pid).length };
     }
@@ -220,6 +250,19 @@ export function takeSeats(seats, cap, held) {
 export function releaseSeat(jobId) {
   if (!JOB_ID.test(jobId)) return;
   try { fs.rmSync(seatFile(jobId), { force: true }); } catch { /* best effort */ }
+  clearCancel(jobId);
+}
+
+// A cancel asked for by a server that does not run the consultation: left
+// beside its seat, for the server that does to find and act on.
+const cancelFile = (jobId) => path.join(seatsDir(), `${jobId}.cancel`);
+export function requestCancel(jobId) {
+  if (!JOB_ID.test(jobId)) return false;
+  try { fs.mkdirSync(seatsDir(), { recursive: true, mode: 0o700 }); fs.writeFileSync(cancelFile(jobId), '', { mode: 0o600 }); return true; } catch { return false; }
+}
+export const cancelRequested = (jobId) => JOB_ID.test(jobId) && fs.existsSync(cancelFile(jobId));
+export function clearCancel(jobId) {
+  if (JOB_ID.test(jobId)) try { fs.rmSync(cancelFile(jobId), { force: true }); } catch { /* best effort */ }
 }
 
 export function loadGroup(groupId) {