severally-mcp 2.1.0 → 2.4.0

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.4.0';
 
 // 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
@@ -22,7 +22,11 @@ const DEFAULT_WAIT_MS = process.env.SEVERALLY_MAX_WAIT_MS ? POLICY.maxWaitMs : M
 const PROGRESS_EVERY_MS = 15_000;
 
 const semver = (v) => String(v).split('.').map(Number);
-const older = (a, b) => { const [x, y] = [semver(a), semver(b)]; for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] < y[i]; return false; };
+const older = (a, b) => {
+  const [x, y] = [semver(a), semver(b)];
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] < y[i];
+  return false;
+};
 
 /**
  * The other installed copies of severally, when one runs a different version
@@ -31,7 +35,13 @@ const older = (a, b) => { const [x, y] = [semver(a), semver(b)]; for (let i = 0;
  * version strings are compared. A copy that is missing is not reported.
  */
 export function staleInstall(home = os.homedir(), severallyHome = POLICY.home) {
-  const read = (file) => { try { return fs.readFileSync(file, 'utf8'); } catch { return null; } };
+  const read = (file) => {
+    try {
+      return fs.readFileSync(file, 'utf8');
+    } catch {
+      return null;
+    }
+  };
   // The runtime's version is read from its bundle, which every install mode
   // replaces; its package.json is written by plugin installs only.
   const bundle = read(path.join(severallyHome, 'runtime', 'severally-mcp.mjs'));
@@ -39,7 +49,13 @@ export function staleInstall(home = os.homedir(), severallyHome = POLICY.home) {
   const found = {
     // This release names it SEVERALLY_VERSION; older ones only had it in the server info.
     runtime: bundle?.match(/(?:SEVERALLY_VERSION = |name: ["']severally["'], version: )["'](\d+\.\d+\.\d+)["']/)?.[1],
-    claude_skills_dir: (() => { try { return JSON.parse(plugin).version; } catch { return undefined; } })(),
+    claude_skills_dir: (() => {
+      try {
+        return JSON.parse(plugin).version;
+      } catch {
+        return undefined;
+      }
+    })(),
   };
   const copies = { this_server: SEVERALLY_VERSION };
   // Only plain x.y.z is compared; anything else is left out rather than guessed at.
@@ -50,9 +66,10 @@ export function staleInstall(home = os.homedir(), severallyHome = POLICY.home) {
   return {
     copies,
     behind: Object.keys(copies).filter((k) => older(copies[k], newest)),
-    fix: `bring every copy to ${newest}: run \`npx -y severally-mcp@${newest} install\` (or \`node scripts/install.mjs\` from a checkout of that version) `
-      + '(it updates the runtime and the ~/.claude/skills copy), run `/plugin marketplace update severally` for a '
-      + 'marketplace install, then restart the clients',
+    fix:
+      `bring every copy to ${newest}: run \`npx -y severally-mcp@${newest} install\` (or \`node scripts/install.mjs\` from a checkout of that version) ` +
+      '(it updates the runtime and the ~/.claude/skills copy), run `/plugin marketplace update severally` for a ' +
+      'marketplace install, then restart the clients',
   };
 }
 
@@ -70,100 +87,79 @@ 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.`;
+${
+  availableConsultants()
+    .map((c) => `          ${c.name}: ${c.cli}, ${c.model}`)
+    .join('\n') || '          (none -- no consultant CLI is installed)'
+}
+        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'),
-  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'),
-    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'),
-  })).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.'),
+  job_id: z.string().min(1).describe('the job_id consult_get returned'),
+  entries: z
+    .array(
+      z.object({
+        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, 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 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()) {
   // Read once: the copies on disk change only when someone reinstalls, and then
   // this server is the one to restart.
   const stale = staleInstall();
-  const server = new McpServer(
-    { name: 'severally', version: SEVERALLY_VERSION },
-    { instructions: SERVER_INSTRUCTIONS },
-  );
+  const server = new McpServer({ name: 'severally', version: SEVERALLY_VERSION }, { instructions: SERVER_INSTRUCTIONS });
 
-  const ok = (payload) => ({ content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] });
-  const fail = (payload) => ({ content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true });
+  const ok = (payload) => ({ content: [{ type: /** @type {const} */ ('text'), text: JSON.stringify(payload, null, 2) }] });
+  const fail = (payload) => ({
+    content: [{ type: /** @type {const} */ ('text'), text: JSON.stringify(payload, null, 2) }],
+    isError: true,
+  });
 
   server.registerTool(
     'consult_start',
@@ -192,31 +188,30 @@ 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(),
         wait_ms: z.number().int().min(0).max(POLICY.maxWaitMs).optional(),
         detail: z.enum(['full']).optional(),
-        ids: z.array(z.string().min(1)).min(1).max(100).optional()
-          .describe('with job_id: return only these points of the finished answer (f1, u1, c1 ...), each whole with its grounds and, under `recorded`, the verdict you wrote'),
+        ids: z
+          .array(z.string().min(1))
+          .min(1)
+          .max(100)
+          .optional()
+          .describe(
+            'with job_id: return only these points of the finished answer (f1, u1, c1 ...), each whole with its grounds and, under `recorded`, the verdict you wrote',
+          ),
       }),
     },
     async ({ job_id, group_id, wait_ms, detail, ids }, ctx) => {
@@ -224,16 +219,26 @@ export function createServer(manager = new JobManager()) {
         return fail({ error: 'invalid_request', message: 'pass exactly one of job_id or group_id' });
       }
       if (ids && (group_id || detail)) {
-        return fail({ error: 'invalid_request', message: 'ids goes with job_id alone: a point id belongs to one consultant\'s answer' });
+        return fail({
+          error: 'invalid_request',
+          message: "ids goes with job_id alone: a point id belongs to one consultant's answer",
+        });
       }
       const req = ctx?.mcpReq;
       const token = req?._meta?.progressToken;
       let beats = 0;
-      const timer = token === undefined ? null : setInterval(() => {
-        beats += 1;
-        req.notify({ method: 'notifications/progress', params: { progressToken: token, progress: beats, message: 'the consultation is still running' } })
-          .catch(() => {});
-      }, PROGRESS_EVERY_MS);
+      const timer =
+        token === undefined
+          ? null
+          : setInterval(() => {
+              beats += 1;
+              req
+                .notify({
+                  method: 'notifications/progress',
+                  params: { progressToken: token, progress: beats, message: 'the consultation is still running' },
+                })
+                .catch(() => {});
+            }, PROGRESS_EVERY_MS);
       let view;
       try {
         // A request the client cancels stops the wait with it.
@@ -244,7 +249,10 @@ export function createServer(manager = new JobManager()) {
         clearInterval(timer);
       }
       if (!view) {
-        return fail({ error: 'unknown_job', message: `no consultation with ${group_id ? 'group_id' : 'job_id'} "${group_id ?? job_id}"` });
+        return fail({
+          error: 'unknown_job',
+          message: `no consultation with ${group_id ? 'group_id' : 'job_id'} "${group_id ?? job_id}"`,
+        });
       }
       // Still running: the poll answer as it is; ids applies once there is an answer.
       if (!ids || ['running', 'queued', 'cancelling'].includes(view.status)) return ok(view);
@@ -264,7 +272,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(),
@@ -276,7 +285,10 @@ export function createServer(manager = new JobManager()) {
       }
       const view = group_id ? manager.cancelGroup(group_id) : manager.cancel(job_id);
       if (!view) {
-        return fail({ error: 'unknown_job', message: `no consultation with ${group_id ? 'group_id' : 'job_id'} "${group_id ?? job_id}"` });
+        return fail({
+          error: 'unknown_job',
+          message: `no consultation with ${group_id ? 'group_id' : 'job_id'} "${group_id ?? job_id}"`,
+        });
       }
       return ok(view);
     },
@@ -288,45 +300,44 @@ 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'),
+        records: z
+          .array(z.object(recordShape))
+          .min(1)
+          .max(POLICY.maxConcurrent)
+          .optional()
+          .describe('one per fan-out member, instead of job_id/entries/reflection'),
       }),
     },
     async ({ job_id, entries, reflection, records }) => {
       try {
         if (records !== undefined) {
-          const out = manager.record(Object.fromEntries(Object.entries({ job_id, entries, reflection, records }).filter(([, v]) => v !== undefined)));
+          const out = manager.record(
+            Object.fromEntries(Object.entries({ job_id, entries, reflection, records }).filter(([, v]) => v !== undefined)),
+          );
           return out.not_saved ? fail(out) : ok(out);
         }
-        if (!job_id) return fail({ error: 'invalid_request', message: 'pass job_id (with entries and/or reflection), or records' });
-        return ok(manager.record({
-          job_id,
-          ...(entries === undefined ? {} : { entries }),
-          ...(reflection === undefined ? {} : { reflection }),
-        }));
+        if (!job_id)
+          return fail({ error: 'invalid_request', message: 'pass job_id (with entries and/or reflection), or records' });
+        return ok(
+          manager.record({
+            job_id,
+            ...(entries === undefined ? {} : { entries }),
+            ...(reflection === undefined ? {} : { reflection }),
+          }),
+        );
       } catch (err) {
         if (err instanceof RequestError) {
           return fail({ error: err.code, message: err.message, details: err.details ?? null });
@@ -342,12 +353,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,17 +378,17 @@ 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({
-      jobs: manager.list({ limit: limit ?? 20 }),
-      usage_totals: manager.usageTotals(),
-      limits: limitsSummary(),
-    }),
+    async ({ limit }) =>
+      ok({
+        jobs: manager.list({ limit: limit ?? 20 }),
+        usage_totals: manager.usageTotals(),
+        limits: limitsSummary(),
+      }),
   );
 
   return { server, manager };
@@ -389,16 +398,17 @@ export async function main() {
   // A config mistake is said here, at start, as well as on every refused
   // 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`);
+  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',
     );
   }
   if (process.env.SEVERALLY_ACTIVE === '1') {
-    process.stderr.write(
-      'severally: refusing to start inside a severally consultant session (recursion barrier)\n',
-    );
+    process.stderr.write('severally: refusing to start inside a severally consultant session (recursion barrier)\n');
     process.exit(2);
   }
   // One manager for the process; serveStdio builds the server once the client's