aiki-cli 0.2.2 → 0.3.0

package/dist/orchestration/stages/s10-render.js

@@ -1,46 +1,48 @@
 // S10 — artifact rendering (§9, §12.1, §307). Pure code → `final-report.md`, a DECISION BRIEF, not a
-// smoothed essay (§263). Every section is assembled deterministically from prior artifacts; the only
-// computed content is the assumption-audit status/confidence, which is DERIVED here (not taken from
-// the judge — §624). A truly missing required field is a template bug (fail loudly); degraded-but-valid
+// smoothed essay (§263). Every section is assembled deterministically from prior artifacts; audit,
+// sensitivity, coverage, contribution, and confidence are DERIVED here rather than invented by the judge.
+// A truly missing required field is a template bug (fail loudly); degraded-but-valid
 // states (S8 skipped, items UNVERIFIED, empty consensus) render normally. User-facing → DISPLAY_NAME.
 import { DISPLAY_NAME } from '../../providers/types.js';
 import { overlap, tokenize } from '../cluster.js';
-/** Pure: derive the assumption-audit (held/failed/unverified + confidence) from the map + the judge's
- *  rulings on disputes. Consensus+undisputed → held/HIGH; single-provider+undisputed → held/MEDIUM;
- *  attack REJECTed → held/MEDIUM; UPHELD → failed/LOW; UNRESOLVED or unadjudicated → unverified/LOW. */
-export function deriveAudit(map, judgeReport) {
-    const contestedBy = new Map(); // claim id → contradiction id
-    for (const d of map.contradictions)
-        for (const cid of d.claim_ids)
-            contestedBy.set(cid, d.id);
+import { renderDecisionDossierMarkdown } from '../decision-dossier.js';
+import { callCategory } from '../modes.js';
+/** Pure graph-backed decision audit. */
+export function deriveAudit(graph, judgeReport) {
     const ruling = new Map(judgeReport.adjudications.map((a) => [a.id, a.ruling]));
-    return [...map.consensus, ...map.unique].map((c) => {
-        const dispId = contestedBy.get(c.id);
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    return graph.claims.map((claim) => {
+        const positions = claim.position_ids.map((id) => positionById.get(id));
+        const providers = [...new Set(positions.map((position) => position.provider))];
         let status;
         let confidence;
-        if (!dispId) {
-            status = 'held';
-            confidence = c.providers.length >= 2 ? 'HIGH' : 'MEDIUM';
+        if (claim.state === 'UNCERTAIN' || claim.evidence_state !== 'SUPPORTED') {
+            [status, confidence] = ['unverified', 'LOW'];
         }
-        else {
-            const r = ruling.get(dispId);
-            if (r === 'REJECT')
+        else if (claim.state === 'SHARED_CONCERN' || (claim.state === 'UNIQUE' && positions[0]?.stance === 'OPPOSE')) {
+            [status, confidence] = ['failed', providers.length >= 2 ? 'HIGH' : 'MEDIUM'];
+        }
+        else if (claim.state === 'DISAGREEMENT') {
+            const result = ruling.get(claim.id);
+            if (result === 'UPHOLD')
+                [status, confidence] = ['failed', 'MEDIUM'];
+            else if (result === 'REJECT')
                 [status, confidence] = ['held', 'MEDIUM'];
-            else if (r === 'UPHOLD')
-                [status, confidence] = ['failed', 'LOW'];
             else
-                [status, confidence] = ['unverified', 'LOW']; // UNRESOLVED / unadjudicated
+                [status, confidence] = ['unverified', 'LOW'];
         }
-        return { id: c.id, statement: c.statement, providers: c.providers, status, confidence };
+        else {
+            [status, confidence] = ['held', providers.length >= 2 ? 'HIGH' : 'MEDIUM'];
+        }
+        return { id: claim.id, statement: claim.proposition, providers, status, confidence };
     });
 }
 const disp = (id) => DISPLAY_NAME[id];
-const attrib = (ps) => ps.map(disp).join(', ');
-/** Union of the seats' open questions, deduped by lexical similarity (≥0.85), capped. */
+/** Union of the seats' decision questions, deduped by lexical similarity (≥0.85), capped. */
 export function mergeOpenQuestions(seats, cap = 10) {
     const kept = [];
     for (const seat of seats) {
-        for (const q of seat.output.open_questions) {
+        for (const { question: q } of seat.output.decision_questions) {
             const tokens = tokenize(q);
             if (!kept.some((k) => overlap(k.tokens, tokens) >= 0.85))
                 kept.push({ q, tokens });
@@ -48,25 +50,29 @@ export function mergeOpenQuestions(seats, cap = 10) {
     }
     return kept.slice(0, cap).map((k) => k.q);
 }
-/** Best-effort rubric coverage for the report. This is intentionally coarse: it mirrors S7's keyword
- *  coverage, never throws, and labels the result honestly as best-effort in the renderer. */
-export function deriveScorecard(rubric, map) {
-    const claimById = new Map([...map.consensus, ...map.unique].map((c) => [c.id, c.statement]));
-    const blind = new Set(map.blind_spots.map((b) => b.toLowerCase()));
-    const contestedTexts = map.contradictions.map((d) => d.claim_ids.map((id) => claimById.get(id) ?? id).join(' '));
+/** Exact rubric coverage derived from graph dimension anchors and holes. */
+export function deriveScorecard(rubric, graph) {
+    const blind = new Set(graph.holes.coverage.map((hole) => hole.dimension_id));
+    const claimByPosition = new Map(graph.claims.flatMap((claim) => claim.position_ids.map((id) => [id, claim])));
     return rubric.map((r) => {
-        if (blind.has(r.label.toLowerCase()))
+        if (blind.has(r.id))
             return { id: r.id, label: r.label, status: 'unexamined' };
-        const dimensionTokens = new Set([...tokenize(r.label), ...r.keywords.flatMap((kw) => [...tokenize(kw)])]);
-        const contested = contestedTexts.some((text) => overlap(dimensionTokens, tokenize(text)) > 0);
+        const contested = graph.positions
+            .filter((position) => position.dimension_id === r.id)
+            .some((position) => {
+            const state = claimByPosition.get(position.id)?.state;
+            return state === 'DISAGREEMENT' || state === 'UNCERTAIN';
+        });
         return { id: r.id, label: r.label, status: contested ? 'contested' : 'examined' };
     });
 }
-function recommendationLabel(r) {
-    return r === 'PROCEED_WITH_CONDITIONS' ? 'PROCEED WITH CONDITIONS' : r;
-}
-function mdCell(s) {
-    return s.replaceAll('\n', ' ').replaceAll('|', '\\|');
+function receiptCategories(ctx) {
+    if (typeof ctx.receipt === 'function')
+        return ctx.receipt();
+    const categories = { discovery: 0, verification: 0, repair: 0, planning: 0 };
+    for (const call of ctx.calls)
+        categories[call.category ?? callCategory(call.stage)]++;
+    return categories;
 }
 function rulingPhrase(ruling) {
     if (ruling === 'UPHOLD')
@@ -75,124 +81,530 @@ function rulingPhrase(ruling) {
         return 'the idea holds here';
     return 'left to you';
 }
-function receiptLines(ctx) {
-    const byProvider = new Map();
-    let ms = 0;
-    for (const c of ctx.calls) {
-        byProvider.set(c.provider, (byProvider.get(c.provider) ?? 0) + 1);
-        ms += c.durationMs;
+export function statusFrom(judgeReport) {
+    switch (judgeReport.recommendation) {
+        case 'PROCEED': return 'ACCEPTED';
+        case 'PROCEED_WITH_CONDITIONS': return 'ACCEPTED_WITH_CONDITIONS';
+        case 'PIVOT':
+        case 'STOP': return 'REJECTED';
+        default: return 'INCONCLUSIVE';
     }
-    const providerCounts = [...byProvider.entries()].map(([p, n]) => `${disp(p)} ${n}`).join(', ') || 'none';
-    return [
-        `- Calls: ${ctx.calls.length}/${ctx.budget.limit}`,
-        `- By provider: ${providerCounts}`,
-        `- Recorded model time: ${(ms / 1000).toFixed(1)}s`,
-    ];
 }
-/** Build the markdown report (pure given the run context's read-only accounting). */
-export function renderReport(ctx, args) {
-    const { seats, map, judgeReport, actionPlan } = args;
-    const flags = [...ctx.flags];
-    const audit = deriveAudit(map, judgeReport);
-    const scorecard = args.rubric ? deriveScorecard(args.rubric, map) : [];
-    const rulingById = new Map(judgeReport.adjudications.map((a) => [a.id, a]));
-    const claimById = new Map([...map.consensus, ...map.unique].map((c) => [c.id, c]));
-    const L = [];
-    L.push(`# Decision Brief — ${ctx.runId}`, '');
-    L.push(`- Providers: ${ctx.available().map(disp).join(', ')}  ·  calls: ${ctx.calls.length}/${ctx.budget.limit}`);
-    if (flags.length)
-        L.push(`- ⚠ Flags: ${flags.join(', ')}`);
-    L.push('');
-    if (judgeReport.recommendation) {
-        L.push('## Bottom line', '', `**${recommendationLabel(judgeReport.recommendation)}** — ${judgeReport.verdict}`, '');
-        if (judgeReport.conditions?.length) {
-            L.push('Conditions:');
-            for (const c of judgeReport.conditions)
-                L.push(`- ${c}`);
-            L.push('');
-        }
-    }
-    else {
-        L.push('## Verdict', '', judgeReport.verdict, '');
-    }
-    if (judgeReport.key_points?.length) {
-        L.push("## Chairman's reasoning", '');
-        for (const p of judgeReport.key_points)
-            L.push(`- ${p}`);
-        L.push('');
+const DEGRADATION_FLAGS = ['low_diversity', 'synthesis_suspect', 'plan_fallback', 'plan_skipped'];
+/** Structural confidence — 40% verification coverage + 25% convergence + 20% evidence quality +
+ *  15% stability − critical-risk penalty. A starting heuristic, NOT a calibrated probability; model
+ *  self-confidence never enters it, and consensus alone can never reach the High band. */
+export function computeConfidence(graph, flags) {
+    const loadBearing = graph.claims.filter((claim) => claim.load_bearing);
+    const verificationCoverage = loadBearing.length
+        ? loadBearing.filter((claim) => claim.evidence_state === 'SUPPORTED').length / loadBearing.length : 0;
+    const independentConvergence = graph.claims.length
+        ? graph.claims.filter((claim) => claim.state === 'CONSENSUS' || claim.state === 'SHARED_CONCERN').length / graph.claims.length : 0;
+    const evidenceQuality = graph.evidence.length
+        ? graph.evidence.filter((card) => card.source_kind !== 'MODEL_KNOWLEDGE').length / graph.evidence.length : 0;
+    const stability = Math.max(0, 1 - 0.25 * DEGRADATION_FLAGS.filter((flag) => flags.has(flag)).length);
+    const criticalRiskPenalty = Math.min(20, 5 * loadBearing.filter((claim) => claim.if_false === 'STOP' && claim.evidence_state !== 'SUPPORTED').length);
+    let score = Math.round(verificationCoverage * 40 + independentConvergence * 25 + evidenceQuality * 20 + stability * 15 - criticalRiskPenalty);
+    if (verificationCoverage < 0.5)
+        score = Math.min(score, 79); // consensus alone never yields High
+    score = Math.max(0, Math.min(100, score));
+    const label = score >= 80 ? 'High' : score >= 60 ? 'Medium' : 'Low';
+    return { score, label, verificationCoverage, independentConvergence, evidenceQuality, stability, criticalRiskPenalty };
+}
+const STANCE_MAP = { SUPPORT: 'AGREE', OPPOSE: 'DISAGREE', MIXED: 'CONDITIONAL', UNKNOWN: 'UNKNOWN' };
+const VERIFICATION_MAP = { SUPPORTED: 'VERIFIED', CONFLICTED: 'PARTIAL', UNVERIFIED: 'UNVERIFIED' };
+const SEVERITY_MAP = { DECISIVE: 'High', MATERIAL: 'Medium', LOW: 'Low' };
+function claimRuling(claim, adjudication) {
+    // UPHOLD/REJECT inverts ONLY on a disagreement (the ruling is on the objection); for every other
+    // state the ruling is evidence-based, matching deriveAudit's semantics.
+    if (claim.state === 'DISAGREEMENT') {
+        if (!adjudication || adjudication.ruling === 'UNRESOLVED')
+            return 'UNRESOLVED';
+        return adjudication.ruling === 'UPHOLD' ? 'REJECTED' : 'ACCEPTED';
     }
-    if (scorecard.length) {
-        L.push('## Dimension scorecard (best-effort)', '', '| Dimension | Status |', '|---|---|');
-        for (const r of scorecard)
-            L.push(`| ${mdCell(r.label)} | ${r.status} |`);
-        L.push('');
+    if (claim.state === 'UNCERTAIN')
+        return 'UNRESOLVED';
+    return claim.evidence_state === 'SUPPORTED' ? 'ACCEPTED' : 'CONDITIONAL';
+}
+function verificationStatusByClaim(verifications) {
+    const statuses = new Map();
+    for (const item of verifications.verifications) {
+        if ('claim_id' in item)
+            statuses.set(item.claim_id, item.status);
+        else
+            statuses.set(item.target_id, item.verdict === 'CONFIRM' ? 'VERIFIED' : item.verdict === 'REFUTE' ? 'CONTRADICTED' : 'PARTIAL');
     }
-    L.push('## Assumption audit', '', '| Claim | Status | Confidence | Analysts |', '|---|---|---|---|');
-    for (const r of audit)
-        L.push(`| ${mdCell(r.statement)} | ${r.status} | ${r.confidence} | ${attrib(r.providers)} |`);
-    L.push('');
-    const failed = audit.filter((r) => r.status === 'failed');
-    if (failed.length) {
-        L.push('## Risks that held up', '');
-        for (const r of failed)
-            L.push(`- ${r.statement} _(${r.confidence})_`);
-        L.push('');
+    return statuses;
+}
+function buildDossier(args) {
+    const { graph, judgeReport, actionPlan, rebuttals, seats } = args;
+    const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
+    const reportClaimById = new Map(args.claims.map((claim) => [claim.id, claim]));
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const verificationById = verificationStatusByClaim(args.verifications);
+    const verifiedClaimIds = new Set([...verificationById].filter(([, status]) => status === 'VERIFIED').map(([id]) => id));
+    const dependencies = new Map();
+    for (const edge of graph.edges) {
+        if (edge.type !== 'DEPENDS_ON' || !claimById.has(edge.from) || !claimById.has(edge.to))
+            continue;
+        const ids = dependencies.get(edge.from) ?? [];
+        if (!ids.includes(edge.to))
+            ids.push(edge.to);
+        dependencies.set(edge.from, ids);
     }
-    if (map.contradictions.length) {
-        L.push('## The debate', '');
-        for (const d of map.contradictions) {
-            const adj = rulingById.get(d.id);
-            const claim = d.claim_ids.map((id) => claimById.get(id)?.statement ?? id).join(' / ');
-            const claimants = [...new Set(d.claim_ids.flatMap((id) => claimById.get(id)?.providers ?? []))];
-            const attackers = [...new Set(d.attacks.map((a) => a.provider))];
-            L.push(`- ${attrib(claimants)} claimed ${claim}. ${attrib(attackers)} countered: ${d.attacks.map((a) => a.argument).join('; ')}. ` +
-                `Chair: ${rulingPhrase(adj?.ruling)}${adj?.reasoning ? ` — ${adj.reasoning}` : ''}.`);
+    const recommendationIds = (judgeReport.recommendation_claim_ids ?? [])
+        .filter((id) => claimById.has(id));
+    const anchors = recommendationIds.length
+        ? recommendationIds
+        : graph.claims.filter((claim) => claim.load_bearing).slice(0, 8).map((claim) => claim.id);
+    const chainIds = [];
+    const seen = new Set();
+    const visit = (id) => {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        for (const dependency of dependencies.get(id) ?? [])
+            visit(dependency);
+        chainIds.push(id);
+    };
+    anchors.forEach(visit);
+    const claimChain = chainIds.flatMap((id) => {
+        const claim = reportClaimById.get(id);
+        return claim ? [{
+                claimId: id,
+                text: claim.text,
+                ruling: claim.ruling,
+                evidenceStatus: verificationById.get(id) ?? claim.verification,
+                dependsOn: dependencies.get(id) ?? [],
+            }] : [];
+    });
+    const evidence = graph.evidence.map((item) => {
+        const claimIds = graph.edges
+            .filter((edge) => edge.from === item.id && (edge.type === 'SUPPORTS' || edge.type === 'ATTACKS') && claimById.has(edge.to))
+            .map((edge) => edge.to);
+        const statuses = claimIds.map((id) => verificationById.get(id)).filter((status) => Boolean(status));
+        const verificationStatus = statuses.includes('CONTRADICTED') ? 'CONTRADICTED'
+            : statuses.length > 0 && statuses.every((status) => status === 'VERIFIED') ? 'VERIFIED'
+                : statuses.includes('UNVERIFIABLE') ? 'UNVERIFIABLE'
+                    : statuses.length ? 'PARTIAL' : 'NOT_CHECKED';
+        return {
+            id: item.id,
+            source: item.locator ?? (item.source_kind === 'MODEL_KNOWLEDGE' ? `${disp(item.provider)} model knowledge` : item.source_kind),
+            sourceKind: item.source_kind,
+            date: item.accessed_at ?? 'Not recorded',
+            freshness: item.freshness,
+            verificationStatus,
+            claimIds,
+        };
+    });
+    const positionChanges = (rebuttals?.events ?? []).map((event) => ({
+        eventId: event.id,
+        claimId: event.claim_id,
+        responder: event.responder,
+        response: event.response,
+        reasoning: event.reasoning,
+        evidenceIds: event.evidence_ids,
+        ...(event.narrowed_proposition ? { narrowedProposition: event.narrowed_proposition } : {}),
+    }));
+    const claimProviders = (claimId) => {
+        const claim = claimById.get(claimId);
+        if (!claim)
+            return [];
+        return [...new Set(claim.position_ids.map((id) => positionById.get(id).provider))];
+    };
+    const sharedConcerns = graph.claims.filter((claim) => claim.state === 'SHARED_CONCERN').map((claim) => ({
+        claimId: claim.id,
+        text: claim.proposition,
+        providerIds: claimProviders(claim.id),
+        evidenceStatus: verificationById.get(claim.id) ?? VERIFICATION_MAP[claim.evidence_state],
+    }));
+    const uniqueSupportedInsights = graph.claims.filter((claim) => claim.state === 'UNIQUE' && claim.evidence_state === 'SUPPORTED').flatMap((claim) => {
+        const providerId = claimProviders(claim.id)[0];
+        return providerId ? [{
+                claimId: claim.id,
+                text: claim.proposition,
+                providerId,
+                verificationStatus: verificationById.get(claim.id) ?? 'NOT_CHECKED',
+            }] : [];
+    });
+    const claimByPosition = new Map(graph.claims.flatMap((claim) => claim.position_ids.map((id) => [id, claim.id])));
+    const missingCoverage = new Set(graph.holes.coverage.map((hole) => hole.dimension_id));
+    const missingEvidence = new Set(graph.holes.evidence.map((hole) => hole.claim_id));
+    const coverage = args.rubric.map((dimension) => {
+        const claimIds = [...new Set(graph.positions
+                .filter((position) => position.dimension_id === dimension.id)
+                .map((position) => claimByPosition.get(position.id))
+                .filter((id) => Boolean(id)))];
+        const notApplicable = seats.some((seat) => seat.output.coverage.find((entry) => entry.dimension_id === dimension.id)?.status === 'NOT_APPLICABLE');
+        const status = missingCoverage.has(dimension.id) ? 'MISSING'
+            : claimIds.some((id) => missingEvidence.has(id)) ? 'MISSING_EVIDENCE'
+                : notApplicable && claimIds.length === 0 ? 'NOT_APPLICABLE' : 'COVERED';
+        return { dimensionId: dimension.id, label: dimension.label, status, claimIds };
+    });
+    const adjudicationById = new Map(judgeReport.adjudications.map((item) => [item.id, item]));
+    const sensitivity = graph.claims
+        .filter((claim) => claim.load_bearing && claim.sensitivity !== 'LOW')
+        .sort((a, b) => (a.sensitivity === 'DECISIVE' ? 0 : 1) - (b.sensitivity === 'DECISIVE' ? 0 : 1))
+        .map((claim) => {
+        const related = graph.edges
+            .filter((edge) => (edge.from === claim.id || edge.to === claim.id) && claimById.has(edge.from) && claimById.has(edge.to))
+            .map((edge) => edge.from === claim.id ? edge.to : edge.from);
+        const experiment = actionPlan && !('kind' in actionPlan)
+            ? actionPlan.actions.find((action) => action.validates === claim.id) : undefined;
+        const evidenceHole = graph.holes.evidence.find((hole) => hole.claim_id === claim.id);
+        return {
+            claimId: claim.id,
+            fact: claim.proposition,
+            sensitivity: claim.sensitivity,
+            impactIfFalse: claim.if_false,
+            whatWouldChangeIt: adjudicationById.get(claim.id)?.what_would_change_it
+                ?? experiment?.kill_signal
+                ?? evidenceHole?.reason
+                ?? `Resolve the evidence status for ${claim.id}.`,
+            linkedClaimIds: [...new Set(related)],
+        };
+    });
+    const experiments = actionPlan && !('kind' in actionPlan)
+        ? {
+            status: 'AVAILABLE',
+            note: actionPlan.sequencing_note,
+            actions: actionPlan.actions.map((action) => ({
+                order: action.order,
+                action: action.action,
+                why: action.why,
+                validates: action.validates,
+                effort: action.effort,
+                killSignal: action.kill_signal,
+            })),
         }
-        L.push('');
-    }
-    if (actionPlan) {
-        L.push('## Validation plan', '', '| # | Action | Why | Validates | Effort | Kill signal |', '|---|---|---|---|---|---|');
-        for (const a of actionPlan.actions) {
-            L.push(`| ${a.order} | ${mdCell(a.action)} | ${mdCell(a.why)} | ${mdCell(a.validates)} | ${a.effort} | ${mdCell(a.kill_signal)} |`);
+        : {
+            status: 'DEGRADED',
+            note: actionPlan && 'kind' in actionPlan
+                ? `Planner unavailable: ${actionPlan.reason}. Unresolved: ${actionPlan.unresolved_questions.join('; ')}`
+                : 'No planner artifact was recorded.',
+            actions: [],
+        };
+    const counter = judgeReport.strongest_counter_case;
+    const contributions = args.models.map((model) => ({
+        provider: model.provider,
+        name: model.name,
+        verifiedUniqueClaimIds: graph.claims
+            .filter((claim) => claim.state === 'UNIQUE' && verifiedClaimIds.has(claim.id) && claimProviders(claim.id).includes(model.provider))
+            .map((claim) => claim.id),
+    }));
+    const technicalPositions = graph.positions.map((position) => ({
+        id: position.id,
+        provider: position.provider,
+        stance: position.stance,
+        proposition: position.proposition,
+        evidenceIds: graph.evidence
+            .filter((evidence) => evidence.provider === position.provider
+            && evidence.source_id === position.source_id
+            && position.evidence_ids.some((id) => id === evidence.id || evidence.id.endsWith(`/${id}`)))
+            .map((evidence) => evidence.id),
+    }));
+    return {
+        recommendation: {
+            status: args.status,
+            summary: args.summary,
+            reason: args.reason,
+            claimIds: recommendationIds,
+            conditions: (judgeReport.conditions ?? []).map((text) => ({
+                text,
+                claimIds: (judgeReport.condition_claim_ids ?? []).filter((id) => claimById.has(id)),
+            })),
+        },
+        claimChain,
+        evidence,
+        positionChanges,
+        sharedConcerns,
+        uniqueSupportedInsights,
+        coverage,
+        sensitivity,
+        experiments,
+        counterCase: counter
+            ? { available: true, reasoning: counter.reasoning, claimIds: counter.claim_ids.filter((id) => claimById.has(id)) }
+            : { available: false, reasoning: 'No graph-anchored counter-case was recorded.', claimIds: [] },
+        contributions,
+        technical: {
+            submissions: seats.map((seat) => ({
+                provider: seat.provider,
+                name: disp(seat.provider),
+                strongestVersion: seat.output.strongest_version,
+                positionIds: graph.positions.filter((position) => position.provider === seat.provider).map((position) => position.id),
+            })),
+            positions: technicalPositions,
+            edges: graph.edges,
+            events: positionChanges,
+        },
+    };
+}
+/** Assemble the machine-readable report deterministically from the run's persisted artifacts. */
+export function buildDecisionReport(ctx, args) {
+    const { contract, seats, graph, verifications, judgeReport, actionPlan } = args;
+    const mode = ctx.mode ?? 'council';
+    const flags = new Set(ctx.flags);
+    const confidence = computeConfidence(graph, flags);
+    const status = statusFrom(judgeReport);
+    const rulingById = new Map(judgeReport.adjudications.map((a) => [a.id, a]));
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
+    const openQuestions = mergeOpenQuestions(seats);
+    const claims = graph.claims.map((claim) => {
+        const stances = {};
+        for (const id of claim.position_ids) {
+            const position = positionById.get(id);
+            stances[position.provider] ??= STANCE_MAP[position.stance] ?? 'UNKNOWN';
         }
-        L.push('', actionPlan.sequencing_note, '');
-    }
-    const questions = mergeOpenQuestions(seats);
-    if (questions.length) {
-        L.push('## Open questions that flip the verdict', '');
-        for (const q of questions)
-            L.push(`- ${q}`);
-        L.push('');
-    }
-    L.push('## Red-team note', '');
-    for (const d of judgeReport.dissent)
-        L.push(`- ${d}`);
-    L.push('', `_Confidence: ${judgeReport.confidence_notes}_`, '');
-    L.push('## Strongest case (per analyst)', '');
-    for (const seat of seats)
-        L.push(`- **${disp(seat.provider)}:** ${seat.output.strongest_version}`);
-    L.push('');
-    L.push('## Disagreement map', '');
-    L.push(`**Consensus (≥2 analysts):** ${map.consensus.length}`);
-    for (const c of map.consensus)
-        L.push(`- ${c.statement}  _(${attrib(c.providers)})_`);
-    L.push('', `**Unique (one analyst):** ${map.unique.length}`);
-    for (const c of map.unique)
-        L.push(`- ${c.statement}  _(${attrib(c.providers)})_`);
-    L.push('', `**Contradictions:** ${map.contradictions.length}`);
-    for (const d of map.contradictions) {
-        const adj = rulingById.get(d.id);
-        L.push(`- **${d.id}** ${adj ? `→ ${adj.ruling}` : ''}: ${d.attacks.map((a) => a.argument).join('; ')}`);
-    }
-    if (map.blind_spots.length) {
-        L.push('', `**Blind spots (rubric items no analyst addressed):**`);
-        for (const b of map.blind_spots)
-            L.push(`- ${b}`);
+        return {
+            id: claim.id,
+            text: claim.proposition,
+            stances,
+            verification: VERIFICATION_MAP[claim.evidence_state],
+            ruling: claimRuling(claim, rulingById.get(claim.id)),
+            loadBearing: claim.load_bearing,
+            sensitivity: claim.sensitivity,
+        };
+    });
+    const disagreements = graph.claims.filter((claim) => claim.state === 'DISAGREEMENT').map((claim) => {
+        const positions = claim.position_ids.map((id) => positionById.get(id));
+        const sides = ['SUPPORT', 'OPPOSE', 'MIXED'].flatMap((stance) => {
+            const inStance = positions.filter((position) => position.stance === stance);
+            return inStance.length
+                ? [{ stance, providers: inStance.map((position) => disp(position.provider)), reasoning: inStance.map((position) => position.reasoning) }]
+                : [];
+        });
+        const adjudication = rulingById.get(claim.id);
+        return {
+            id: claim.id,
+            topic: claim.proposition,
+            sides,
+            ruling: rulingPhrase(adjudication?.ruling),
+            reasoning: adjudication?.reasoning ?? null,
+            status: (adjudication && adjudication.ruling !== 'UNRESOLVED' ? 'RESOLVED' : 'UNRESOLVED'),
+        };
+    });
+    const uniqueOppositions = graph.claims
+        .filter((claim) => claim.state === 'UNIQUE')
+        .flatMap((claim) => claim.position_ids.map((id) => positionById.get(id)))
+        .filter((position) => position.stance === 'OPPOSE')
+        .map((position) => ({ provider: disp(position.provider), proposition: position.proposition }));
+    const unresolvedDecisive = disagreements.some((d) => d.status === 'UNRESOLVED' && claimById.get(d.id)?.sensitivity === 'DECISIVE');
+    const consensusType = mode === 'quick' ? 'single_analyst' : disagreements.length === 0
+        ? (claims.some((claim) => claim.ruling === 'UNRESOLVED') ? 'convergent_with_unresolved_claims' : 'unanimous')
+        : disagreements.every((d) => d.status === 'RESOLVED') ? 'majority_with_dissent' : 'contested';
+    const risks = graph.claims
+        .filter((claim) => claim.load_bearing && claim.evidence_state !== 'SUPPORTED')
+        .map((claim) => ({ risk: claim.proposition, severity: SEVERITY_MAP[claim.sensitivity] ?? 'Medium' }));
+    // Frame the slot as what it is — a decisive assumption that is NOT proven. Echoing the bare
+    // proposition inverts the meaning when the claim is phrased affirmatively (run 20260714-2321:
+    // "a cutover can preserve compliance" read as reassurance, the opposite of the verdict).
+    const criticalClaim = graph.claims.find((claim) => claim.load_bearing && claim.if_false === 'STOP' && claim.evidence_state !== 'SUPPORTED');
+    const criticalWarning = criticalClaim
+        ? `Unverified decisive assumption (if false, STOP): ${criticalClaim.proposition} — evidence ${criticalClaim.evidence_state}.`
+        : null;
+    const verificationResults = verifications.verifications.map((v) => {
+        if ('claim_id' in v) {
+            return {
+                claimId: v.claim_id,
+                claim: claimById.get(v.claim_id)?.proposition ?? v.claim_id,
+                method: 'independent verifier model',
+                verdict: (v.status === 'VERIFIED' ? 'CONFIRMED' : v.status === 'CONTRADICTED' ? 'REFUTED' : 'UNCERTAIN'),
+                evidence: v.evidence_ids.length ? v.evidence_ids.join(', ') : v.missing_evidence.join('; '),
+                note: v.reasoning,
+            };
+        }
+        return {
+            claimId: v.target_id,
+            claim: claimById.get(v.target_id)?.proposition ?? v.target_id,
+            method: 'independent verifier model',
+            verdict: (v.verdict === 'CONFIRM' ? 'CONFIRMED' : v.verdict === 'REFUTE' ? 'REFUTED' : 'UNCERTAIN'),
+            evidence: v.evidence,
+            note: v.note,
+        };
+    });
+    const byProvider = {};
+    let modelTimeMs = 0;
+    for (const call of ctx.calls) {
+        byProvider[call.provider] = (byProvider[call.provider] ?? 0) + 1;
+        modelTimeMs += call.durationMs;
     }
-    L.push('');
-    L.push('## Receipt', '', ...receiptLines(ctx), '');
-    return L.join('\n');
+    const roles = ctx.roles;
+    const reportProviders = mode === 'quick' ? [...new Set(seats.map((seat) => seat.provider))] : ctx.available();
+    const models = reportProviders.map((provider) => ({
+        provider,
+        name: disp(provider),
+        roles: mode === 'quick' ? ['single analyst'] : [
+            ...(roles.analyst === provider ? ['analyst'] : []),
+            ...(roles.judge === provider ? ['judge'] : []),
+            ...(roles.verifier === provider ? ['verifier'] : []),
+            ...(roles.s4.includes(provider) ? ['scout'] : []),
+        ],
+    }));
+    const positions = seats.map((seat) => {
+        const seatPositions = seat.output.positions;
+        const oppose = seatPositions.filter((position) => position.stance === 'OPPOSE').length;
+        const support = seatPositions.filter((position) => position.stance === 'SUPPORT').length;
+        return {
+            provider: seat.provider,
+            name: disp(seat.provider),
+            initialConclusion: seat.output.strongest_version,
+            mainArgument: seatPositions.find((position) => position.load_bearing)?.reasoning ?? seatPositions[0]?.reasoning ?? '—',
+            keyRisk: seatPositions.find((position) => position.stance === 'OPPOSE')?.proposition ?? '—',
+            finalPosition: (oppose > support ? 'Oppose' : oppose > 0 || status === 'ACCEPTED_WITH_CONDITIONS' ? 'Conditional' : 'Support'),
+        };
+    });
+    const dossier = buildDossier({
+        status,
+        summary: judgeReport.verdict,
+        reason: judgeReport.key_points?.[0] ?? judgeReport.verdict,
+        claims,
+        models,
+        seats,
+        graph,
+        verifications,
+        judgeReport,
+        actionPlan,
+        rebuttals: args.rebuttals,
+        rubric: args.rubric ?? [],
+    });
+    const decisionSnapshot = judgeReport.decision_snapshot ? {
+        decisiveNumbers: judgeReport.decision_snapshot.decisive_numbers.map((item) => ({
+            label: item.label,
+            value: item.value,
+            meaning: item.meaning,
+            claimIds: item.claim_ids,
+        })),
+        ...(judgeReport.decision_snapshot.payback ? {
+            payback: {
+                status: judgeReport.decision_snapshot.payback.status,
+                result: judgeReport.decision_snapshot.payback.result,
+                basis: judgeReport.decision_snapshot.payback.basis,
+                claimIds: judgeReport.decision_snapshot.payback.claim_ids,
+            },
+        } : {}),
+        options: judgeReport.decision_snapshot.options.map((option) => ({
+            label: option.label,
+            commitment: option.commitment,
+            commitmentKind: option.commitment_kind,
+            tradeoff: option.tradeoff,
+            claimIds: option.claim_ids,
+        })),
+        ...(judgeReport.decision_snapshot.tripwire ? {
+            tripwire: {
+                metric: judgeReport.decision_snapshot.tripwire.metric,
+                threshold: judgeReport.decision_snapshot.tripwire.threshold,
+                decisionRule: judgeReport.decision_snapshot.tripwire.decision_rule,
+                claimIds: judgeReport.decision_snapshot.tripwire.claim_ids,
+            },
+        } : {}),
+    } : undefined;
+    return {
+        reportId: ctx.runId,
+        generatedAt: new Date().toISOString(),
+        mode,
+        task: {
+            original: args.original ?? contract.task,
+            normalized: contract.task,
+            type: contract.task_type,
+            constraints: contract.constraints,
+            successCriteria: contract.success_criteria,
+            ...('confirmation' in contract && typeof contract.confirmation === 'string' ? { confirmation: contract.confirmation } : {}),
+        },
+        verdict: {
+            status,
+            summary: judgeReport.verdict,
+            confidence: confidence.score / 100,
+            confidenceLabel: confidence.label,
+            consensusType,
+            conditions: judgeReport.conditions ?? [],
+            primaryReason: judgeReport.key_points?.[0] ?? judgeReport.verdict,
+            criticalWarning,
+        },
+        keyFindings: (judgeReport.key_points?.length ? judgeReport.key_points : [judgeReport.verdict]).slice(0, 4),
+        criticalUnknowns: openQuestions.slice(0, 3),
+        ...(decisionSnapshot ? { decisionSnapshot } : {}),
+        confidenceBreakdown: confidence,
+        models,
+        positions,
+        claims,
+        consensusSummary: {
+            unanimous: graph.claims.filter((claim) => claim.state === 'CONSENSUS').length,
+            accepted: claims.filter((claim) => claim.ruling === 'ACCEPTED').length,
+            conditional: claims.filter((claim) => claim.ruling === 'CONDITIONAL').length,
+            unresolved: claims.filter((claim) => claim.ruling === 'UNRESOLVED').length,
+            rejected: claims.filter((claim) => claim.ruling === 'REJECTED').length,
+        },
+        disagreements,
+        minority: {
+            dissent: judgeReport.dissent,
+            uniqueOppositions,
+            blocksDecision: unresolvedDecisive ? 'YES' : (judgeReport.conditions?.length ? 'ONLY_IF_CONDITION' : 'NO'),
+        },
+        verification: {
+            results: verificationResults,
+            confirmed: verificationResults.filter((result) => result.verdict === 'CONFIRMED').length,
+            refuted: verificationResults.filter((result) => result.verdict === 'REFUTED').length,
+            uncertain: verificationResults.filter((result) => result.verdict === 'UNCERTAIN').length,
+        },
+        risks,
+        recommendedActions: actionPlan && !('kind' in actionPlan)
+            ? actionPlan.actions.map((action) => ({ order: action.order, action: action.action, why: action.why, effort: action.effort, killSignal: action.kill_signal }))
+            : [],
+        openQuestions,
+        flags: [...ctx.flags],
+        receipt: { calls: ctx.calls.length, budget: ctx.budget.limit, byProvider, modelTimeMs, categories: receiptCategories(ctx) },
+        dossier,
+    };
+}
+const pct = (n) => `${Math.round(n * 100)}%`;
+export { renderDecisionDossierMarkdown };
+export function renderReport(ctx, args) {
+    return renderDecisionDossierMarkdown(buildDecisionReport(ctx, args));
+}
+// ── Terminal summary (level 1) ───────────────────────────────────────────────
+const RULE = '─'.repeat(52);
+export function renderTerminalSummary(report, paths) {
+    const summary = report.consensusSummary;
+    const c = report.confidenceBreakdown;
+    const snapshot = report.decisionSnapshot;
+    const decisiveLines = snapshot ? [
+        'Decision numbers:',
+        ...snapshot.decisiveNumbers.slice(0, 3).map((item) => `${item.label}: ${item.value} — ${item.meaning}`),
+        ...(snapshot.payback ? [`Payback (${snapshot.payback.status.replaceAll('_', ' ').toLowerCase()}): ${snapshot.payback.result}`] : []),
+        `Options: ${snapshot.options.map((option) => `${option.label} — ${option.commitment} (${option.commitmentKind.replace('_', ' ').toLowerCase()})`).join(' · ')}`,
+    ] : ['Decisive result:', report.verdict.primaryReason];
+    const checks = [
+        `[${c.verificationCoverage >= 0.5 ? 'PASS' : 'WARN'}] Verification coverage ${pct(c.verificationCoverage)} of load-bearing claims`,
+        `[PASS] Minority opinion preserved (${report.minority.dissent.length} dissent item(s))`,
+        `[${report.verification.refuted === 0 ? 'PASS' : 'WARN'}] Verifier refutations: ${report.verification.refuted}`,
+        ...(report.flags.length ? [`[WARN] Degradation flags: ${report.flags.join(', ')}`] : []),
+        `[WARN] Structural score ${c.score}/100 is heuristic — not yet benchmark-calibrated`,
+    ];
+    return [
+        report.mode === 'quick' ? 'SINGLE-MODEL DECISION REPORT' : 'MULTI-MODEL DECISION REPORT',
+        RULE,
+        `Verdict: ${report.verdict.summary}`,
+        `Decision state: ${report.verdict.status}`,
+        `Evidence coverage: ${pct(c.verificationCoverage)} of load-bearing claims independently verified`,
+        'Coverage note: unchecked inputs remain; this is not a probability of correctness.',
+        `${report.mode === 'quick' ? 'Claims' : 'Consensus'}: ${report.verdict.consensusType.replaceAll('_', ' ')} — ${summary.accepted} accepted · ${summary.rejected} rejected · ${summary.unresolved} unresolved`,
+        '',
+        ...decisiveLines,
+        '',
+        ...(report.verdict.criticalWarning ? ['Critical warning:', report.verdict.criticalWarning, ''] : []),
+        ...(report.minority.dissent[0] ? ['Critical dissent:', report.minority.dissent[0], ''] : []),
+        'Verification:',
+        ...checks,
+        '',
+        ...(report.recommendedActions[0] ? ['Recommended action:', report.recommendedActions[0].action, ''] : []),
+        ...(snapshot?.tripwire ? ['Go/no-go tripwire:', `${snapshot.tripwire.metric}: ${snapshot.tripwire.threshold} — ${snapshot.tripwire.decisionRule}`, ''] : []),
+        `Full report: ${paths.markdownPath}`,
+        `Audit JSON:  ${paths.jsonPath}`,
+    ].join('\n');
 }
 export async function s10Render(ctx, args) {
-    await ctx.writer.writeText('final-report', renderReport(ctx, args));
+    const report = buildDecisionReport(ctx, args);
+    await ctx.writer.writeJson('decision-report', report);
+    await ctx.writer.writeText('final-report', renderDecisionDossierMarkdown(report));
 }