amicus 4.0.1 → 4.1.1

package/src/council/run-debate.js

@@ -0,0 +1,293 @@
+// src/council/run-debate.js
+'use strict';
+
+/**
+ * @module council/run-debate
+ * Impure Stage-2.5 orchestration for headless debate mode (spec §5.1). Launches the
+ * defense mini-wave (one solo per raiser) and the re-vote mini-wave (one fanout to
+ * disputing judges), parses each with one bounded repair, then hands off to the pure
+ * reassembly in ./debate.js. Launchers are injected via ctx (repo DI pattern).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const dbrief = require('./briefings-debate');
+const { parseDebateDefense, parseRevote } = require('./parse-stage2');
+const { applyDebate, debateRunStatsRows, PAST_TENSE } = require('./debate');
+const { materializeDebate } = require('./run-launch');
+const { tally } = require('./tally');
+const { isAbortExit } = require('./run-stages');
+const runState = require('./run-state');
+
+/** Spec §5.7 fallback: a dead/unparseable defense means every bundled id's original stands. */
+function allNoResponse(ids) {
+  const byId = {};
+  for (const id of ids) { byId[id] = { action: 'no-response' }; }
+  return byId;
+}
+
+/** True when there is nothing to challenge (spec §5.1). */
+function nothingToDebate(provisionalRecord) {
+  if (!provisionalRecord || provisionalRecord.judged === false) { return true; }
+  const n = provisionalRecord.findings.filter(f => f.tier === 'Contested' || f.tier === 'Disputed').length;
+  return n === 0;
+}
+
+/** Judges whose provisional adjudications dispute at least one bundled id. */
+function disputingJudges(provisionalRecord, bundledIds) {
+  const ids = new Set(bundledIds);
+  const judges = new Set();
+  for (const f of provisionalRecord.findings) {
+    if (!ids.has(f.id)) { continue; }
+    for (const adj of f.adjudications || []) {
+      if (adj.verdict === 'dispute') { judges.add(adj.judge); }
+    }
+  }
+  return [...judges];
+}
+
+/** Group Contested+Disputed findings by raiser (defense targets). */
+function debateTargets(provisionalRecord, tallyInput) {
+  const claimById = new Map(tallyInput.findings.map(f => [f.id, f]));
+  const byRaiser = {};
+  const previousTier = {};
+  for (const f of provisionalRecord.findings) {
+    if (f.tier !== 'Contested' && f.tier !== 'Disputed') { continue; }
+    previousTier[f.id] = f.tier;
+    const src = claimById.get(f.id) || {};
+    const peerVerdicts = (f.adjudications || []).filter(a => a.judge !== f.raiser).map(a => a.verdict);
+    (byRaiser[f.raiser] = byRaiser[f.raiser] || []).push({ id: f.id, claim: src.claim,
+      severity: f.severity, location: src.location, peerVerdicts, disputeReasons: [] });
+  }
+  return { byRaiser, previousTier };
+}
+
+/** Common launch options for every debate leg (judge-isolated `_scratch` cwd). */
+function legOpts(ctx, waveId) {
+  return { project: ctx.scratchDir, waveId, timeout: ctx.o.timeout, gateway: ctx.o.gateway,
+    noValidateModel: ctx.o.noValidateModel, noCostGate: ctx.o.noCostGate };
+}
+
+async function runDefenseSolo(ctx, raiser, findings, idx) {
+  const brief = dbrief.buildDefenseBrief({ findings, date: ctx.o.date });
+  const waveId = `${ctx.o.runId}-d${idx + 1}`;
+  const expectedIds = findings.map(f => f.id);
+  // Record the sub-wave BEFORE launching: `amicus abort` cascades over stages[].waveIds
+  // (run-stages.js's record(), run-chair.js's chair chain), so an id written after the
+  // launch leaves an in-flight leg reachable only by the pid kill. The v4.0.1
+  // abort-cascade fix must hold for debate stages too.
+  runState.appendStageWave(ctx.o.runDir, 'debate-defense', waveId);
+  const res = await ctx.launchers.launchSolo({ ...legOpts(ctx, waveId), model: raiser, prompt: brief });
+  ctx.addWave(res.wave);
+  if (isAbortExit(res.exitCode)) { return { raiser, aborted: res.exitCode }; }
+  let leg = res.leg && res.leg.status === 'complete' ? res.leg : null;
+  // A dead leg gets the SAME spec §5.7 fallback the parser applies to a block-level
+  // failure — every expected id 'no-response', never an empty map, so the
+  // originals-stand outcome still reaches debate.json and the record decoration.
+  let parsed = leg ? parseDebateDefense(leg.summary, expectedIds)
+    : { ok: false, byId: allNoResponse(expectedIds), errors: [{ code: 'DEAD_LEG', detail: 'no summary' }] };
+  let conformance = leg ? 'clean' : 'unstructured';
+  if (leg && !parsed.ok) {
+    const repairId = `${waveId}r`;
+    runState.appendStageWave(ctx.o.runDir, 'debate-defense', repairId);
+    const res2 = await ctx.launchers.launchSolo({
+      ...legOpts(ctx, repairId), model: raiser,
+      prompt: dbrief.buildDefenseRepairPrompt({ errors: parsed.errors }),
+    });
+    ctx.addWave(res2.wave);
+    if (isAbortExit(res2.exitCode)) { return { raiser, aborted: res2.exitCode }; }
+    const leg2 = res2.leg && res2.leg.status === 'complete' ? res2.leg : null;
+    parsed = leg2 ? parseDebateDefense(leg2.summary, expectedIds) : parsed;
+    conformance = parsed.ok ? 'repaired' : 'unstructured';
+    if (leg2) { leg = leg2; }
+  }
+  // A dead leg (no complete summary) OR an 'unstructured' conformance after the one
+  // repair is a debate degradation (spec §5.7) — surfaced via the returned leg.
+  const stub = { model: raiser, status: 'error', durationMs: null, usage: null, conformance: 'unstructured', summary: '' };
+  return { raiser, byId: parsed.byId,
+    leg: leg ? { model: raiser, status: leg.status, durationMs: leg.durationMs, usage: leg.usage, conformance, summary: leg.summary } : stub };
+}
+
+async function runRevoteWave(ctx, judges, bundleFindings) {
+  const bundle = dbrief.buildRevoteBundle({ findings: bundleFindings, date: ctx.o.date });
+  // spec §5.1 names `revote-bundle.md` a run-dir artifact: the shared re-vote prompt goes to
+  // disk exactly like Stage 2's bundle-stage2.md, so the round's model-facing input is
+  // auditable alongside briefing-stage1.md and chair-packet.md.
+  fs.writeFileSync(path.join(ctx.o.runDir, 'revote-bundle.md'), bundle, { mode: 0o600 });
+  const waveId = `${ctx.o.runId}-rv`;
+  const expectedIds = bundleFindings.map(f => f.id);
+  // run-debate — not run.js — owns this stage's `running` checkpoint AND its abort-cascade
+  // id: only this function knows whether the wave actually launched (it is skipped when
+  // nothing was defended/amended, or the cost ceiling hit).
+  runState.updateStage(ctx.o.runDir, 'debate-revote',
+    { status: 'running', startedAt: new Date().toISOString(), project: ctx.scratchDir, waveId });
+  runState.appendStageWave(ctx.o.runDir, 'debate-revote', waveId);
+  const res = await ctx.launchers.launchWave({ ...legOpts(ctx, waveId), models: judges, prompt: bundle });
+  ctx.addWave(res.wave);
+  if (isAbortExit(res.exitCode)) { return { aborted: res.exitCode }; }
+  const byJudge = {}, legs = [];
+  for (const leg of ((res.wave && res.wave.legs) || [])) {
+    // The council ALIAS, not the resolved executable id — runStats rows join
+    // meta.models by exact string (run-assemble.js's buildRunStatsEntry).
+    const judge = leg.modelInput || leg.model;
+    const alive = leg.status === 'complete' && leg.summary;
+    let outLeg = leg;               // the leg actually recorded (post-repair when there is one)
+    let parsed = alive ? parseRevote(leg.summary, expectedIds)
+      : { ok: false, byId: {}, errors: [{ code: 'DEAD_LEG', detail: 'no summary' }] };
+    let conformance = alive ? 'clean' : 'unstructured';
+    if (alive && !parsed.ok) {
+      // One repair, solo, to that judge.
+      const repairId = `${waveId}-${judge}r`;
+      runState.appendStageWave(ctx.o.runDir, 'debate-revote', repairId);
+      const r2 = await ctx.launchers.launchSolo({ ...legOpts(ctx, repairId), model: judge,
+        prompt: dbrief.buildRevoteRepairPrompt({ errors: parsed.errors }) });
+      ctx.addWave(r2.wave);
+      if (isAbortExit(r2.exitCode)) { return { aborted: r2.exitCode }; }
+      const leg2 = r2.leg && r2.leg.status === 'complete' ? r2.leg : null;
+      parsed = leg2 ? parseRevote(leg2.summary, expectedIds) : parsed;
+      conformance = parsed.ok ? 'repaired' : 'unstructured';
+      // Symmetric with runDefenseSolo's `if (leg2) { leg = leg2; }` — otherwise
+      // revote-<model>.md and the runStats row keep the PRE-repair output.
+      if (leg2) { outLeg = leg2; }
+    }
+    byJudge[judge] = parsed.byId;
+    legs.push({ model: judge, status: outLeg.status, durationMs: outLeg.durationMs, usage: outLeg.usage, conformance, summary: outLeg.summary || '' });
+  }
+  return { byJudge, legs };
+}
+
+/** The re-vote bundle: defended-or-amended findings ONLY (spec §5.1 — withdrawn never appear). */
+function bundleFor(defenseResults, tallyInput) {
+  const out = [];
+  for (const dr of defenseResults) {
+    for (const [id, resp] of Object.entries(dr.byId)) {
+      if (resp.action !== 'defend' && resp.action !== 'amend') { continue; }
+      const src = tallyInput.findings.find(f => f.id === id) || {};
+      out.push({ id, severity: src.severity, amended: resp.action === 'amend',
+        claim: resp.action === 'amend' ? resp.claim : src.claim,
+        argument: resp.argument || 'defended without extra argument' });
+    }
+  }
+  return out;
+}
+
+/**
+ * Full Stage-2.5 sequence (spec §5.1). Returns everything run.js needs. Cost gate: run.js
+ * checks overBudget before invoking; this checks again before the re-vote wave (spec §5.7).
+ * @param {object} ctx run.js's {o, launchers, addWave, overBudget, scratchDir}
+ * @param {{provisionalRecord: object, tallyInput: object}} args
+ */
+async function runDebate(ctx, { provisionalRecord, tallyInput }) {
+  const { byRaiser, previousTier } = debateTargets(provisionalRecord, tallyInput);
+  const contested = provisionalRecord.findings.filter(f => f.tier === 'Contested').length;
+  const disputed = provisionalRecord.findings.filter(f => f.tier === 'Disputed').length;
+
+  // ---- Defense mini-wave: ONE CONCURRENT solo per raiser (spec §5.1) ----
+  // Concurrent, not sequential: every raiser gets its OWN briefing, so this is N independent
+  // solos rather than one fanout wave. No per-leg budget check interleaves between them — the
+  // cost ceiling is a WHOLE-ROUND gate run.js applies BEFORE calling runDebate
+  // ('skipped-cost-ceiling' is a round-level outcome in spec §5.1's enum, not a per-leg one).
+  // `appendStageWave` is sync fs and each solo registers its waveId before its first await,
+  // so concurrency cannot interleave a read-modify-write of run.json.
+  // v4.1 §4.4: the reserved seat 'claude' is a FILE-sourced review with no leg to
+  // launch, so it is never asked to defend — its contested findings simply stand
+  // (the same "originals stand" outcome as a no-response).
+  const raisers = Object.keys(byRaiser).filter(m => m !== 'claude');
+  const defenseResults = await Promise.all(
+    raisers.map((raiser, i) => runDefenseSolo(ctx, raiser, byRaiser[raiser], i)));
+  // A signal during the defense wave aborts the whole finalization (spec §5.7):
+  // return the abort code so run.js finalizes 'aborted' with NO tally-final / NO ledger.
+  const abortedDefense = defenseResults.find(d => d.aborted);
+  if (abortedDefense) { return { aborted: abortedDefense.aborted, contested, disputed }; }
+  materializeDebate(ctx.o.runDir, defenseResults.map(d => ({ model: d.raiser, summary: d.leg.summary })), 'rebuttal');
+
+  const defenseByRaiser = {};
+  for (const dr of defenseResults) { defenseByRaiser[dr.raiser] = { ...dr.byId }; }
+  // v4.1 §4.4: claude never gets a defense leg (raisers filter above), but its
+  // contested/disputed findings still need an audit trail — the SAME spec §5.7
+  // "originals stand" fallback a dead/unrepaired defense leg gets. Seeded into
+  // defenseByRaiser ONLY (never defenseResults, which feeds the `bad(l)`
+  // degraded check below — a claude entry there would wrongly flip a clean run
+  // to degraded/exit 2).
+  if (byRaiser.claude) { defenseByRaiser.claude = allNoResponse(byRaiser.claude.map(f => f.id)); }
+  // Stamp previousTier onto the tally input: applyDebate reads it off tallyInput.findings[]
+  // (it ignores the provisional record), so without this every row's previousTier is null.
+  const stampedInput = { ...tallyInput, findings: tallyInput.findings.map(f => ({ ...f, previousTier: previousTier[f.id] })) };
+
+  // ---- Re-vote mini-wave (disputing judges only) ----
+  let revoteByJudge = {}, revoteLegs = [];
+  const defendedOrAmended = bundleFor(defenseResults, tallyInput);
+  const judges = disputingJudges(provisionalRecord, defendedOrAmended.map(f => f.id));
+  // A re-vote is warranted only when something was defended/amended AND ≥1 judge disputed it.
+  // Skipping THAT case because the whole-run budget is spent is the 'skipped-cost-ceiling'
+  // degradation branch (spec §5.7); skipping because there is simply nothing to re-vote is NOT.
+  const wouldRevote = defendedOrAmended.length > 0 && judges.length > 0;
+  const costCeiling = ctx.overBudget() && wouldRevote;
+  // run.js needs to know whether the wave actually launched so it can
+  // checkpoint debate-revote 'skipped' (not a false 'complete') when nothing
+  // was defended/amended, or the cost ceiling skipped it (spec §5.7).
+  const revoteLaunched = wouldRevote && !costCeiling;
+  if (revoteLaunched) {
+    const rv = await runRevoteWave(ctx, judges, defendedOrAmended);
+    if (rv.aborted) { return { aborted: rv.aborted, contested, disputed }; }
+    revoteByJudge = rv.byJudge;
+    revoteLegs = rv.legs;
+    // revote-<model>.md per surviving judge leg, mirroring rebuttal-<model>.md
+    // (spec §5.1 'raw outputs revote-<model>.md').
+    materializeDebate(ctx.o.runDir, revoteLegs, 'revote');
+  }
+
+  // ---- Pure reassembly ----
+  const { input: debatedInput, debateFindings } = applyDebate({
+    tallyInput: stampedInput, provisionalRecord, defenseByRaiser, revoteByJudge });
+  debatedInput.runStats = [...(debatedInput.runStats || []),
+    ...debateRunStatsRows({ defenseLegs: defenseResults.map(d => d.leg), revoteLegs })];
+
+  // verdictChanges: findings whose tier moved from provisional to debated.
+  const provTierById = new Map(provisionalRecord.findings.map(f => [f.id, f.tier]));
+  const debatedRec = tally(debatedInput);
+  let verdictChanges = 0;
+  for (const f of debatedRec.findings) { if (provTierById.get(f.id) !== f.tier) { verdictChanges += 1; } }
+
+  // ---- Artifacts + summary ----
+  const revotesJson = [];
+  for (const [judge, perId] of Object.entries(revoteByJudge)) {
+    for (const [id, rv] of Object.entries(perId)) { revotesJson.push({ judge, id, verdict: rv.verdict, reason: rv.reason || null, applied: true }); }
+  }
+  fs.writeFileSync(path.join(ctx.o.runDir, 'debate.json'),
+    JSON.stringify({ findings: debateFindings, revotes: revotesJson }, null, 2), { mode: 0o600 });
+
+  const counts = { defended: 0, amended: 0, withdrawn: 0, noResponse: 0 };
+  const COUNT_KEY = { defend: 'defended', amend: 'amended', withdraw: 'withdrawn' };
+  for (const df of debateFindings) { counts[COUNT_KEY[df.action] || 'noResponse'] += 1; }
+  const debateSummary = {
+    enabled: true, outcome: costCeiling ? 'skipped-cost-ceiling' : 'ran',
+    contested, disputed, ...counts,
+    revoteJudges: revoteLegs.length, revoteApplied: revotesJson.length, verdictChanges,
+  };
+
+  // ---- Degradation (spec §5.7) → run.js maps this to exit code 2 ----
+  // A dead/unstructured-after-repair defense solo, a partial or fully-dead re-vote wave, or a
+  // cost-ceiling skip of a warranted re-vote each degrade the run. (Abort short-circuits above;
+  // nothing-to-debate and a clean run are NOT degradations.)
+  const bad = (l) => l.status !== 'complete' || l.conformance === 'unstructured';
+  const degraded = defenseResults.some(d => bad(d.leg)) || revoteLegs.some(bad) || costCeiling;
+
+  // Chair-addendum outcomes (spec §5.3c). `action` is the PAST_TENSE form
+  // buildDebateAddendum renders verbatim — only the four valid values ever reach it.
+  const priorById = new Map(provisionalRecord.findings.map(
+    f => [f.id, Object.fromEntries((f.adjudications || []).map(a => [a.judge, a.verdict]))]));
+  const addendumOutcomes = debateFindings.map(df => ({
+    id: df.id, originalClaim: (tallyInput.findings.find(f => f.id === df.id) || {}).claim,
+    action: PAST_TENSE[df.action] || PAST_TENSE['no-response'],
+    amendedClaim: df.action === 'amend' ? df.claim : null,
+    priorVerdicts: priorById.get(df.id) || {},
+    revotes: Object.fromEntries(revotesJson.filter(r => r.id === df.id).map(r => [r.judge, r.verdict])),
+  }));
+
+  return { debatedInput, debateFindings, debateSummary, addendumOutcomes,
+    defenseLegs: defenseResults.map(d => d.leg), revoteLegs, verdictChanges,
+    degraded, aborted: null, revoteLaunched };
+}
+
+module.exports = { runDebate, nothingToDebate, disputingJudges, debateTargets };

