aiki-cli 0.2.1 → 0.3.0

package/dist/orchestration/stages/s4-analyze.js

@@ -9,20 +9,24 @@
 // Discriminator injection (§13): the model returns JSON with NO `workflow` field. We validate the
 // call against `IdeaRoleOutputModel` (that exact shape), then inject `workflow` and persist via
 // `writeRoleOutput`, which re-validates the full `RoleOutput`.
-import { IdeaRoleOutputModel } from '../../schemas/index.js';
+import { IdeaRoleOutputModel, salvageIdeaRoleOutputModel } from '../../schemas/index.js';
 import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
+import { IDEA_LANES } from '../idea-lanes.js';
 /** Run one analyst seat → validated `RoleOutput`, persisted to 04-role-outputs/<label>.json.
  *  `label` doubles as the artifact filename, so a resample uses a distinct label. */
-async function runSeat(ctx, seat, label, prompt) {
-    const model = await jsonCall(ctx, ctx.handle(seat), `S4-${label}`, prompt, IdeaRoleOutputModel);
+async function runSeat(ctx, seat, label, lane, prompt) {
+    const model = await jsonCall(ctx, ctx.handle(seat), `S4-${label}`, prompt, IdeaRoleOutputModel, { salvage: salvageIdeaRoleOutputModel });
     const output = { workflow: 'idea-refinement', ...model };
     await ctx.writer.writeRoleOutput(label, output);
-    return { provider: seat, output };
+    return { provider: seat, sample: label, lane, output };
 }
-export async function s4Analyze(ctx, analystPrompt) {
+export async function s4Analyze(ctx, prompts) {
     const seats = ctx.roles.s4;
-    const settled = await Promise.allSettled(seats.map((seat) => runSeat(ctx, seat, seat, analystPrompt)));
+    const settled = await Promise.allSettled(seats.map((seat, index) => {
+        const lane = IDEA_LANES[index % IDEA_LANES.length];
+        return runSeat(ctx, seat, seat, lane, prompts[lane]);
+    }));
     const survivors = [];
     const dropped = [];
     for (let i = 0; i < settled.length; i++) {
@@ -43,7 +47,8 @@ export async function s4Analyze(ctx, analystPrompt) {
     if (survivors.length === 1) {
         const only = survivors[0];
         ctx.addFlag('low_diversity');
-        const resample = await runSeat(ctx, only.provider, `${only.provider}-2`, analystPrompt);
+        const lane = only.lane ?? IDEA_LANES[0];
+        const resample = await runSeat(ctx, only.provider, `${only.provider}-2`, lane, prompts[lane]);
         return [only, resample];
     }
     throw new StageError('S4', 'QUORUM', `no analyst seats survived (dropped: ${dropped.map((d) => `${d.provider}:${d.error}`).join('; ')})`);

package/dist/orchestration/stages/s5-drift.js

@@ -1,6 +1,6 @@
 // S5 — drift detection (§9, §12.1). Deterministic gate: does each S4 output still address the
 // contract's task? Two code checks (no model call — the §601/§532 T6 "deterministic core"; the §9
-// "verifier spot-check" is deferred): (1) the output produced ≥1 assumption (an analyst that
+// "verifier spot-check" is deferred): (1) the output produced ≥1 position (an analyst that
 // produced none did not engage the task), and (2) its `task_echo` is similar enough to the contract
 // task (overlap coefficient ≥ DRIFT_MIN_SIMILARITY). Drifted outputs are excluded from everything
 // downstream and logged; if exclusion drops the survivor count below quorum (2), the run aborts.
@@ -11,19 +11,19 @@ import { overlapCoefficient, tokenize } from '../cluster.js';
  *  paragraph. Lenient by design — this catches an analyst that wandered off-task, not paraphrase
  *  distance. Tunable (same footnote class as the S2 clustering threshold). */
 export const DRIFT_MIN_SIMILARITY = 0.3;
-export async function s5Drift(ctx, contract, seats) {
+export async function s5Drift(ctx, contract, seats, minSeats = 2) {
     const taskTokens = tokenize(contract.task);
     const entries = [];
     const kept = [];
     const excluded = [];
     for (const seat of seats) {
         const sim = overlapCoefficient(tokenize(seat.output.task_echo), taskTokens);
-        const hasAssumptions = seat.output.assumptions.length > 0;
-        const on_task = hasAssumptions && sim >= DRIFT_MIN_SIMILARITY;
-        const evidence = !hasAssumptions
-            ? 'no assumptions produced'
+        const hasPositions = seat.output.positions.length > 0;
+        const on_task = hasPositions && sim >= DRIFT_MIN_SIMILARITY;
+        const evidence = !hasPositions
+            ? 'no positions produced'
             : on_task
-                ? `task_echo overlap ${sim.toFixed(2)} ≥ ${DRIFT_MIN_SIMILARITY}; ${seat.output.assumptions.length} assumption(s)`
+                ? `task_echo overlap ${sim.toFixed(2)} ≥ ${DRIFT_MIN_SIMILARITY}; ${seat.output.positions.length} position(s)`
                 : `task_echo overlap ${sim.toFixed(2)} < ${DRIFT_MIN_SIMILARITY} (off-task)`;
         entries.push({ provider: seat.provider, on_task, similarity: Number(sim.toFixed(3)), evidence });
         if (on_task)
@@ -33,8 +33,8 @@ export async function s5Drift(ctx, contract, seats) {
     }
     const report = { entries, excluded };
     await ctx.writer.writeJson('drift-report', report);
-    if (kept.length < 2) {
-        throw new StageError('S5', 'QUORUM', `drift exclusion left ${kept.length} on-task output(s); need ≥2`);
+    if (kept.length < minSeats) {
+        throw new StageError('S5', 'QUORUM', `drift exclusion left ${kept.length} on-task output(s); need ≥${minSeats}`);
     }
     return { report, kept };
 }

package/dist/orchestration/stages/s6-positions.js

@@ -0,0 +1,10 @@
+// S6 — preserve validated analyst submissions for graph compilation. No lexical merging: positions
+// keep their original text and are grouped only by stable references in S7.
+export function collectPositions(seats) {
+    return seats.map((seat) => ({ provider: seat.provider, source_id: seat.sample ?? seat.provider, submission: seat.output }));
+}
+export async function s6Positions(ctx, seats) {
+    const positions = collectPositions(seats);
+    await ctx.writer.writeJson('positions', positions);
+    return positions;
+}

package/dist/orchestration/stages/s7-decision-graph.js

@@ -0,0 +1,76 @@
+// S7 — deterministic conservative grouping plus pure decision-graph compilation. R6 removes the
+// model-authored grouping call so graph audit spends no provider call on an obvious run.
+import { compileDecisionGraph, coverageHoleQueue, positionId } from '../decision-graph.js';
+import { IdeaRoleOutputModel } from '../../schemas/index.js';
+import { isFatal } from '../context.js';
+import { jsonCall } from '../jsonStage.js';
+import { overlapCoefficient, tokenize } from '../cluster.js';
+const GROUP_SIMILARITY = 0.8;
+export function buildCoverageFillPrompt(task, holes) {
+    return `TARGETED COVERAGE FILL. Answer only the missing dimensions below; do not repeat the full analysis.
+TASK: ${task}
+MISSING DIMENSIONS:
+${holes.map((hole) => `- ${hole.dimension_id}: ${hole.label}`).join('\n')}
+
+Output ONLY the idea analyst JSON schema. Emit positions/evidence only when needed. Include one explicit
+COVERED entry anchored to a position, or a reasoned NOT_APPLICABLE entry, for every listed dimension.
+Required top-level keys: task_echo, strongest_version, positions, evidence, calculations, coverage, decision_questions.
+Use calculations: [] unless a new position makes a derived numeric claim.
+Use the same position and evidence-card shapes as the initial analysis; JSON only.`;
+}
+async function fillCoverage(ctx, submissions, rubric, task) {
+    const holes = coverageHoleQueue(submissions, rubric);
+    if (holes.length === 0 || ctx.optionalCallsRemaining() === 0)
+        return submissions;
+    const provider = ctx.roles.s4[0] ?? ctx.roles.analyst;
+    try {
+        const model = await jsonCall(ctx, ctx.handle(provider), 'S7-coverage-fill', buildCoverageFillPrompt(task, holes), IdeaRoleOutputModel, { repair: false });
+        const output = { workflow: 'idea-refinement', ...model };
+        await ctx.writer.writeJson('coverage-fill', output);
+        return [...submissions, { provider, source_id: `${provider}-coverage-fill`, submission: output }];
+    }
+    catch (error) {
+        if (isFatal(error))
+            throw error;
+        return submissions;
+    }
+}
+/** Conservative exact/high-overlap grouping. False negatives stay separate; false merges are worse. */
+export function deterministicClaimGroups(submissions) {
+    const positions = submissions.flatMap(({ provider, source_id = provider, submission }) => submission.positions.map((position) => ({
+        id: positionId(provider, position.local_id, source_id),
+        provider,
+        dimension: position.dimension_id,
+        proposition: position.proposition.trim().toLowerCase().replace(/[^a-z0-9]+/g, ' '),
+        tokens: tokenize(position.proposition),
+    })));
+    const used = new Set();
+    const groups = [];
+    for (const first of positions) {
+        if (used.has(first.id))
+            continue;
+        const group = [first];
+        for (const candidate of positions) {
+            if (used.has(candidate.id) || candidate.id === first.id)
+                continue;
+            if (candidate.provider === first.provider || candidate.dimension !== first.dimension)
+                continue;
+            const same = candidate.proposition === first.proposition
+                || overlapCoefficient(candidate.tokens, first.tokens) >= GROUP_SIMILARITY;
+            if (same && !group.some((item) => item.provider === candidate.provider))
+                group.push(candidate);
+        }
+        if (group.length >= 2) {
+            group.forEach((item) => used.add(item.id));
+            groups.push(group.map((item) => item.id));
+        }
+    }
+    return groups;
+}
+export async function s7DecisionGraph(ctx, submissions, rubric, task = '') {
+    const completed = await fillCoverage(ctx, submissions, rubric, task);
+    const groups = deterministicClaimGroups(completed);
+    const graph = compileDecisionGraph(completed, rubric, groups);
+    await ctx.writer.writeJson('decision-graph', graph);
+    return graph;
+}

package/dist/orchestration/stages/s8-verify.js

@@ -1,56 +1,163 @@
-// S8 — verifier loop (§9, §13). The verifier (codex) independently checks each dispute before the
-// judge sees it. Idea-refinement runs a SINGLE pass (the "max 2 iterations" cap is the code-review
-// reviewer cross-exam, §313, landing at T10). Disputed items are ANONYMIZED — the verifier sees the
-// claim + the argument(s) against it with NO provider labels (§313/§624 anti-self-preference), since
-// codex authored some S4 claims. Zero disputes → skip the call entirely. A verifier failure is
-// graceful: every item is marked UNCERTAIN ("unverified") and passed to the judge, never an abort (§259).
-import { VerificationSet } from '../../schemas/index.js';
-import { isFatal } from '../context.js';
+// S8 — independently verify graph-selected claims from stored evidence/calculation references.
+// Provider identity stays hidden; model output is translated back to graph evidence IDs before S9.
+import { selectEscalations } from '../decision-graph.js';
+import { ClaimVerificationSet } from '../../schemas/index.js';
+import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
-const S8_PROMPT = `ROLE: Verifier. Below are disputed claims, each with the argument(s) against it, from
-anonymous sources. For EACH item, independently judge whether the argument defeats the claim.
-Output ONLY JSON:
-{"verifications": [{"target_id": "<id>", "verdict": "CONFIRM|REFUTE|UNCERTAIN",
-  "evidence": "<your own independent reasoning>", "note": "<≤2 sentences>"}]}
-CONFIRM = the argument holds (the claim is genuinely doubtful). REFUTE = the argument fails (the claim
-stands). Rules: you MUST issue at least one REFUTE, or set "all_confirmed_justification" explaining why
-every claim survives. JSON only, no prose outside it.
-ITEMS: {{DISPUTED_ITEMS_JSON}}`;
-export async function s8Verify(ctx, map) {
-    const disputes = map.contradictions;
-    if (disputes.length === 0) {
+const S8_PROMPT = `ROLE: Independent verifier. Check each anonymous decision claim below against the
+provided evidence cards and deterministic calculation checks. Output ONLY JSON:
+{"verifications": [{"claim_id": "<G-id>", "status": "VERIFIED|PARTIAL|CONTRADICTED|UNVERIFIABLE",
+  "reasoning": "<concise reason>", "evidence_ids": ["<E-id>"],
+  "calculation_check": "PASS|FAIL|NOT_APPLICABLE", "missing_evidence": ["<gap>"]}]}
+VERIFIED = the proposition is supported. CONTRADICTED = it is refuted. PARTIAL = evidence is mixed or
+incomplete. UNVERIFIABLE = the supplied sources cannot decide. Cite only supplied evidence IDs. Model
+knowledge cannot verify a current, numeric, legal, medical, financial, market, or regulatory fact.
+Judge each item independently; no verdict quota. JSON only.
+ITEMS: {{ITEMS_JSON}}`;
+function evidenceIdsForClaim(graph, claimId) {
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const claim = graph.claims.find((item) => item.id === claimId);
+    const positionEvidence = claim?.position_ids.flatMap((id) => {
+        const position = positionById.get(id);
+        return position?.evidence_ids.map((evidenceId) => `${position.source_id}/${evidenceId}`) ?? [];
+    }) ?? [];
+    const calculationEvidence = graph.calculations.filter((calculation) => calculation.claim_id === claimId)
+        .flatMap((calculation) => calculation.inputs.flatMap((input) => input.evidence_ids));
+    return new Set([...positionEvidence, ...calculationEvidence]);
+}
+function verifierInput(graph) {
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const evidenceRefs = new Map(graph.evidence.map((evidence, index) => [`E${index + 1}`, evidence.id]));
+    const aliasByEvidence = new Map([...evidenceRefs].map(([alias, id]) => [id, alias]));
+    const evidenceById = new Map(graph.evidence.map((evidence) => [evidence.id, evidence]));
+    const items = selectEscalations(graph, { max: 8 }).map((escalation) => {
+        const claim = graph.claims.find((item) => item.id === escalation.claim_id);
+        const linkedEvidenceIds = evidenceIdsForClaim(graph, claim.id);
+        return {
+            id: claim.id,
+            kind: escalation.kind,
+            proposition: claim.proposition,
+            positions: claim.position_ids.map((id) => {
+                const position = positionById.get(id);
+                return { stance: position.stance, reasoning: position.reasoning };
+            }),
+            evidence: [...linkedEvidenceIds].flatMap((id) => {
+                const evidence = evidenceById.get(id);
+                if (!evidence)
+                    return [];
+                const { provider: _provider, source_id: _sourceId, ...card } = evidence;
+                return [{ ...card, id: aliasByEvidence.get(id) }];
+            }),
+            calculations: graph.calculations.filter((calculation) => calculation.claim_id === claim.id).map((calculation, index) => ({
+                id: `C${index + 1}`,
+                inputs: calculation.inputs.map((input) => ({
+                    ...input,
+                    evidence_ids: input.evidence_ids.map((id) => aliasByEvidence.get(id)).filter((id) => id !== undefined),
+                })),
+                steps: calculation.steps,
+                result_step: calculation.result_step,
+                deterministic_check: (() => {
+                    const check = graph.calculation_checks.find((item) => item.calculation_id === calculation.id);
+                    return check ? { status: check.status, issues: check.issues } : undefined;
+                })(),
+            })),
+            evidence_hole: graph.holes.evidence.find((hole) => hole.claim_id === claim.id)?.reason,
+        };
+    });
+    return { prompt: S8_PROMPT.replace('{{ITEMS_JSON}}', JSON.stringify(items, null, 2)), evidenceRefs };
+}
+export function buildVerifierPrompt(graph) {
+    return verifierInput(graph).prompt;
+}
+/** Validate every S8 claim/evidence reference before the chair can see it. */
+export function claimVerificationRefIssues(graph, verifications, expectedIds = selectEscalations(graph, { max: 8 }).map((item) => item.claim_id)) {
+    const expected = new Set(expectedIds);
+    const evidence = new Map(graph.evidence.map((item) => [item.id, item]));
+    const seen = new Set();
+    const issues = [];
+    for (const verification of verifications.verifications) {
+        if (!expected.has(verification.claim_id))
+            issues.push(`unknown claim id: ${verification.claim_id}`);
+        if (seen.has(verification.claim_id))
+            issues.push(`duplicate claim verification: ${verification.claim_id}`);
+        seen.add(verification.claim_id);
+        const cards = verification.evidence_ids.map((id) => evidence.get(id));
+        for (const [index, card] of cards.entries())
+            if (!card)
+                issues.push(`unknown evidence id for ${verification.claim_id}: ${verification.evidence_ids[index]}`);
+        const linkedEvidence = evidenceIdsForClaim(graph, verification.claim_id);
+        for (const id of verification.evidence_ids)
+            if (evidence.has(id) && !linkedEvidence.has(id))
+                issues.push(`unrelated evidence id for ${verification.claim_id}: ${id}`);
+        if (verification.status !== 'UNVERIFIABLE' && verification.evidence_ids.length === 0) {
+            issues.push(`${verification.claim_id}: ${verification.status} requires evidence ids`);
+        }
+        const evidenceHole = graph.holes.evidence.find((hole) => hole.claim_id === verification.claim_id);
+        const onlyModelKnowledge = cards.length > 0 && cards.every((card) => card?.source_kind === 'MODEL_KNOWLEDGE');
+        if (verification.status === 'VERIFIED' && evidenceHole && onlyModelKnowledge) {
+            issues.push(`${verification.claim_id}: model knowledge cannot close its evidence hole`);
+        }
+        const calculationChecks = graph.calculation_checks.filter((check) => check.claim_id === verification.claim_id);
+        if (calculationChecks.some((check) => check.status === 'FAIL')) {
+            if (verification.calculation_check !== 'FAIL')
+                issues.push(`${verification.claim_id}: failed deterministic calculation must be reported`);
+            if (verification.status === 'VERIFIED')
+                issues.push(`${verification.claim_id}: failed deterministic calculation cannot be verified`);
+        }
+    }
+    for (const id of expected)
+        if (!seen.has(id))
+            issues.push(`missing claim verification: ${id}`);
+    return issues;
+}
+export async function s8Verify(ctx, graph) {
+    const escalations = selectEscalations(graph, { max: 8 });
+    if (escalations.length === 0) {
         const empty = { verifications: [] };
         await ctx.writer.writeJson('verifications', empty);
         return empty;
     }
-    // Anonymized disputed items: claim text + argument text only, no provider attribution.
-    const claimById = new Map();
-    for (const c of [...map.consensus, ...map.unique])
-        claimById.set(c.id, c.statement);
-    const items = disputes.map((d) => ({
-        id: d.id,
-        claim: d.claim_ids.map((cid) => claimById.get(cid) ?? cid).join(' / '),
-        arguments_against: d.attacks.map((a) => a.argument),
-    }));
-    const prompt = S8_PROMPT.replace('{{DISPUTED_ITEMS_JSON}}', JSON.stringify(items, null, 2));
-    try {
-        const vset = await jsonCall(ctx, ctx.handle(ctx.roles.verifier), 'S8', prompt, VerificationSet);
-        await ctx.writer.writeJson('verifications', vset);
-        return vset;
+    const unavailable = () => ({
+        verifications: escalations.map((escalation) => {
+            const checks = graph.calculation_checks.filter((check) => check.claim_id === escalation.claim_id);
+            return {
+                claim_id: escalation.claim_id,
+                status: 'UNVERIFIABLE',
+                reasoning: 'Independent verification was unavailable or skipped to preserve required calls.',
+                evidence_ids: [],
+                calculation_check: checks.length === 0 ? 'NOT_APPLICABLE'
+                    : checks.some((check) => check.status === 'FAIL') ? 'FAIL' : 'PASS',
+                missing_evidence: ['independent verification'],
+            };
+        }),
+    });
+    if (ctx.optionalCallsRemaining() === 0) {
+        ctx.addFlag('verification_skipped');
+        const skipped = unavailable();
+        await ctx.writer.writeJson('verifications', skipped);
+        return skipped;
     }
-    catch (e) {
-        if (isFatal(e))
-            throw e; // budget/deadline/abort → abort the run
-        // Verifier down / bad output: mark every dispute unverified, pass to the judge as low-confidence.
-        const vset = {
-            verifications: disputes.map((d) => ({
-                target_id: d.id,
-                verdict: 'UNCERTAIN',
-                evidence: '(verifier unavailable — unverified)',
-                note: '',
+    try {
+        const input = verifierInput(graph);
+        // Optional work gets no model repair: one logical optional call must remain one call.
+        const result = await jsonCall(ctx, ctx.handle(ctx.roles.verifier), 'S8', input.prompt, ClaimVerificationSet, { repair: false });
+        const translated = {
+            verifications: result.verifications.map((verification) => ({
+                ...verification,
+                evidence_ids: verification.evidence_ids.map((id) => input.evidenceRefs.get(id) ?? id),
             })),
         };
-        await ctx.writer.writeJson('verifications', vset);
-        return vset;
+        const issues = claimVerificationRefIssues(graph, translated, escalations.map((item) => item.claim_id));
+        if (issues.length)
+            throw new StageError('S8', 'BAD_OUTPUT', issues.join('; '));
+        await ctx.writer.writeJson('verifications', translated);
+        return translated;
+    }
+    catch (error) {
+        if (isFatal(error))
+            throw error;
+        const failed = unavailable();
+        await ctx.writer.writeJson('verifications', failed);
+        return failed;
     }
 }

package/dist/orchestration/stages/s8b-rebuttal.js

@@ -0,0 +1,208 @@
+// R5 — one optional, bounded rebuttal round over verdict-flipping graph nodes. Original graph
+// objects are never rewritten; validated responses are appended as a separate 08b event artifact.
+import { RebuttalEventSet as RebuttalEventSetSchema, RebuttalResponseSet } from '../../schemas/index.js';
+import { selectRebuttalEscalations, } from '../decision-graph.js';
+import { isFatal, StageError } from '../context.js';
+import { jsonCall } from '../jsonStage.js';
+import { IDEA_MODE_PLANS } from '../modes.js';
+/** Internal protocol caps only. R6 owns exposing modes and changing the surrounding topology. */
+export const REBUTTAL_LIMITS = {
+    quick: { maxNodes: 0, optionalCalls: 0 },
+    council: { maxNodes: 3, optionalCalls: 2 },
+    research: { maxNodes: 3, optionalCalls: 2 },
+};
+const REBUTTAL_PROMPT = `ROLE: Scout rebuttal. This is the council's only rebuttal round. Respond only
+to the anonymous decision nodes assigned below. You may not rewrite any original claim or evidence.
+
+Output ONLY JSON:
+{"events":[{"claim_id":"<G-id>","response":"CONCEDE|COUNTER|NARROW|UNRESOLVED",
+"reasoning":"<precise reason>","evidence_ids":["<E-id>"],
+"narrowed_proposition":"<required only for NARROW>"}]}
+
+CONCEDE = your position changes. COUNTER = retain it using a cited supplied card or a precise logical
+rebuttal. NARROW = state the smaller proposition actually supported. UNRESOLVED = evidence cannot decide.
+Return exactly one event per assigned claim. Cite only evidence IDs shown for that claim. Do not invent
+sources, URLs, claim IDs, or evidence IDs. JSON only.
+NODES: {{NODES_JSON}}`;
+function claimAuthors(graph, claimId) {
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const claim = graph.claims.find((item) => item.id === claimId);
+    return [...new Set(claim?.position_ids
+            .map((id) => positionById.get(id)?.provider)
+            .filter((provider) => provider !== undefined) ?? [])];
+}
+function linkedEvidenceIds(graph, claimId) {
+    const evidenceIds = new Set(graph.evidence.map((item) => item.id));
+    const linked = graph.edges
+        .filter((edge) => edge.to === claimId && evidenceIds.has(edge.from))
+        .map((edge) => edge.from);
+    for (const calculation of graph.calculations.filter((item) => item.claim_id === claimId)) {
+        for (const input of calculation.inputs)
+            linked.push(...input.evidence_ids);
+    }
+    return [...new Set(linked)];
+}
+/** One grouped call per relevant scout; judge-authored nodes never enter the rebuttal/chair path. */
+export function planRebuttalCalls(graph, escalations, scouts, judge) {
+    const assigned = new Map();
+    const add = (provider, claimId) => {
+        const ids = assigned.get(provider) ?? [];
+        if (!ids.includes(claimId))
+            ids.push(claimId);
+        assigned.set(provider, ids);
+    };
+    for (const escalation of escalations) {
+        const authors = claimAuthors(graph, escalation.claim_id);
+        if (authors.includes(judge))
+            continue;
+        if (escalation.kind === 'DISAGREEMENT' || escalation.kind === 'EVIDENCE_CONFLICT') {
+            for (const scout of scouts)
+                if (authors.includes(scout) && scout !== judge)
+                    add(scout, escalation.claim_id);
+            continue;
+        }
+        const challenger = scouts.find((scout) => scout !== judge && !authors.includes(scout));
+        if (challenger)
+            add(challenger, escalation.claim_id);
+    }
+    return scouts.flatMap((provider) => {
+        const claim_ids = assigned.get(provider);
+        return claim_ids?.length ? [{ provider, claim_ids }] : [];
+    });
+}
+function rebuttalInput(graph, verifications, escalationById, assignment) {
+    const claimIds = new Set(assignment.claim_ids);
+    const positionRefs = new Map();
+    const evidenceRefs = new Map();
+    const aliasPosition = (id) => {
+        const found = [...positionRefs].find(([, value]) => value === id)?.[0];
+        if (found)
+            return found;
+        const alias = `P${positionRefs.size + 1}`;
+        positionRefs.set(alias, id);
+        return alias;
+    };
+    const aliasEvidence = (id) => {
+        const found = [...evidenceRefs].find(([, value]) => value === id)?.[0];
+        if (found)
+            return found;
+        const alias = `E${evidenceRefs.size + 1}`;
+        evidenceRefs.set(alias, id);
+        return alias;
+    };
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const evidenceById = new Map(graph.evidence.map((evidence) => [evidence.id, evidence]));
+    const verificationById = new Map(verifications.verifications.map((item) => [item.claim_id, item]));
+    const allowedEvidence = new Map();
+    const nodes = graph.claims.filter((claim) => claimIds.has(claim.id)).map((claim) => {
+        const evidenceIds = linkedEvidenceIds(graph, claim.id);
+        const aliases = new Set(evidenceIds.map(aliasEvidence));
+        allowedEvidence.set(claim.id, aliases);
+        const positions = claim.position_ids.map((id) => positionById.get(id)).map((position) => ({
+            id: aliasPosition(position.id),
+            proposition: position.proposition,
+            stance: position.stance,
+            reasoning: position.reasoning,
+        }));
+        const verification = verificationById.get(claim.id);
+        return {
+            claim_id: claim.id,
+            escalation_kind: escalationById.get(claim.id)?.kind,
+            proposition: claim.proposition,
+            consequence_if_false: claim.if_false,
+            your_positions: claim.position_ids
+                .filter((id) => positionById.get(id)?.provider === assignment.provider)
+                .map((id) => positions.find((position) => position.id === aliasPosition(id))),
+            opposing_positions: claim.position_ids
+                .filter((id) => positionById.get(id)?.provider !== assignment.provider)
+                .map((id) => positions.find((position) => position.id === aliasPosition(id))),
+            evidence: evidenceIds.flatMap((id) => {
+                const evidence = evidenceById.get(id);
+                if (!evidence)
+                    return [];
+                const { provider: _provider, source_id: _sourceId, ...card } = evidence;
+                return [{ ...card, id: aliasEvidence(id) }];
+            }),
+            verification: verification ? {
+                ...verification,
+                evidence_ids: verification.evidence_ids.map(aliasEvidence),
+            } : undefined,
+        };
+    });
+    return {
+        prompt: REBUTTAL_PROMPT.replace('{{NODES_JSON}}', JSON.stringify(nodes, null, 2)),
+        evidenceRefs,
+        allowedEvidence,
+    };
+}
+function translateEvents(graph, assignment, input, output, startIndex) {
+    const expected = new Set(assignment.claim_ids);
+    const seen = new Set();
+    const issues = [];
+    for (const event of output.events) {
+        if (!expected.has(event.claim_id))
+            issues.push(`unknown claim id: ${event.claim_id}`);
+        if (seen.has(event.claim_id))
+            issues.push(`duplicate claim response: ${event.claim_id}`);
+        seen.add(event.claim_id);
+        const allowed = input.allowedEvidence.get(event.claim_id) ?? new Set();
+        for (const id of event.evidence_ids)
+            if (!allowed.has(id))
+                issues.push(`invalid evidence id for ${event.claim_id}: ${id}`);
+    }
+    for (const id of expected)
+        if (!seen.has(id))
+            issues.push(`missing claim response: ${id}`);
+    if (issues.length)
+        throw new StageError('S8b', 'BAD_OUTPUT', issues.join('; '));
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
+    return output.events.map((event, index) => ({
+        ...event,
+        id: `R${startIndex + index + 1}`,
+        round: 1,
+        responder: assignment.provider,
+        target_position_ids: claimById.get(event.claim_id)?.position_ids
+            .filter((id) => positionById.get(id)?.provider === assignment.provider) ?? [],
+        evidence_ids: event.evidence_ids.map((id) => input.evidenceRefs.get(id)),
+    }));
+}
+export async function s8bRebuttal(ctx, graph, verifications, mode = ctx.mode) {
+    const limits = REBUTTAL_LIMITS[mode];
+    const escalations = selectRebuttalEscalations(graph, verifications, { maxNodes: limits.maxNodes });
+    const selected_claim_ids = escalations.map((item) => item.claim_id);
+    const finish = async (events, stop_reason) => {
+        const result = RebuttalEventSetSchema.parse({ round: 1, selected_claim_ids, events, stop_reason });
+        await ctx.writer.writeJson('rebuttals', result);
+        return result;
+    };
+    if (escalations.length === 0)
+        return finish([], 'NO_ESCALATIONS');
+    const planned = planRebuttalCalls(graph, escalations, ctx.roles.s4, ctx.roles.judge);
+    if (planned.length === 0)
+        return finish([], 'NO_ELIGIBLE_SCOUT');
+    const optionalCalls = Math.min(limits.optionalCalls, ctx.optionalCallsRemaining());
+    if (optionalCalls === 0) {
+        const budgetRoom = ctx.budget.limit - ctx.budget.used - IDEA_MODE_PLANS[mode].reservedCalls;
+        return finish([], budgetRoom <= 0 ? 'BUDGET_RESERVED' : 'CALL_CAP_REACHED');
+    }
+    const assignments = planned.slice(0, optionalCalls);
+    const escalationById = new Map(escalations.map((item) => [item.claim_id, item]));
+    const events = [];
+    for (const assignment of assignments) {
+        const input = rebuttalInput(graph, verifications, escalationById, assignment);
+        try {
+            const output = await jsonCall(ctx, ctx.handle(assignment.provider), `S8b-${assignment.provider}`, input.prompt, RebuttalResponseSet, { repair: false });
+            events.push(...translateEvents(graph, assignment, input, output, events.length));
+        }
+        catch (error) {
+            if (isFatal(error))
+                throw error;
+        }
+    }
+    if (planned.length > optionalCalls)
+        return finish(events, 'CALL_CAP_REACHED');
+    if (events.length > 0 && events.every((event) => event.evidence_ids.length === 0))
+        return finish(events, 'NO_NEW_EVIDENCE');
+    return finish(events, 'ROUND_COMPLETE');
+}