severally-mcp 2.0.0 → 2.1.0

package/src/expose-paths.mjs

@@ -105,6 +105,12 @@ function walkDir(root, dir, onFile, totals, skipped) {
   }
   for (const item of items) {
     const child = path.join(dir, item.name);
+    // Outside git there is no .gitignore to say what is not source: these two
+    // are never what a consultant should read, and would hit the caps alone.
+    if (item.name === '.git' || item.name === 'node_modules') {
+      skipped.push({ source: child, reason: 'ignored' });
+      continue;
+    }
     // Not followed: a link inside a directory the lead exposed can resolve
     // anywhere on the disk, which is exactly the scope this feature exists
     // to keep drawn. Recorded rather than dropped silently, so a consultant
@@ -130,6 +136,61 @@ function walkDir(root, dir, onFile, totals, skipped) {
   }
 }
 
+// walkDir's order: name by name at every level, not the whole path as one
+// string ("a/x" comes before "a-b" there, after it as a string).
+function byPathParts(a, b) {
+  const x = a.split('/');
+  const y = b.split('/');
+  for (let i = 0; i < Math.min(x.length, y.length); i++) if (x[i] !== y[i]) return x[i] < y[i] ? -1 : 1;
+  return x.length - y.length;
+}
+
+// A directory inside a git work tree: the candidates are what git lists
+// (tracked, plus untracked that .gitignore does not exclude), so `.git` and
+// ignored trees drop out. Every candidate gets walkDir's checks again -- a
+// committed .env is still protected, a listed file may be gone, a link, a
+// submodule, or reach outside the directory. False when this is not a work
+// tree, git is missing or lists nothing (an ignored directory the lead named
+// on purpose): the caller walks it instead.
+function walkGit(dir, exposedAs, onFile, totals, skipped) {
+  let listed;
+  let ignored;
+  try {
+    listed = [...new Set(nulSplit(git(dir, ['ls-files', '-z', '--cached', '--others', '--exclude-standard'])))];
+    ignored = nulSplit(git(dir, ['ls-files', '-z', '--others', '--ignored', '--exclude-standard', '--directory']));
+  } catch { return false; }
+  if (listed.length === 0) return false;
+  for (const p of ignored) skipped.push({ source: path.join(dir, p), reason: 'ignored' });
+  if (fs.existsSync(path.join(dir, '.git'))) skipped.push({ source: path.join(dir, '.git'), reason: 'ignored' });
+  const realDir = fs.realpathSync(dir);
+  const protectedDirs = new Set();
+  for (const rel of listed.sort(byPathParts)) {
+    const abs = path.join(dir, rel);
+    // walkDir never enters a protected directory (.env.d/, .ssh/ ...); a
+    // listed file is checked with each directory above it for the same reason.
+    const parts = rel.split('/');
+    const guarded = parts.slice(0, -1).map((_, i) => path.join(dir, ...parts.slice(0, i + 1))).find(isProtectedPath);
+    if (guarded) {
+      if (!protectedDirs.has(guarded)) skipped.push({ source: guarded, reason: 'protected' });
+      protectedDirs.add(guarded);
+      continue;
+    }
+    if (isProtectedPath(abs)) { skipped.push({ source: abs, reason: 'protected' }); continue; }
+    let stat;
+    // Deleted in the work tree but still in the index: not part of the tree
+    // as it is now, so not part of the copy either.
+    try { stat = fs.lstatSync(abs); } catch { continue; }
+    // A directory here is a submodule (or a nested repository): its own history, not this one's files.
+    if (stat.isDirectory()) { skipped.push({ source: abs, reason: 'submodule' }); continue; }
+    const inside = (() => { try { return fs.realpathSync(abs).startsWith(realDir + path.sep); } catch { return false; } })();
+    if (stat.isSymbolicLink() || !inside) { skipped.push({ source: abs, reason: 'symlink' }); continue; }
+    if (!stat.isFile()) continue;
+    onFile(abs, path.normalize(rel));
+    checkBudget(totals);
+  }
+  return true;
+}
+
 // Each path is a string, or { source, index } to keep the name an earlier
 // round gave it.
 function walkEntries(exposePaths, onFile) {
@@ -138,6 +199,9 @@ function walkEntries(exposePaths, onFile) {
   const entries = exposePaths.map((p, i) => {
     const { source, index } = typeof p === 'string' ? { source: p, index: i } : p;
     const stat = statEntry(source);
+    // Indexed, so two entries whose basenames collide (two different
+    // util.mjs) stay apart, and the brief can name each one exactly.
+    const exposedAs = `workspace/${index}-${path.basename(source)}`;
     const before = { files: totals.files, bytes: totals.bytes };
     // What a directory holds, for the brief: not every consultant has a tool
     // that lists a directory, and a name it cannot see is a file it never reads.
@@ -148,18 +212,17 @@ function walkEntries(exposePaths, onFile) {
       onFile(source, '', index, source, totals);
       checkBudget(totals);
     } else {
-      walkDir(source, source, (abs, rel) => {
+      const add = (abs, rel) => {
         paths.push(rel.split(path.sep).join('/'));
         onFile(abs, rel, index, source, totals);
-      }, totals, skipped);
+      };
+      walkGit(source, exposedAs, add, totals, skipped) || walkDir(source, source, add, totals, skipped);
     }
     return {
       index,
       source,
       kind: stat.isDirectory() ? 'directory' : 'file',
-      // Indexed, so two entries whose basenames collide (two different
-      // util.mjs) stay apart, and the brief can name each one exactly.
-      exposedAs: `workspace/${index}-${path.basename(source)}`,
+      exposedAs,
       files: totals.files - before.files,
       bytes: totals.bytes - before.bytes,
       paths: paths.sort(),

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';
@@ -296,7 +296,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 +334,18 @@ 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 });
+    const req = parseRequest(rawRequest, {
+      isFollowup: Boolean(parent || fromGroup),
+      parentMode: parent?.mode ?? fromGroup?.group.mode ?? null,
+      groupFollowup: Boolean(fromGroup),
+    });
 
+    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 +353,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',
@@ -361,14 +383,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 +493,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 +528,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.
@@ -500,14 +566,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 +582,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 +618,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 +629,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 +643,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 +704,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 +850,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.
@@ -834,7 +924,11 @@ 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)}`,
+      ].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,34 +1148,36 @@ 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;
@@ -1182,7 +1278,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 +1291,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);
   }
@@ -1321,6 +1417,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),

package/src/policy.mjs

@@ -214,9 +214,10 @@ export const POLICY = Object.freeze({
   // going beyond that is an operator decision with quota to match.
   maxConcurrent: limit('SEVERALLY_MAX_CONCURRENT', cfgServer.max_concurrent, 9, 1, 9),
   maxJobsRetained: limit('SEVERALLY_MAX_JOBS_RETAINED', cfgServer.max_jobs_retained, 200, 20, 2000),
-  // Upper bound for consult_get(wait_ms). Deliberately under the 60s default
-  // request timeout that MCP clients apply, so a long wait does not blow up as
-  // a client-side timeout while the consultation is still healthy.
+  // Upper bound for consult_get(wait_ms). 45 s stays under the 60 s some MCP
+  // 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).
   maxWaitMs: limit('SEVERALLY_MAX_WAIT_MS', cfgServer.max_wait_ms, 45_000, 0, 600_000),
 
   input: Object.freeze({
@@ -261,7 +262,7 @@ export const POLICY = Object.freeze({
  * different request, not a slower one.
  */
 export function timeoutMs(consultant) {
-  return consultant?.timeoutMs ?? limit('SEVERALLY_TIMEOUT_MS', cfgServer.timeout_ms, 3_600_000, 1_000, 7_200_000);
+  return consultant?.timeoutMs ?? limit('SEVERALLY_TIMEOUT_MS', cfgServer.timeout_ms, 1_800_000, 1_000, 7_200_000);
 }
 
 /**

package/src/redact.mjs

@@ -1,6 +1,19 @@
 // Credential scrubbing. Applied on the way out (brief sent to the consultant),
 // on the way in (consultant output), and to everything persisted to disk.
 
+const CODE_WORDS = new Set(['true', 'false', 'null', 'none', 'undefined', 'string', 'str', 'number', 'boolean', 'bool', 'int', 'bytes']);
+
+// A password-type value that is code, not a secret: a flag or a type, a
+// variable reference (${X}, $X, process.env.X, os.environ[...]), and -- unless
+// it is a long value under a full PASSWORD/PASSWD name, which stays masked
+// whatever it looks like -- a dotted name, a call or a borrow (&str).
+function looksLikeCode(name, value) {
+  if (CODE_WORDS.has(value.toLowerCase()) || value.startsWith('${') || /^\$[A-Z_][A-Z0-9_]*$/.test(value)
+    || /^(?:process\.env\.|os\.environ\b)/.test(value)) return true;
+  if (value.length >= 8 && /^PASSW(?:OR)?D$/i.test(name.split('_').at(-1))) return false;
+  return /^[A-Za-z_][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/.test(value) || /^[A-Za-z_][\w$.]*\(/.test(value) || value.startsWith('&');
+}
+
 const PATTERNS = [
   // Provider API keys
   [/\bsk-ant-[A-Za-z0-9_\-]{12,}/g, '[REDACTED:anthropic-key]'],
@@ -9,6 +22,7 @@ const PATTERNS = [
   [/\bgh[pousr]_[A-Za-z0-9]{16,}/g, '[REDACTED:github-token]'],
   [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, '[REDACTED:github-token]'],
   [/\bxox[baprs]-[A-Za-z0-9-]{10,}/g, '[REDACTED:slack-token]'],
+  [/https:\/\/hooks\.slack\.com\/services\/T[A-Za-z0-9]+\/B[A-Za-z0-9]+\/[A-Za-z0-9]+/g, '[REDACTED:slack-webhook]'],
   [/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED:aws-access-key-id]'],
   [/\bASIA[0-9A-Z]{16}\b/g, '[REDACTED:aws-access-key-id]'],
   [/\bAIza[0-9A-Za-z_\-]{30,}/g, '[REDACTED:google-api-key]'],
@@ -25,8 +39,13 @@ const PATTERNS = [
   // The password in a URL's userinfo, also with an empty user (redis://:pass@host)
   [/(:\/\/[^\s:/@]*:)[^\s@/]+(@)/g, '$1[REDACTED]$2'],
   // KEY=value / "token": "value" style assignments
-  [/\b((?:[A-Za-z0-9_]*_)?(?:API_KEY|APIKEY|ACCESS_KEY|PRIVATE_KEY|ACCESS_TOKEN|REFRESH_TOKEN|ID_TOKEN|SECRET_KEY|CLIENT_SECRET|AUTH_TOKEN|CREDENTIALS|PASSWORD|PASSWD|SECRET|TOKEN))(["']?\s*[:=]\s*["']?)([^\s"',;)]{8,})/gi,
+  [/\b((?:[A-Za-z0-9_]*_)?(?:API_KEY|APIKEY|ACCESS_KEY|PRIVATE_KEY|ACCESS_TOKEN|REFRESH_TOKEN|ID_TOKEN|SECRET_KEY|CLIENT_SECRET|AUTH_TOKEN|CREDENTIALS|ACCOUNTKEY|SHAREDACCESSKEY|SECRET|TOKEN))(["']?\s*[:=]\s*["']?)([^\s"',;)]{8,})/gi,
     (_m, k, sep, _v) => `${k}${sep}[REDACTED]`],
+  // Password-type names, with values from 4 characters; PASS and PWD too (PWD
+  // only after `_` or a letter: bare PWD is the working directory). What reads
+  // as code rather than a password is left alone (looksLikeCode).
+  [/\b((?:[A-Za-z0-9_]*_)?(?:PASSWORD|PASSWD|PASS|(?<=[A-Za-z_])PWD))(["']?\s*[:=]\s*["']?)([^\s"',;)]{4,})/gi,
+    (m, k, sep, v) => (looksLikeCode(k, v) ? m : `${k}${sep}[REDACTED]`)],
   // Any environment variable named *_KEY. Upper case only: in code, primary_key,
   // sort_key and idempotency_key name things, not secrets.
   [/\b([A-Z0-9_]+_KEY)(\s*=\s*["']?)([^\s"',;)]{8,})/g, (_m, k, sep, _v) => `${k}${sep}[REDACTED]`],

package/src/schema.mjs

@@ -147,9 +147,10 @@ export class RequestError extends Error {
 
 /**
  * Validate + normalise a consult request.
- * `isFollowup` is decided by the caller (the job store resolves followup_to first).
+ * `isFollowup` is decided by the caller (the job store resolves followup_to first);
+ * `groupFollowup` when followup_to named a fan-out, whose members are the targets.
  */
-export function parseRequest(raw, { isFollowup = false, parentMode = null } = {}) {
+export function parseRequest(raw, { isFollowup = false, parentMode = null, groupFollowup = false } = {}) {
   const parsed = requestSchema.safeParse(raw);
   if (!parsed.success) {
     const issues = parsed.error.issues.map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`);
@@ -220,9 +221,9 @@ export function parseRequest(raw, { isFollowup = false, parentMode = null } = {}
       'duplicate_targets',
     );
   }
-  if (isFollowup && unique.length > 1) {
+  if (isFollowup && !groupFollowup && unique.length > 1) {
     throw new RequestError(
-      'a follow-up continues the exchange with one consultant; name exactly one target',
+      'a follow-up to a job continues the exchange with one consultant; name exactly one target, or pass followup_to a group_id to ask every member of that fan-out again',
       'followup_fanout_not_allowed',
     );
   }