severally-mcp 2.0.0 → 2.3.1

package/src/jobs.mjs

@@ -4,7 +4,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { POLICY, VERDICTS, limitsSummary, timeoutMs, detectCaller, configProblem, consultantByName } from './policy.mjs';
+import { POLICY, VERDICTS, limitsSummary, timeoutMs, detectCaller, configProblem, consultantByName, consultantAvailable } from './policy.mjs';
 import { vendorOf, sameModel, CLI_VENDORS } from './consultants.mjs';
 import { parseRequest, RequestError, charCount } from './schema.mjs';
 import { renderBrief, renderGuardrails, briefRecord } from './brief.mjs';
@@ -27,6 +27,9 @@ const ADAPTERS = { codex, 'claude-code': claudeCode, antigravity, opencode };
 // anyway would silently extend the job's advertised wall-clock deadline.
 const MIN_RETRY_MS = 5_000;
 
+// How often a server looks for a cancel another server asked for.
+const CANCEL_POLL_MS = 1_000;
+
 // The second way a consultant can be authenticated. A linked token file and an
 // API key / ADC file are alternatives, not both required, so the presence of
 // either has to satisfy the credential check below. These are the names
@@ -226,14 +229,39 @@ export class JobManager {
     return compactBrief(rec, detail);
   }
 
