severally-mcp 2.1.0 → 2.3.1

package/scripts/install.mjs

@@ -249,8 +249,51 @@ const codexHome = process.env.CODEX_HOME ?? path.join(home, '.codex');
 // .mcp.json carries the same value for Claude Code, and its Codex manifest
 // with tool_timeout_sec 660 (codex 0.163 stops a tool call at 300 s by
 // default, progress notwithstanding). `codex mcp add` cannot set that
-// timeout, so a --manual Codex keeps 45 s.
+// timeout, so a --manual Codex gets it as one line written into config.toml
+// under [mcp_servers.severally] (see the Codex row), together with the env;
+// both or neither, since the wait without the timeout would outlast Codex's
+// own deadline.
 const LONG_WAIT = 'SEVERALLY_MAX_WAIT_MS=600000';
+const AGY_WAIT = 'SEVERALLY_MAX_WAIT_MS=165000';
+const agyConfig = path.join(home, '.gemini', 'config', 'mcp_config.json');
+const CODEX_TIMEOUT_SEC = 660;
+const codexConfig = path.join(codexHome, 'config.toml');
+// The user's own tool_timeout_sec, read before --force removes the table that holds it.
+let priorCodexTimeout;
+
+// Where [mcp_servers.severally] sits in config.toml, and what it holds.
+// A minimal text read, not a TOML parser: the table runs to the next header
+// that is not one of its own sub-tables (codex may put env in one).
+function codexTable() {
+  let lines;
+  try { lines = fs.readFileSync(codexConfig, 'utf8').split('\n'); } catch (err) { return { reason: `cannot read ${codexConfig}: ${err.message}` }; }
+  const start = lines.findIndex((l) => /^\s*\[\s*mcp_servers\.severally\s*\]/.test(l));
+  if (start < 0) return { reason: `${codexConfig} has no [mcp_servers.severally] table` };
+  let end = lines.findIndex((l, i) => i > start && /^\s*\[/.test(l) && !/^\s*\[\s*mcp_servers\.severally\./.test(l));
+  if (end < 0) end = lines.length;
+  const block = lines.slice(start + 1, end).join('\n');
+  const timeout = block.match(/^\s*tool_timeout_sec\s*=\s*(\d+(?:\.\d+)?)/m)?.[1];
+  return { lines, start, timeout: timeout === undefined ? undefined : Number(timeout), wait: /SEVERALLY_MAX_WAIT_MS\s*=\s*"?\d+/.test(block) };
+}
+
+// The wait follows the timeout Codex will enforce: 15 s under the user's own
+// tool_timeout_sec when that is short, else the full 600000 ms.
+function codexPlan() {
+  const sec = priorCodexTimeout ?? CODEX_TIMEOUT_SEC;
+  return { sec, ms: sec < 615 ? Math.max(0, Math.floor((sec - 15) * 1000)) : 600000 };
+}
+
+// Inserts tool_timeout_sec right after the table header. Returns why it could
+// not, or null.
+function writeCodexTimeout(sec) {
+  const t = codexTable();
+  if (t.reason) return t.reason;
+  if (t.timeout !== undefined) return null; // never overwrite the user's value
+  t.lines.splice(t.start + 1, 0, `tool_timeout_sec = ${sec}`);
+  try { fs.writeFileSync(codexConfig, t.lines.join('\n')); } catch (err) { return `cannot write ${codexConfig}: ${err.message}`; }
+  return null;
+}
+
 const claudeSkillsDir = path.join(home, '.claude', 'skills');
 
 // ---------------------------------------------------------------- clients
@@ -279,8 +322,35 @@ const CLIENTS = [
     label: 'Codex',
     backup: [path.join(codexHome, 'config.toml')],
     isRegistered: () => tryRun('codex', ['mcp', 'get', 'severally'], { real: true }).ok,
-    remove: () => tryRun('codex', ['mcp', 'remove', 'severally']),
-    add: (bin) => tryRun('codex', ['mcp', 'add', 'severally', '--', ...bin]),
+    remove: () => {
+      priorCodexTimeout = codexTable().timeout;
+      return tryRun('codex', ['mcp', 'remove', 'severally']);
+    },
+    // The long wait is the env plus tool_timeout_sec in config.toml, both or neither.
+    add: (bin) => {
+      const { sec, ms } = codexPlan();
+      const r = tryRun('codex', ['mcp', 'add', 'severally', '--env', `SEVERALLY_MAX_WAIT_MS=${ms}`, '--', ...bin]);
+      if (!r.ok) return r;
+      if (dryRun) {
+        log(`   [dry-run] write tool_timeout_sec = ${sec} into ${codexConfig} under [mcp_servers.severally]`);
+        return r;
+      }
+      const why = writeCodexTimeout(sec);
+      if (!why) {
+        log(`   consult_get waits up to ${ms / 1000} s (SEVERALLY_MAX_WAIT_MS=${ms}, tool_timeout_sec = ${sec})`);
+        return r;
+      }
+      const back = tryRun('codex', ['mcp', 'remove', 'severally']);
+      if (!back.ok) return back;
+      log(`   the long consult_get wait was not set (it stays 45 s): ${why}`);
+      return tryRun('codex', ['mcp', 'add', 'severally', '--', ...bin]);
+    },
+    keptNote: () => {
+      const t = codexTable();
+      if (t.timeout === undefined || !t.wait) {
+        log(`   this registration lacks the long consult_get wait (45 s); --force adds it (SEVERALLY_MAX_WAIT_MS and tool_timeout_sec = ${CODEX_TIMEOUT_SEC})`);
+      }
+    },
     skillFrom: path.join(PLUGIN, 'skills', 'codex', 'severally'),
     skillTo: path.join(codexHome, 'skills', 'severally'),
   },
@@ -297,7 +367,14 @@ const CLIENTS = [
       return r.ok && /severally/.test(r.out);
     },
     remove: () => tryRun('agy', ['mcp', 'remove', 'severally']),
-    add: (bin) => tryRun('agy', ['mcp', 'add', 'severally', ...bin]),
+    // agy stops an MCP tool call at 3 minutes, progress notifications or not
+    // (measured: a 310 s call ended at 180 s), so its wait is 15 s under that.
+    add: (bin) => tryRun('agy', ['mcp', 'add', '--env', AGY_WAIT, 'severally', ...bin]),
+    keptNote: () => {
+      if (!/SEVERALLY_MAX_WAIT_MS/.test(fs.existsSync(agyConfig) ? fs.readFileSync(agyConfig, 'utf8') : '')) {
+        log('   this registration lacks the longer consult_get wait (45 s); --force adds it (SEVERALLY_MAX_WAIT_MS=165000)');
+      }
+    },
     skillFrom: path.join(PLUGIN, 'skills', 'antigravity', 'severally'),
     skillTo: path.join(home, '.gemini', 'config', 'skills', 'severally'),
   },
@@ -326,7 +403,14 @@ const CLIENTS = [
     // reachable only inside whatever directory the installer happened to
     // run from.
     remove: () => ({ ok: true, out: 'opencode has no mcp remove; re-adding replaces the entry' }),
-    add: (bin) => tryRun('opencode', ['mcp', 'add', 'severally', '--global', '--', ...bin]),
+    // OpenCode sets no deadline of its own on a tool call (a 610 s call came
+    // back), so it gets the long consult_get wait with no timeout to pair.
+    add: (bin) => tryRun('opencode', ['mcp', 'add', 'severally', '--global', '--env', LONG_WAIT, '--', ...bin]),
+    keptNote: () => {
+      const text = [path.join(xdgConfig, 'opencode', 'opencode.json'), path.join(xdgConfig, 'opencode', 'opencode.jsonc')]
+        .map((f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return ''; } }).join('\n');
+      if (!text.includes('SEVERALLY_MAX_WAIT_MS')) log('   this registration lacks the long consult_get wait (45 s); --force adds it (SEVERALLY_MAX_WAIT_MS)');
+    },
     // A zero exit from `mcp add` can be a usage dump in disguise (see above),
     // so this client's registration is verified by listing after adding --
     // and the recorded command is compared against this install's.
@@ -381,6 +465,7 @@ function installClientDirectly(client, bin) {  step(`Registering with ${client.l
   if (client.isRegistered() && !force) {
     keptRegistrations = true;
     log('   already registered; leaving it as it is (use --force to re-register)');
+    client.keptNote?.();
   } else {
     if (client.isRegistered()) client.remove();
     const r = client.add(bin);

package/src/consultants.mjs

@@ -212,25 +212,41 @@ const clamp = (v, min, max) => Math.min(max, Math.max(min, v));
  * CLI's availability, decided by policy.mjs.
  */
 export function buildConsultants(config) {
+  // `problems` is every mistake, for the operator to read; `global` the ones
+  // that leave the whole file untrustworthy. A mistake inside one consultant
+  // or one CLI is kept to it: that consultant cannot be used (`broken`), that
+  // CLI is off (`brokenClis`) -- the closed side either way, so nothing the
+  // operator turned off comes back on.
   const problems = [];
+  const global = [];
+  const broken = {};
+  const brokenClis = {};
+  const fault = (msg) => { problems.push(msg); global.push(msg); };
   const cfg = isObject(config) ? config : {};
-  if (!isObject(config)) problems.push('the config file must hold a JSON object');
+  if (!isObject(config)) fault('the config file must hold a JSON object');
   for (const key of Object.keys(cfg)) {
-    if (!TOP_KEYS.includes(key)) problems.push(`unknown top-level key "${key}" (allowed: ${TOP_KEYS.join(', ')})`);
+    if (!TOP_KEYS.includes(key)) fault(`unknown top-level key "${key}" (allowed: ${TOP_KEYS.join(', ')})`);
+  }
+
+  // The one server key that is not a number to clamp: a wrong value cannot
+  // be read as either setting, and reading it as "on" would open the web.
+  if (isObject(cfg.server) && cfg.server.network !== undefined && !['on', 'off'].includes(cfg.server.network)) {
+    fault('server.network must be "on" or "off"');
   }
 
   let ranking = [];
   if (cfg.ranking !== undefined) {
     if (Array.isArray(cfg.ranking) && cfg.ranking.every((r) => typeof r === 'string' && r.trim() !== '')) ranking = cfg.ranking.map((r) => r.trim());
-    else problems.push('ranking must be an array of non-empty strings');
+    else fault('ranking must be an array of non-empty strings');
   }
 
   if (cfg.clis !== undefined) {
-    if (!isObject(cfg.clis)) problems.push('clis must be an object keyed by CLI');
+    if (!isObject(cfg.clis)) fault('clis must be an object keyed by CLI');
     else {
       for (const [id, def] of Object.entries(cfg.clis)) {
         if (!CLI_IDS.includes(id)) { problems.push(`clis.${id}: unknown CLI (known: ${CLI_IDS.join(', ')})`); continue; }
-        if (!isObject(def)) { problems.push(`clis.${id} must be an object`); continue; }
+        const before = problems.length;
+        if (!isObject(def)) { problems.push(`clis.${id} must be an object`); brokenClis[id] = problems.slice(before); continue; }
         for (const k of Object.keys(def)) if (!CLI_KEYS.includes(k)) problems.push(`clis.${id}.${k}: unknown key (allowed: ${CLI_KEYS.join(', ')})`);
         // A wrong type must not fall back to a default: enabled: "false"
         // read as "unset" would turn on the CLI the operator meant to stop.
@@ -242,6 +258,7 @@ export function buildConsultants(config) {
           if (id !== 'opencode') problems.push(`clis.${id}.provider: only OpenCode takes provider definitions`);
           else if (!(isObject(def.provider) && Object.values(def.provider).every(isObject))) problems.push(`clis.${id}.provider: must be an object of provider objects, as in opencode.json`);
         }
+        if (problems.length > before) brokenClis[id] = problems.slice(before);
       }
     }
   }
@@ -250,15 +267,15 @@ export function buildConsultants(config) {
   if (cfg.consultants === undefined) {
     for (const cli of CLI_IDS) consultants.push(make(cli, { cli, model: DEFAULT_MODELS[cli] }));
   } else if (!isObject(cfg.consultants)) {
-    problems.push('consultants must be an object keyed by name');
+    fault('consultants must be an object keyed by name');
   } else {
     const seen = new Map();
     for (const [name, def] of Object.entries(cfg.consultants)) {
       const at = `consultants.${name}`;
       if (!/^[a-z0-9][a-z0-9.-]{0,63}$/.test(name)) { problems.push(`${at}: a name is lower-case letters, digits, "." and "-", at most 64 characters`); continue; }
       if (RESERVED_NAMES.includes(name)) { problems.push(`${at}: "${name}" is reserved`); continue; }
-      if (!isObject(def)) { problems.push(`${at} must be an object`); continue; }
       const before = problems.length;
+      if (!isObject(def)) { problems.push(`${at} must be an object`); broken[name] = problems.slice(before); continue; }
       for (const k of Object.keys(def)) if (!CONSULTANT_KEYS.includes(k)) problems.push(`${at}.${k}: unknown key (allowed: ${CONSULTANT_KEYS.join(', ')})`);
       if (!CLI_IDS.includes(def.cli)) problems.push(`${at}.cli: must be one of ${CLI_IDS.join(', ')}`);
       if (typeof def.model !== 'string' || def.model.trim() === '') problems.push(`${at}.model: required`);
@@ -272,14 +289,18 @@ export function buildConsultants(config) {
       if (def.max_budget_usd !== undefined && def.cli !== 'claude-code') problems.push(`${at}.max_budget_usd: only a claude-code consultant has a budget`);
       // agy takes the effort from the model name and rejects --effort.
       if (def.effort !== undefined && def.cli === 'antigravity') problems.push(`${at}.effort: Antigravity takes the effort from the model name (e.g. gemini-3.8-flash-low)`);
-      if (problems.length > before) continue;
+      if (problems.length > before) { broken[name] = problems.slice(before); continue; }
       const pair = `${def.cli}\n${def.model.trim()}`;
-      if (seen.has(pair)) { problems.push(`${at}: same cli and model as consultants.${seen.get(pair)}; asking one model twice adds no independence`); continue; }
+      if (seen.has(pair)) {
+        problems.push(`${at}: same cli and model as consultants.${seen.get(pair)}; asking one model twice adds no independence`);
+        broken[name] = problems.slice(before);
+        continue;
+      }
       seen.set(pair, name);
       consultants.push(make(name, def));
     }
   }
-  return { consultants: Object.freeze(consultants), ranking: Object.freeze(ranking), problems };
+  return { consultants: Object.freeze(consultants), ranking: Object.freeze(ranking), problems, global, broken, brokenClis };
 }
 
 function make(name, def) {

package/src/jobs.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,
@@ -334,11 +363,19 @@ export class JobManager {
       parent = { ...parent, nextRound: Math.max(...rounds.map((j) => j.round)) + 1 };
     }
 
+    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(
@@ -363,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: {
@@ -373,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}`
@@ -550,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;
@@ -891,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);
       }
 
@@ -916,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 {
@@ -928,6 +984,7 @@ export class JobManager {
         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
@@ -1183,16 +1240,31 @@ export class JobManager {
     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') {
@@ -1309,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
@@ -1484,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 = [];
@@ -1491,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`);
   }

package/src/policy.mjs

@@ -35,21 +35,50 @@ const CONFIG = (() => {
   }
 })();
 
-// Every mistake in the file, not only a syntax error. A config with any of
-// them is not run on defaults: the server still starts, so the operator can
-// read why, but every consultation is refused (jobs.mjs) -- falling back would
-// quietly re-enable a CLI the operator turned off.
+// A mistake that leaves the whole file untrustworthy (unreadable, an unknown
+// top-level key, a section of the wrong shape) is not run on defaults: the
+// server still starts, so the operator can read why, but every consultation is
+// refused (jobs.mjs) -- falling back would quietly re-enable a CLI the
+// operator turned off. A mistake inside one consultant or one CLI only takes
+// that one out of use, with the reason.
 const BUILT = buildConsultants(CONFIG);
-if (!configError && BUILT.problems.length) configError = `${CONFIG_PATH}: ${BUILT.problems.join('; ')}`;
+if (!configError && BUILT.global.length) configError = `${CONFIG_PATH}: ${BUILT.global.join('; ')}`;
+// A value that is neither, from the environment, cannot be read as either: reading it as "on" would open the web.
+if (!configError && ![undefined, '', 'on', 'off'].includes(process.env.SEVERALLY_NETWORK)) {
+  configError = `SEVERALLY_NETWORK must be "on" or "off", not ${JSON.stringify(process.env.SEVERALLY_NETWORK)}`;
+}
 const FROM = configError ? buildConsultants({}) : BUILT;
+const LOCAL = configError ? [] : BUILT.problems.filter((p) => !BUILT.global.includes(p));
 
-/** What is wrong with the config file, or null. Reported at startup; while set, nothing can be started. */
+/** What is wrong with the config file as a whole, or null. Reported at startup; while set, nothing can be started. */
 export function configProblem() {
   return configError;
 }
 
+/** The mistakes kept to one consultant or one CLI, each of which is out of use until fixed. */
+export function configWarnings() {
+  return LOCAL.map((p) => `${CONFIG_PATH}: ${p}`);
+}
+
+/** The names of the consultants out of use because of a mistake in their own config section. */
+export function brokenConsultantNames() {
+  return configError ? [] : Object.keys(BUILT.broken);
+}
+
+/** Why the consultant of this name is out of use because of a config mistake, or null. */
+export function brokenConsultant(name) {
+  const p = !configError && Object.hasOwn(BUILT.broken, name) ? BUILT.broken[name] : null;
+  return p ? `the config file has a mistake in it: ${p.join('; ')}` : null;
+}
+
 const usable = configError ? {} : CONFIG;
-const cfgCli = (id) => (usable.clis && typeof usable.clis === 'object' ? usable.clis[id] ?? {} : {});
+// A CLI whose own section has a mistake is off, whatever else the section says.
+const cfgCli = (id) => {
+  if (Object.hasOwn(BUILT.brokenClis, id) && !configError) {
+    return { enabled: false, note: `turned off: the config file has a mistake in clis.${id}: ${BUILT.brokenClis[id].join('; ')}` };
+  }
+  return usable.clis && typeof usable.clis === 'object' ? usable.clis[id] ?? {} : {};
+};
 const cfgServer = usable.server && typeof usable.server === 'object' ? usable.server : {};
 
 /**
@@ -218,6 +247,10 @@ export const POLICY = Object.freeze({
   // clients allow a tool call, so a long wait does not blow up as a client-side
   // timeout while the consultation is still healthy; a client registration
   // that is known to wait longer raises it (scripts/install.mjs).
+  // "off" takes the web away from every consultation, whatever the request
+  // asks; "on" leaves it to each request's own network.
+  // Either source can close it; neither can reopen what the other closed.
+  network: [process.env.SEVERALLY_NETWORK, cfgServer.network].includes('off') ? 'off' : 'on',
   maxWaitMs: limit('SEVERALLY_MAX_WAIT_MS', cfgServer.max_wait_ms, 45_000, 0, 600_000),
 
   input: Object.freeze({
@@ -389,11 +422,15 @@ export function limitsSummary() {
   const by = (f) => Object.fromEntries(list.map((c) => [c.name, f(c)]));
   return {
     available_targets: list.map((c) => c.name),
+    // A consultant or CLI out of use because of a mistake in its own section.
+    ...(LOCAL.length ? { config_mistakes: configWarnings() } : {}),
     clis: by((c) => c.cli),
     models: by((c) => c.model),
     // Per consultant, because they no longer share one budget.
     timeout_ms: by(timeoutMs),
     max_rounds_per_chain: POLICY.maxRounds,
+    // "off": the operator has taken the web away from every consultation.
+    network: POLICY.network,
     max_concurrent_jobs: POLICY.maxConcurrent,
     max_wait_ms: POLICY.maxWaitMs,
     input_char_budget: POLICY.input.totalCharsMax,

package/src/run.mjs

@@ -164,15 +164,21 @@ export class ProcHandle {
     this.stdoutSoFar = readStdout;
   }
 
-  /** Kill the child and every descendant it spawned. */
+  /**
+   * Kill the child and every descendant it spawned -- also after the child
+   * itself has exited: a descendant still holding its pipes keeps the
+   * consultation from closing, and on POSIX it is still in the group.
+   */
   stop(signal = 'SIGTERM') {
-    if (this.killed || !this.child || this.child.exitCode !== null) return;
+    if (this.killed || !this.child) return;
     this.killed = true;
     const pid = this.child.pid;
     if (!pid) return;
     if (process.platform === 'win32') {
       // Negative PIDs/process groups are POSIX-only. Kill the Windows tree
-      // before its parent exits and its descendants become unreachable.
+      // before its parent exits and its descendants become unreachable. Once
+      // it has exited, its pid may already be another process's: leave it.
+      if (this.child.exitCode !== null || this.child.signalCode !== null) return;
       const killer = spawn(path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'taskkill.exe'),
         ['/pid', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
       const fallback = () => { try { this.child.kill('SIGKILL'); } catch { /* gone */ } };
@@ -201,6 +207,12 @@ export class ProcHandle {
 /**
  * @returns {{handle: ProcHandle, done: Promise<{code, signal, stdout, stderr, timedOut, cancelled, truncated}>}}
  */
+/**
+ * `pipesForced` in the result: the child exited but something it started kept
+ * stdout or stderr open past the kill grace, so the group was stopped and the
+ * pipes closed from this side. A descendant outside the group (setsid, or on
+ * Windows once the parent is gone) may still be running.
+ */
 export function runChild({ command, args, cwd, env, input, timeoutMs, onCancelSignal, compactLine = null,
   settleAfter = null, stopSignal = 'SIGTERM' }) {
   const child = spawn(command, args, {
@@ -288,16 +300,37 @@ export function runChild({ command, args, cwd, env, input, timeoutMs, onCancelSi
 
   const done = new Promise((resolve) => {
     let settled = false;
+    let pipesForced = false;
+    let orphanTimer = null;
     const finish = (payload) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
       clearTimeout(settleTimer);
-      resolve({ stdout, stderr, truncated, timedOut, cancelled, stalled, ...payload });
+      clearTimeout(orphanTimer);
+      resolve({ stdout, stderr, truncated, timedOut, cancelled, stalled, pipesForced, ...payload });
     };
+    const flushPending = () => { if (byLine && pending) { append('out', compact(pending)); pending = ''; } };
     child.on('error', (err) => finish({ code: null, signal: null, spawnError: err.message }));
+    // 'close' waits for the pipes as well as the child. Once the child has
+    // exited, a grace later the rest of its group is stopped, and a grace
+    // after that the pipes are closed from here, whoever still holds them.
+    child.on('exit', (code, signal) => {
+      const grace = POLICY.killGraceMs;
+      orphanTimer = setTimeout(() => {
+        pipesForced = true;
+        handle.stop(stopSignal);
+        orphanTimer = setTimeout(() => {
+          handle.forceKill();
+          flushPending();
+          child.stdout.destroy();
+          child.stderr.destroy();
+          finish({ code, signal });
+        }, grace);
+      }, grace);
+    });
     child.on('close', (code, signal) => {
-      if (byLine && pending) { append('out', compact(pending)); pending = ''; }
+      flushPending();
       finish({ code, signal });
     });
   });