package/src/council/run-launch.js

@@ -43,6 +43,13 @@ function createLaunchers(deps = {}) {
       includeContext: false,
       gatewayMode: opts.gateway,
       noValidateModel: opts.noValidateModel,
+      // v4.1 §4.5d: `--no-cost-gate` is a WHOLE-RUN opt-out (an intentional
+      // o3-class council), so it has to ride every council launch — otherwise
+      // fanout's per-$/Mtok gate refuses the first repair or the chair
+      // mid-council. Transport key is literally `noCostGate` (fanout.js
+      // guards with `if (!options.noCostGate)`); the CALLERS assemble these
+      // option objects, so run-stages/run-chair/run-debate each set it.
+      noCostGate: !!opts.noCostGate,
       json: false,
       quiet: true,
       // Spec §6 judge isolation: pin every leg's OpenCode tool-exec cwd to its
@@ -96,4 +103,23 @@ function materializeReviews(runDir, legs) {
   return out;
 }
 
-module.exports = { createLaunchers, materializeReviews, sanitizeName };
+/**
+ * Write per-leg debate artifacts: `<prefix>-<sanitizeName(model)>.md` for each
+ * leg with a non-empty summary. Mirrors materializeReviews.
+ * @param {string} runDir
+ * @param {Array<{model: string, summary: string}>} legs
+ * @param {string} prefix 'rebuttal' | 'revote'
+ * @returns {Array<{model: string, file: string}>}
+ */
+function materializeDebate(runDir, legs, prefix) {
+  const out = [];
+  for (const leg of legs) {
+    if (!leg || !leg.summary || !leg.summary.trim()) { continue; }
+    const file = path.join(runDir, `${prefix}-${sanitizeName(leg.model)}.md`);
+    fs.writeFileSync(file, leg.summary, { mode: 0o600 });
+    out.push({ model: leg.model, file });
+  }
+  return out;
+}
+
+module.exports = { createLaunchers, materializeReviews, materializeDebate, sanitizeName };

package/src/council/run-stages.js

@@ -36,9 +36,11 @@ function slug(text) {
 /** Launch all Stage-1 legs (wave + critic/lens solos), collect run docs. */
 async function launchStage1(ctx) {
   const { o, launchers } = ctx;
+  // `noCostGate` rides EVERY launch object in this file (here, the findings
+  // repair, the judge wave, the judge repair) — see run-launch.js's fanout call.
   const common = {
     project: o.runDir, timeout: o.timeout, gateway: o.gateway,
-    noValidateModel: o.noValidateModel,
+    noValidateModel: o.noValidateModel, noCostGate: o.noCostGate,
   };
   const launches = [];
   // Record every sub-wave BEFORE it launches: `amicus abort` cascades over
@@ -118,7 +120,7 @@ async function runStage1(ctx) {
       const solo = await ctx.launchers.launchSolo({
         model: m.modelInput, prompt: briefings.buildFindingsRepairPrompt({ errors: res.errors }),
         project: o.runDir, waveId, timeout: o.timeout,
-        gateway: o.gateway, noValidateModel: o.noValidateModel,
+        gateway: o.gateway, noValidateModel: o.noValidateModel, noCostGate: o.noCostGate,
       });
       ctx.addWave(solo.wave);
       if (isAbortExit(solo.exitCode)) { return { aborted: solo.exitCode, reviews, deadLegs }; }
@@ -137,18 +139,27 @@ async function runStage1(ctx) {
 /**
  * Stage 2: shared anonymized bundle → judge wave in _scratch → parse + repair.
  * @param {object} ctx
- * @param {{reviews: Array, labels: {entries, labelMap}, globalFindings: Array}} args
+ * @param {{reviews: Array, labels: {entries, labelMap}, globalFindings: Array,
+ *   extraLabeled?: Array<{label: string, text: string}>}} args
+ *   `extraLabeled` (v4.1 §4.4) are labeled reviews sourced from a FILE rather than
+ *   a leg (the Claude review): they join the judged BUNDLE, never the judge ROSTER.
  * @returns {Promise<{aborted: number|null, judgeResults: Array}>}
  */
-async function runStage2(ctx, { reviews, labels, globalFindings }) {
+async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled = [] }) {
   const { o } = ctx;
   const { rankingToOrder } = require('./anonymize');
   fs.mkdirSync(ctx.scratchDir, { recursive: true, mode: 0o700 });
 
-  const labeled = labels.entries.map((e, i) => ({ label: e.label, text: reviews[i].text }));
-  const bundle = stage2.buildJudgeBundle({ reviews: labeled, findings: globalFindings });
+  // Zip off `reviews` (never off `labels.entries`, which may be one longer than
+  // reviews when a file-sourced review is present) and append the extras.
+  const labeled = reviews
+    .map((r, i) => ({ label: labels.entries[i].label, text: r.text }))
+    .concat(extraLabeled);
+  const bundle = stage2.buildJudgeBundle({ reviews: labeled, findings: globalFindings, date: o.date });
   fs.writeFileSync(path.join(o.runDir, 'bundle-stage2.md'), bundle, { mode: 0o600 });
 
+  // ROSTER, not bundle: derived ONLY from legs that actually ran, so a file-sourced
+  // review is judged but never judges (v4.1 §4.4). Do not widen with extraLabeled.
   const judges = reviews.map(r => r.modelInput);
   const parseCtx = {
     labels: labels.entries.map(e => e.label),
@@ -158,6 +169,7 @@ async function runStage2(ctx, { reviews, labels, globalFindings }) {
   const { wave, exitCode } = await ctx.launchers.launchWave({
     models: judges, prompt: bundle, project: ctx.scratchDir, waveId: `${o.runId}-s2`,
     timeout: o.timeout, gateway: o.gateway, noValidateModel: o.noValidateModel,
+    noCostGate: o.noCostGate,
   });
   ctx.addWave(wave);
   if (isAbortExit(exitCode)) { return { aborted: exitCode, judgeResults: [] }; }
@@ -182,7 +194,7 @@ async function runStage2(ctx, { reviews, labels, globalFindings }) {
       const solo = await ctx.launchers.launchSolo({
         model: judge, prompt: stage2.buildJudgeRepairPrompt({ errors: parsed.errors }),
         project: ctx.scratchDir, waveId, timeout: o.timeout,
-        gateway: o.gateway, noValidateModel: o.noValidateModel,
+        gateway: o.gateway, noValidateModel: o.noValidateModel, noCostGate: o.noCostGate,
       });
       ctx.addWave(solo.wave);
       if (isAbortExit(solo.exitCode)) { return { aborted: solo.exitCode, judgeResults }; }