+  // This session's consultations and the history's, so an earlier session's
+  // job_id and group_id can still be followed up and recorded against. The
+  // index only picks and orders; each row shown is read from its round, which
+  // holds the verdicts written since. Memory wins over disk for the same job.
   list({ limit = 20 } = {}) {
-    return this.order
-      .slice(-limit)
-      .reverse()
-      .map((jid) => {
-        const j = this.jobs.get(jid);
+    const here = this.order.map((jid) => this.jobs.get(jid));
+    const seen = new Set(here.map((j) => j.job_id));
+    const elsewhere = [];
+    // Read only: a marker whose owner is gone is shown as interrupted, and
+    // left for consult_get or the startup sweep to close out.
+    for (const jobId of store.listRunning()) {
+      const live = seen.has(jobId) ? null : store.loadRunning(jobId);
+      if (!live) continue;
+      seen.add(jobId);
+      const state = ownerState(jobId, live.owner);
+      // A round saved just before its owner died is the answer, whatever the marker says.
+      const saved = state === 'alive' ? null : store.loadRoundAt(live);
+      elsewhere.push({ rec: state === 'alive' ? live : saved ?? { ...live, status: 'failed', failure: { kind: 'interrupted' } } });
+    }
+    for (const row of store.indexRows()) if (!seen.has(row.job_id)) { seen.add(row.job_id); elsewhere.push({ row }); }
+    const at = (x) => x.created_at ?? x.rec?.created_at ?? x.row?.created_at ?? '';
+    const picked = [];
+    // Round files are read only for the rows shown; one that cannot be read is passed over.
+    for (const x of [...here, ...elsewhere].sort((p, q) => (at(q) < at(p) ? -1 : at(q) > at(p) ? 1 : 0))) {
+      if (picked.length >= limit) break;
+      const j = x.row ? store.loadRoundAt(x.row) : x.rec ?? x;
+      if (j) picked.push(j);
+    }
+    return picked
+      .map((j) => {
         return {
           job_id: j.job_id,
+          group_id: j.group_id ?? null,
           chain_id: j.chain_id,
           round: j.round,
           target: j.target,
@@ -246,7 +274,8 @@ export class JobManager {
           duration_ms: j.duration_ms,
           summary: j.result ? j.result.summary.slice(0, 200) : null,
           recorded: Boolean(j.record),
-          verdicts: j.record ? tally(j.record.entries.map((e) => e.verdict)) : null,
+          verdicts: j.record?.entries ? tally(j.record.entries.map((e) => e.verdict)) : null,
+          this_session: this.jobs.has(j.job_id),
           predicted: Boolean(j.prediction),
           reflected: Boolean(j.reflection),
           initiator: j.initiator ?? null,
@@ -296,7 +325,19 @@ export class JobManager {
       ? rawRequest.followup_to.trim()
       : null;
     let parent = null;
-    if (followupTo) {
+    let fromGroup = null;
+    if (followupTo?.startsWith('group_')) {
+      // A follow-up to a fan-out goes to every member that can take one; the
+      // members are the targets, so the request names none.
+      if ((rawRequest.target ?? null) !== null || rawRequest.targets?.length) {
+        throw new RequestError(
+          'a follow-up to a group goes to every member that can take one, so leave target and targets out; to follow up one member, pass its job_id',
+          'followup_group_targets',
+        );
+      }
+      fromGroup = this.#groupParents(followupTo);
+      rawRequest = { ...rawRequest, targets: fromGroup.links.map((l) => l.parent.target) };
+    } else if (followupTo) {
       // A job from an earlier server session is read back from the history,
       // so a restart does not end a consultation the lead is still checking.
       parent = this.jobs.get(followupTo) ?? store.loadRound(followupTo);
@@ -322,8 +363,26 @@ export class JobManager {
       parent = { ...parent, nextRound: Math.max(...rounds.map((j) => j.round)) + 1 };
     }
 
-    const req = parseRequest(rawRequest, { isFollowup: Boolean(parent), parentMode: parent?.mode ?? null });
+    if (parent && (rawRequest.target ?? null) === null && !rawRequest.targets?.length) {
+      rawRequest = { ...rawRequest, target: parent.target };
+    }
+    // A fan-out's members were all handed the same brief, so any one of them holds it.
+    if (parent || fromGroup) rawRequest = inherit(rawRequest, fromGroup ? fromGroup.links[0].groupMember ?? fromGroup.links[0].parent : parent);
+
+    const req = parseRequest(rawRequest, {
+      isFollowup: Boolean(parent || fromGroup),
+      parentMode: parent?.mode ?? fromGroup?.group.mode ?? null,
+      groupFollowup: Boolean(fromGroup),
+    });
+    // The operator's setting only ever closes: a request cannot reopen the web.
+    if (POLICY.network === 'off') req.network = 'off';
 
+    if (fromGroup && fromGroup.links.some((l, i) => l.parent.target !== req.targets[i])) {
+      throw new RequestError(
+        `the members of group "${followupTo}" no longer resolve to the consultants that answered them; follow up each member by its job_id`,
+        'followup_target_mismatch',
+      );
+    }
     if (parent && parent.target !== req.target) {
       throw new RequestError(
         `follow-up must go to the same consultant as job "${parent.job_id}" (${parent.target})`,
@@ -331,7 +390,7 @@ export class JobManager {
       );
     }
     const round = parent ? parent.nextRound : 1;
-    if (round > POLICY.maxRounds) {
+    if (!fromGroup && round > POLICY.maxRounds) {
       throw new RequestError(
         `this consultation has used its ${POLICY.maxRounds} rounds (1 initial + ${POLICY.maxRounds - 1} follow-ups); decide with what you have, or start a new consultation with a materially different question`,
         'round_limit',
@@ -341,8 +400,13 @@ export class JobManager {
     // Admit or refuse the whole fan-out: a half-started group would leave the
     // lead comparing answers to a question only some consultants were asked.
     // The cap counts every severally process on this home, through the seats.
-    const seats = req.targets.map((target) => ({
+    // A follow-up's seat also names the chain and round it opens, so that two
+    // servers continuing one consultation at once cannot both take a round
+    // number: neither sees the other's round in its history until it ends.
+    const chainOf = (i) => (fromGroup ? fromGroup.links[i] : parent ? { parent, round } : null);
+    const seats = req.targets.map((target, i) => ({
       job_id: id('job'),
+      ...(chainOf(i) ? { chain_id: chainOf(i).parent.chain_id, round: chainOf(i).round } : {}),
       // Twice the budget plus an hour: the deadline is wall-clock, the budget is
       // not, so a suspended laptop must not make a live owner look overdue.
       owner: {
@@ -351,6 +415,14 @@ export class JobManager {
       },
     }));
     const taken = store.takeSeats(seats, POLICY.maxConcurrent, (seat) => ownerState(seat.job_id, seat.owner) === 'alive');
+    if (taken.chainBusy) {
+      const { live, mine } = taken.chainBusy;
+      throw new RequestError(
+        `another severally process has already continued this consultation: job "${live.job_id}" is round ${live.round ?? mine.round}`
+        + '; wait for it (consult_get) and follow up the latest round',
+        'followup_not_latest',
+      );
+    }
     if (!taken.ok) {
       throw new RequestError(
         `this would run ${taken.live + seats.length} consultations at once; the cap is ${POLICY.maxConcurrent}`
@@ -361,14 +433,57 @@ export class JobManager {
     }
     // A request refused from here on gives its seats back.
     try {
-      return this.#admitted(req, parent, round, seats);
+      // Each target's parent round and the round it opens, in req.targets order.
+      const links = fromGroup?.links ?? req.targets.map(() => ({ parent, round }));
+      return this.#admitted(req, links, seats, fromGroup);
     } catch (err) {
       for (const seat of seats) if (!this.jobs.has(seat.job_id)) store.releaseSeat(seat.job_id);
       throw err;
     }
   }
 
-  #admitted(req, parent, round, seats) {
+  // A follow-up to a fan-out: each member goes on from the newest answered
+  // round of its own chain. A member that is still running, never answered or
+  // has used its rounds is skipped and named; if that is every member, the
+  // request is refused.
+  #groupParents(groupId) {
+    const group = this.groups.get(groupId) ?? store.loadGroup(groupId);
+    if (!group) throw new RequestError(`followup_to references unknown group "${groupId}"`, 'unknown_group');
+    const links = [];
+    const skipped = [];
+    for (const jid of group.job_ids) {
+      const member = this.jobs.get(jid) ?? store.loadRound(jid);
+      if (!member) {
+        skipped.push({ job_id: jid, target: null, reason: 'not found: aged out of the history, or still running in another severally process' });
+        continue;
+      }
+      const rounds = this.#chainRounds(member.chain_id);
+      const latest = rounds.filter((j) => !['failed', 'cancelled'].includes(j.status)).sort((a, b) => b.round - a.round)[0];
+      const nextRound = Math.max(...rounds.map((j) => j.round)) + 1;
+      // The name is kept, not re-resolved: a consultant renamed or turned off
+      // since is skipped, never continued by whichever one answers to it now.
+      const consultant = consultantByName(member.target);
+      const reason = !latest ? `${member.status}, so there is no answer to follow up`
+        : latest.status !== 'completed' ? `round ${latest.round} is still ${latest.status}`
+          : nextRound > POLICY.maxRounds ? `has used its ${POLICY.maxRounds} rounds`
+            : !consultant || !consultantAvailable(consultant) ? 'this consultant is no longer configured or available here'
+              : null;
+      if (reason) skipped.push({ job_id: (latest ?? member).job_id, target: member.target, reason });
+      else links.push({ parent: { ...latest, nextRound }, round: nextRound, groupMember: member });
+    }
+    if (!links.length) {
+      throw new RequestError(
+        `no member of group "${groupId}" can take a follow-up: ${skipped.map((x) => `${x.target ?? x.job_id} (${x.reason})`).join(', ')}`,
+        'followup_nothing_to_continue',
+      );
+    }
+    return { group, links, skipped };
+  }
+
+  #admitted(req, links, seats, fromGroup = null) {
+    // What expose_from_parent copies again: for a group, what that fan-out
+    // exposed (one manifest, shared by its members); otherwise the parent's.
+    const parent = links[0].groupMember ?? links[0].parent;
     const groupId = id('group');
     // Copied once for the whole request, before a round is counted or a job
     // exists, into the group's own directory: every member is then handed the
@@ -428,7 +543,8 @@ export class JobManager {
       req._snapshot = path.join(snapshot, 'workspace');
     }
     const members = req.targets.map((target, i) => {
-      const chainId = parent ? parent.chain_id : id('chain');
+      const { parent: from, round } = links[i];
+      const chainId = from ? from.chain_id : id('chain');
       const jobId = seats[i].job_id;
       const job = {
         job_id: jobId,
@@ -462,7 +578,7 @@ export class JobManager {
         retries: [],
         partial_output: null,
         tool_calls: null,
-        followup_to: parent?.job_id ?? null,
+        followup_to: from?.job_id ?? null,
         status: 'queued',
         // What this consultant is: the CLI it runs on, the model and its
         // lineage, as the operator defined it.
@@ -484,6 +600,7 @@ export class JobManager {
       this.jobs.set(jobId, job);
       this.order.push(jobId);
       LIVE_HERE.add(jobId);
+      this.#watchCancels();
       job._owner = seats[i].owner;
       this.#mark(job);
       return job;
@@ -500,14 +617,13 @@ export class JobManager {
     this.groups.set(groupId, group);
     try { store.persistGroup(group); } catch { /* history is best effort */ }
 
-    // One brief, rendered once for the whole group: a fan-out is only comparable
-    // if every consultant answered the same question in the same words. Every
-    // member shares one chain history by construction -- a fan-out is never a
-    // follow-up (parseRequest refuses that), so each member's fresh chain is
-    // empty, and a follow-up is always a group of one on the parent's chain.
-    const chain = { round, priorRounds: this.#chainHistory(members[0].chain_id) };
-    const brief = renderBrief(req, chain, exposeManifest);
+    // A fan-out is only comparable if every consultant answered the same
+    // question in the same words: every member's brief is the same request,
+    // rendered the same way. Only the earlier rounds differ -- each member's
+    // own, on a follow-up to a group; none, on a first round.
     for (const job of members) {
+      const chain = { round: job.round, priorRounds: this.#chainHistory(job.chain_id) };
+      const brief = renderBrief(req, chain, exposeManifest);
       job.promise = this.#execute(job, { ...req, target: job.target }, chain, brief).catch((err) => {
         this.#fail(job, 'cli_error', err?.message ?? String(err));
       });
@@ -517,11 +633,14 @@ export class JobManager {
     // if the process dies mid-consultation. Keep that copy ahead of any await.
     if (req._snapshot) store.cleanupJobDir(groupId);
 
+    // The members of a follow-up to a group can be at different rounds.
+    const { round } = members[0];
+    const sameRound = members.every((m) => m.round === round);
     const common = {
       group_id: groupId,
-      round,
+      ...(sameRound ? { round, rounds_remaining: POLICY.maxRounds - round } : {}),
+      ...(fromGroup ? { followup_to_group: fromGroup.group.group_id, skipped: fromGroup.skipped } : {}),
       ...(parentEntries.length ? { exposed_from_parent: inheritedSummary(exposeManifest) } : {}),
-      rounds_remaining: POLICY.maxRounds - round,
       mode: req.mode,
       // Counted, not refused: a brief of facts alone is a legitimate
       // consultation, but one about code that hands over no file is one the
@@ -550,7 +669,10 @@ export class JobManager {
     return {
       ...common,
       question: group.question, // the redacted text every member was actually sent
-      jobs: members.map((m) => ({ job_id: m.job_id, chain_id: m.chain_id, target: m.target, cli: m.cli, model: m.model })),
+      jobs: members.map((m) => ({
+        job_id: m.job_id, chain_id: m.chain_id, target: m.target, cli: m.cli, model: m.model,
+        ...(sameRound ? {} : { round: m.round, rounds_remaining: POLICY.maxRounds - m.round }),
+      })),
       poll_with: `consult_get({ group_id: "${groupId}" })`,
       note: 'Every consultant got the identical brief. When they come back, compare the grounds behind the points that differ; matching summaries are not evidence of agreement.',
     };
@@ -558,9 +680,8 @@ export class JobManager {
 
   // The rounds before a follow-up, from the history on disk and from memory
   // (memory wins: it can hold a verdict written since the round was saved).
-  // Each finding goes with the lead's verdict on it, so the consultant answers
-  // knowing which of its points were checked and how they came out. Every
-  // finding that carries a verdict is passed; of the rest, the first five.
+  // Each point goes with the lead's verdict on it, so the consultant answers
+  // knowing which of its points were checked and how they came out.
   #chainRounds(chainId) {
     const byRound = new Map(store.loadChain(chainId).map((j) => [j.round, j]));
     for (const j of this.jobs.values()) if (j.chain_id === chainId) byRound.set(j.round, j);
@@ -573,11 +694,24 @@ export class JobManager {
       .sort((a, b) => a.round - b.round)
       .map((j) => {
         const verdicts = new Map((j.record?.entries ?? []).map((e) => [e.id, e]));
-        let unchecked = 0;
-        const findings = j.result.findings
-          .filter((f) => verdicts.has(f.id) || unchecked++ < 5)
-          .map((f) => ({ id: f.id, point: f.point, verdict: verdicts.get(f.id)?.verdict ?? null, effect: verdicts.get(f.id)?.effect ?? null }));
-        return { round: j.round, mode: j.mode, question: j.question, summary: j.result.summary, findings };
+        // The checked points first, then the unchecked ones, each with the
+        // lead's verdict and effect when there is one.
+        const ordered = (items, shape) => [
+          ...items.filter((x) => verdicts.has(x.id)),
+          ...items.filter((x) => !verdicts.has(x.id)),
+        ].map((x) => ({ id: x.id, ...shape(x), verdict: verdicts.get(x.id)?.verdict ?? null, effect: verdicts.get(x.id)?.effect ?? null }));
+        const checked = (x) => x.verdict !== null;
+        const findings = ordered(j.result.findings, (f) => ({ point: f.point, grounds: f.grounds ?? null }));
+        return {
+          round: j.round,
+          mode: j.mode,
+          question: j.question,
+          summary: j.result.summary,
+          // Every checked finding; of the rest, the first five.
+          findings: [...findings.filter(checked), ...findings.filter((f) => !checked(f)).slice(0, 5)],
+          unknowns: ordered(j.result.unknowns, (u) => ({ point: u.item })).slice(0, 5),
+          next_checks: ordered(j.result.next_checks, (c) => ({ point: c.check })).slice(0, 5),
+        };
       });
   }
 
@@ -621,8 +755,9 @@ export class JobManager {
         return this.#fail(job, 'spawn_error', `could not copy the exposed files: ${err.message}`);
       }
     }
-    // start() renders the brief once per chain and hands it in, so every member
-    // of a fan-out is sent byte-identical text.
+    // start() renders the brief and hands it in: every member of a fan-out is
+    // sent the same request in the same words, with only its own earlier rounds
+    // added on a follow-up to the group.
     const text = brief ?? renderBrief(req, chain);
     const schemaPath = store.writeJobArtifact(job.job_id, 'response-schema.json', JSON.stringify(CONSULT_RESULT_SCHEMA, null, 2));
     const sandbox = adapter.prepareSandbox ? adapter.prepareSandbox({ workdir, network: req.network }) : null;
@@ -766,6 +901,12 @@ export class JobManager {
         }
         const lastMessageText = invocation.lastMessagePath ? store.readIfExists(invocation.lastMessagePath) : '';
         interpreted = adapter.interpret({ ...run, lastMessageText });
+        // An answer after an error the CLI reported is kept only if it parses;
+        // otherwise it is that error, re-run like any other.
+        const { recoveredError } = interpreted;
+        if (interpreted.ok && recoveredError && !parses(interpreted.text)) {
+          interpreted = { ok: false, ...recoveredError, usageRaw: interpreted.usageRaw };
+        }
         if (interpreted.ok) break;
         // No envelope at all: what stderr holds is the dump from stopping it,
         // not a message to classify. Not re-run, as it may have spent its quota.
@@ -801,8 +942,12 @@ export class JobManager {
         break;
       }
 
+      // Without an answer, a process left holding the pipes is the failure to report.
+      const leftover = run.pipesForced
+        && `${invocation.command} exited, but a process it started kept its output open and was stopped`;
       if (!interpreted.ok) {
         job.usage = adapter.usageRecord(interpreted.usageRaw);
+        if (leftover) return this.#fail(job, 'cli_error', leftover, interpreted.message);
         return this.#fail(job, interpreted.failureKind, interpreted.message);
       }
 
@@ -826,6 +971,7 @@ export class JobManager {
           }
           if (!normalized) {
             job.usage = adapter.usageRecord(interpreted.usageRaw);
+            if (leftover) return this.#fail(job, 'cli_error', leftover, err.message);
             return this.#fail(job, 'invalid_output', err.message, redact(String(err.detail ?? '')).slice(0, 1200));
           }
         } else {
@@ -834,7 +980,12 @@ export class JobManager {
       }
 
       job.result = normalized.result;
-      const notes = [adviceCaveat(normalized), sameVendorCaveat(job.caller, job.caller_model, consultant)].filter(Boolean);
+      const notes = [
+        adviceCaveat(normalized),
+        sameVendorCaveat(job.caller, job.caller_model, consultant),
+        interpreted.recoveredError && `the consultant's CLI reported an error mid-run and then finished its answer: ${redact(interpreted.recoveredError.message).slice(0, 300)}`,
+        leftover && 'the answer parsed, but a process the consultant started kept its output open after it exited and was stopped (one that left its process group may still be running)',
+      ].filter(Boolean);
       // No `advice_usable` verdict here. It was always true, so it carried no
       // information -- and worse, it read as the server vouching for advice it
       // cannot judge. What this server may assert is what it can derive from
@@ -1054,49 +1205,66 @@ export class JobManager {
         message: `the verdict for "${job.job_id}" could not be written to the history (${e.message}); record it again`,
       };
     }
+    // Counts only: the entries are what the lead just wrote, and
+    // consult_get({ job_id, ids }) reads any of them back with its verdict.
+    const summary = job.record && recordSummary(job);
     return {
       job_id: job.job_id,
       chain_id: job.chain_id,
       round: job.round,
-      record: job.record ? recordSummary(job) : null,
-      prediction: job.prediction ?? null,
-      reflection: job.reflection ?? null,
+      record: summary ? { updated_at: summary.updated_at, verdicts: summary.verdicts, coverage: summary.coverage } : null,
+      reflection_saved: job.reflection != null,
     };
   }
 
-  async wait(jobId, waitMs, opts) {
+  async wait(jobId, waitMs, opts, signal) {
     const job = this.jobs.get(jobId);
-    if (!job) return this.#waitOnDisk(() => this.view(jobId, opts), waitMs);
+    if (!job) return this.#waitOnDisk(() => this.view(jobId, opts), waitMs, signal);
     const budget = Math.min(Math.max(0, waitMs ?? 0), POLICY.maxWaitMs);
     if (budget === 0 || job.status === 'completed' || job.status === 'failed' || job.status === 'cancelled') {
       return this.view(jobId, opts);
     }
-    await Promise.race([job.promise, new Promise((r) => setTimeout(r, budget).unref?.())]);
+    await settled(job.promise, budget, signal);
     return this.view(jobId, opts);
   }
 
   // A consultation another process runs has no promise here, so its history
   // is re-read once a second until it is no longer running or the wait is up.
-  async #waitOnDisk(read, waitMs) {
+  async #waitOnDisk(read, waitMs, signal) {
     const until = Date.now() + Math.min(Math.max(0, waitMs ?? 0), POLICY.maxWaitMs);
     let view = read();
-    while (view && ['running', 'queued'].includes(view.status) && Date.now() < until) {
-      await new Promise((r) => setTimeout(r, Math.min(1000, until - Date.now())));
+    while (view && ['running', 'queued'].includes(view.status) && Date.now() < until && !signal?.aborted) {
+      await settled(null, Math.min(1000, until - Date.now()), signal);
       view = read();
     }
     return view;
   }
 
+  // Cancels another server asked for (store.requestCancel), checked while
+  // this one runs anything. ponytail: polled once a second, not signalled;
+  // a watch on the slots directory if that delay ever matters.
+  #watchCancels() {
+    this._cancelWatch ??= setInterval(() => {
+      for (const job of this.jobs.values()) {
+        if ((job.status === 'running' || job.status === 'queued') && store.cancelRequested(job.job_id)) {
+          store.clearCancel(job.job_id);
+          this.cancel(job.job_id);
+        }
+      }
+    }, CANCEL_POLL_MS).unref();
+  }
+
   cancel(jobId) {
     const job = this.jobs.get(jobId);
     if (!job) {
       const view = this.view(jobId);
       if (!view) return null;
+      if (view.status !== 'running' && view.status !== 'queued') return { ...view, cancel_effect: `job was already ${view.status}` };
       return {
         ...view,
-        cancel_effect: view.status === 'running' || view.status === 'queued'
-          ? 'nothing signalled: this consultation runs in another severally process, and only that process can cancel it'
-          : `job was already ${view.status}`,
+        cancel_effect: store.requestCancel(jobId)
+          ? `asked the severally process running it to stop it; that takes up to ${CANCEL_POLL_MS / 1000} s, and consult_get shows when it has`
+          : 'nothing signalled: the request to the severally process running it could not be written',
       };
     }
     if (job.status !== 'running' && job.status !== 'queued') {
@@ -1182,7 +1350,10 @@ export class JobManager {
       limits: live || !full ? null : limitsSummary(),
     };
     // The side-by-side gets what the rest of the response leaves of GROUP_CHARS.
-    view.comparison = comparison(members, full ? Infinity : GROUP_CHARS - printed(view));
+    // While no one has finished there is nothing to set side by side, and an
+    // empty column per consultant is only context spent on every poll.
+    const anyFinished = members.some((m) => ['completed', 'failed', 'cancelled'].includes(m.status));
+    if (anyFinished) view.comparison = comparison(members, full ? Infinity : GROUP_CHARS - printed(view));
     return view;
   }
 
@@ -1192,18 +1363,15 @@ export class JobManager {
     return this.#shapeGroup(group, group.job_ids.map((jid) => this.view(jid, opts)).filter(Boolean), opts);
   }
 
-  async waitGroup(groupId, waitMs, opts) {
+  async waitGroup(groupId, waitMs, opts, signal) {
     const group = this.groups.get(groupId);
     // A fan-out from another process or an earlier session: nothing here to
     // wait on, so report what the history holds.
-    if (!group) return this.#waitOnDisk(() => this.groupView(groupId, opts), waitMs);
+    if (!group) return this.#waitOnDisk(() => this.groupView(groupId, opts), waitMs, signal);
     const budget = Math.min(Math.max(0, waitMs ?? 0), POLICY.maxWaitMs);
     if (budget > 0) {
       const promises = group.job_ids.map((jid) => this.jobs.get(jid)?.promise).filter(Boolean);
-      await Promise.race([
-        Promise.all(promises),
-        new Promise((r) => setTimeout(r, budget).unref?.()),
-      ]);
+      await settled(Promise.all(promises), budget, signal);
     }
     return this.groupView(groupId, opts);
   }
@@ -1213,7 +1381,12 @@ export class JobManager {
     if (!group) {
       const view = this.groupView(groupId);
       if (!view) return null;
-      return { ...view, cancel_effect: 'nothing signalled: this fan-out was started by another severally process or before a restart, and only a live process can cancel its own consultants' };
+      // Started by another server: each member still running there is asked to stop.
+      const asked = (store.loadGroup(groupId)?.job_ids ?? [])
+        .map((jid) => this.cancel(jid)).filter((r) => /^asked/.test(r?.cancel_effect ?? '')).length;
+      return { ...view, cancel_effect: asked
+        ? `asked the severally process running it to stop ${asked} consultation(s); that takes up to ${CANCEL_POLL_MS / 1000} s, and consult_get shows when it has`
+        : 'nothing to signal: no consultant in this fan-out is still running' };
     }
     // Count what is actually about to be signalled before signalling it:
     // cancel() short-circuits on a member that has already finished, so a
@@ -1321,6 +1494,36 @@ function partialOutput(run) {
   };
 }
 
+// Waits for `promise` (null: for nothing), at most `ms`, and no longer than
+// `signal` stays unaborted. The timer goes with the wait: a ten-minute wait
+// cut short leaves nothing behind.
+async function settled(promise, ms, signal) {
+  let timer;
+  let stop;
+  const until = new Promise((resolve) => {
+    stop = resolve;
+    timer = setTimeout(resolve, ms);
+    if (signal?.aborted) resolve();
+    else signal?.addEventListener('abort', resolve, { once: true });
+  });
+  try {
+    await (promise ? Promise.race([promise, until]) : until);
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener('abort', stop);
+  }
+}
+
+function parses(text) {
+  try {
+    normalizeResult(text);
+    return true;
+  } catch (err) {
+    if (err instanceof OutputError) return false;
+    throw err;
+  }
+}
+
 function recordableIds(result) {
   return [
     ...result.findings.map((f) => f.id),
@@ -1358,6 +1561,37 @@ function text(value) {
   return t.length > POLICY.output.itemTextMax ? `${t.slice(0, POLICY.output.itemTextMax)}\n…[truncated by severally]` : t;
 }
 
+// A follow-up restates what the round before was given unless it says
+// otherwise: the lead sends the new question, not the whole brief again. Only
+// a key left out is inherited -- one passed, even as an empty list, replaces
+// it -- and the validation that follows sees the result. Files are not:
+// copying them again stays expose_from_parent, named in the call (schema.mjs).
+function inherit(raw, round) {
+  const { brief } = round;
+  // A round kept off the web stays off: the material it carries over is the same.
+  const out = raw.network === undefined && round.network ? { ...raw, network: round.network } : { ...raw };
+  if (!brief) return out;
+  for (const k of ['objective', 'success_criteria', 'constraints']) {
+    if (out[k] === undefined && raw.context?.[k] === undefined && brief[k] != null && !(Array.isArray(brief[k]) && !brief[k].length)) out[k] = brief[k];
+  }
+  const ctx = { ...(raw.context ?? {}) };
+  for (const k of ['facts', 'proposal', 'counterpoints']) {
+    if (ctx[k] === undefined && brief[k] != null && !(Array.isArray(brief[k]) && !brief[k].length)) ctx[k] = brief[k];
+  }
+  // The diff expose_diff added is not the lead's material: it is taken again
+  // (or replaced) through expose_from_parent, against the files as they are now.
+  // It is the last artifact (appended after the lead's own), so only that one is dropped.
+  const artifacts = [...(brief.artifacts ?? [])];
+  const last = artifacts.at(-1);
+  if (brief.expose_paths?.entries?.some((e) => e.kind === 'diff') && last?.kind === 'diff' && last.name.startsWith('git diff ')) artifacts.pop();
+  if (ctx.artifacts === undefined && artifacts.length) {
+    // Stored with null for an absent language or source; the request schema takes them as optional strings.
+    ctx.artifacts = artifacts.map((a) => Object.fromEntries(Object.entries(a).filter(([, v]) => v != null)));
+  }
+  out.context = ctx;
+  return out;
+}
+
 function adviceCaveat(normalized) {
   const { result, quality } = normalized;
   const notes = [];
@@ -1365,7 +1599,11 @@ function adviceCaveat(normalized) {
     notes.push('the consultant reported its evidence as insufficient: treat this as a request for more material, not as advice');
   } else if (result.evidence_basis === 'thin') {
     notes.push('the consultant reported thin evidence: weigh the findings accordingly');
+  } else if (!result.evidence_basis) {
+    notes.push('the consultant did not say how well its evidence supports the answer (evidence_basis)');
   }
+  // Read first in a comparison; a missing one is shown as null there, and named here.
+  if (!result.stance) notes.push('the answer gives no bottom line (stance): read the summary and findings for one before relying on it');
   if (quality.findings_without_grounds > 0) {
     notes.push(`${quality.findings_without_grounds} finding(s) arrived without grounds: do not adopt them without checking`);
   }