aiki-cli 0.3.0 → 0.3.2

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

@@ -3,37 +3,25 @@
 // 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 { ReaderBrief as ReaderBriefSchema, readerBriefIssues } from '../../schemas/index.js';
 import { DISPLAY_NAME } from '../../providers/types.js';
 import { overlap, tokenize } from '../cluster.js';
-import { renderDecisionDossierMarkdown } from '../decision-dossier.js';
+import { interpretClaimOutcome } from '../decision-graph.js';
+import { buildReaderProjection, renderDecisionDossierMarkdown, sanitizeReaderText } 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]));
+    const ruling = new Map(judgeReport.adjudications.map((a) => [a.id, a]));
     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 (claim.state === 'UNCERTAIN' || claim.evidence_state !== 'SUPPORTED') {
-            [status, confidence] = ['unverified', 'LOW'];
-        }
-        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
-                [status, confidence] = ['unverified', 'LOW'];
-        }
-        else {
-            [status, confidence] = ['held', providers.length >= 2 ? 'HIGH' : 'MEDIUM'];
-        }
+        const outcome = interpretClaimOutcome(graph, claim, ruling.get(claim.id));
+        const status = outcome.decisionEffect === 'HELD' ? 'held'
+            : outcome.decisionEffect === 'FAILED' ? 'failed' : 'unverified';
+        const confidence = status === 'unverified' ? 'LOW'
+            : claim.state === 'DISAGREEMENT' ? 'MEDIUM'
+                : providers.length >= 2 ? 'HIGH' : 'MEDIUM';
         return { id: claim.id, statement: claim.proposition, providers, status, confidence };
     });
 }
@@ -96,8 +84,10 @@ const DEGRADATION_FLAGS = ['low_diversity', 'synthesis_suspect', 'plan_fallback'
  *  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 factual = loadBearing.filter((claim) => claim.nature === 'FACTUAL');
+    const verificationClaims = factual.length ? factual : loadBearing;
+    const verificationCoverage = verificationClaims.length
+        ? verificationClaims.filter((claim) => claim.evidence_state === 'SUPPORTED').length / verificationClaims.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
@@ -109,22 +99,93 @@ export function computeConfidence(graph, flags) {
         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 };
+    return {
+        score,
+        label,
+        verificationCoverage,
+        ...(factual.length ? { verificationScope: 'FACTUAL' } : {}),
+        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 (claim.state === 'UNCERTAIN')
-        return 'UNRESOLVED';
-    return claim.evidence_state === 'SUPPORTED' ? 'ACCEPTED' : 'CONDITIONAL';
+function claimRuling(graph, claim, adjudication) {
+    const truth = interpretClaimOutcome(graph, claim, adjudication).propositionTruth;
+    return truth === 'HOLDS' ? 'ACCEPTED' : truth === 'FAILS' ? 'REJECTED' : 'UNRESOLVED';
+}
+function fallbackReaderBrief(args) {
+    const labelFor = (id) => args.graph.claims.find((claim) => claim.id === id)?.proposition ?? null;
+    const clean = (value, max) => {
+        const text = sanitizeReaderText(value, labelFor);
+        if (text.length <= max)
+            return text;
+        const clipped = text.slice(0, max - 1);
+        const boundary = clipped.lastIndexOf(' ');
+        return `${clipped.slice(0, boundary > max * 0.6 ? boundary : max - 1).trimEnd()}…`;
+    };
+    const keyPoints = args.judgeReport.key_points ?? [];
+    const missing = args.missingRequestedOutputs.length
+        ? `Requested deliverables unavailable: ${args.missingRequestedOutputs.join(', ')}.`
+        : 'No additional requested deliverable was synthesized.';
+    const firstAction = args.actionPlan && !('kind' in args.actionPlan) ? args.actionPlan.actions[0]?.action : undefined;
+    const nextStep = firstAction
+        ?? args.openQuestions[0]
+        ?? args.judgeReport.strongest_counter_case?.reasoning
+        ?? 'Review the unresolved decision evidence before committing.';
+    const adjudicationById = new Map(args.judgeReport.adjudications.map((item) => [item.id, item]));
+    const acceptedClaims = new Set(args.graph.claims
+        .filter((claim) => claim.evidence_state === 'SUPPORTED'
+        && interpretClaimOutcome(args.graph, claim, adjudicationById.get(claim.id)).propositionTruth === 'HOLDS')
+        .map((claim) => claim.id));
+    const sourceIds = args.graph.evidence
+        .filter((evidence) => {
+        if (evidence.source_kind !== 'PRIMARY' && evidence.source_kind !== 'SECONDARY')
+            return false;
+        try {
+            const url = new URL(evidence.url ?? '');
+            if (url.protocol !== 'http:' && url.protocol !== 'https:')
+                return false;
+        }
+        catch {
+            return false;
+        }
+        return args.graph.edges.some((edge) => edge.from === evidence.id && edge.type === 'SUPPORTS' && acceptedClaims.has(edge.to));
+    })
+        .map((evidence) => evidence.id)
+        .slice(0, 8);
+    const raw = {
+        headline: clean(args.judgeReport.verdict, 160),
+        bottom_line: clean(args.judgeReport.verdict, 1200),
+        sections: [
+            {
+                heading: 'Why',
+                summary: clean(keyPoints[0] ?? args.judgeReport.verdict, 1000),
+                bullets: [...keyPoints.slice(1, 3), ...(args.judgeReport.conditions ?? []).slice(0, 2)].map((item) => clean(item, 500)),
+            },
+            {
+                heading: 'What remains',
+                summary: missing,
+                bullets: [args.openQuestions[0], args.judgeReport.strongest_counter_case?.reasoning]
+                    .filter((item) => Boolean(item)).map((item) => clean(item, 500)),
+            },
+        ],
+        next_step: clean(nextStep, 600),
+        caveats: [
+            ...(args.missingRequestedOutputs.length ? [missing] : []),
+            ...(args.flags.has('plan_skipped') || args.flags.has('plan_fallback')
+                ? ['The requested synthesis was unavailable; this concise summary uses the recorded chair decision only.'] : []),
+        ],
+        source_ids: sourceIds,
+    };
+    const brief = ReaderBriefSchema.parse(raw);
+    const issues = readerBriefIssues(brief, args.graph.claims.map((claim) => claim.id));
+    if (issues.length)
+        throw new Error(`fallback reader brief leaked graph ids: ${issues.join(', ')}`);
+    return brief;
 }
 function verificationStatusByClaim(verifications) {
     const statuses = new Map();
@@ -154,6 +215,18 @@ function buildDossier(args) {
     }
     const recommendationIds = (judgeReport.recommendation_claim_ids ?? [])
         .filter((id) => claimById.has(id));
+    const recommendationPositionIds = new Set(recommendationIds.flatMap((id) => claimById.get(id)?.position_ids ?? []));
+    const seatStats = [...graph.positions.reduce((stats, position) => {
+            const provider = position.id.split('/')[0].replace(/-coverage-fill$/, '');
+            const entry = stats.get(provider) ?? { provider, positions: 0, evidenced: 0, survivedIntoDecision: 0 };
+            entry.positions += 1;
+            if (position.evidence_ids.length)
+                entry.evidenced += 1;
+            if (recommendationPositionIds.has(position.id))
+                entry.survivedIntoDecision += 1;
+            stats.set(provider, entry);
+            return stats;
+        }, new Map()).values()];
     const anchors = recommendationIds.length
         ? recommendationIds
         : graph.claims.filter((claim) => claim.load_bearing).slice(0, 8).map((claim) => claim.id);
@@ -191,6 +264,8 @@ function buildDossier(args) {
             id: item.id,
             source: item.locator ?? (item.source_kind === 'MODEL_KNOWLEDGE' ? `${disp(item.provider)} model knowledge` : item.source_kind),
             sourceKind: item.source_kind,
+            ...(item.title ? { title: item.title } : {}),
+            ...(item.url ? { url: item.url } : {}),
             date: item.accessed_at ?? 'Not recorded',
             freshness: item.freshness,
             verificationStatus,
@@ -264,7 +339,7 @@ function buildDossier(args) {
             linkedClaimIds: [...new Set(related)],
         };
     });
-    const experiments = actionPlan && !('kind' in actionPlan)
+    const experiments = actionPlan && !('kind' in actionPlan) && actionPlan.actions.length > 0
         ? {
             status: 'AVAILABLE',
             note: actionPlan.sequencing_note,
@@ -279,11 +354,28 @@ function buildDossier(args) {
         }
         : {
             status: 'DEGRADED',
-            note: actionPlan && 'kind' in actionPlan
-                ? `Planner unavailable: ${actionPlan.reason}. Unresolved: ${actionPlan.unresolved_questions.join('; ')}`
-                : 'No planner artifact was recorded.',
+            note: actionPlan && !('kind' in actionPlan)
+                ? 'The answer is available, but no validation action survived anchor checks.'
+                : actionPlan && 'kind' in actionPlan
+                    ? `Planner unavailable: ${actionPlan.reason}. Unresolved: ${actionPlan.unresolved_questions.join('; ')}`
+                    : 'No planner artifact was recorded.',
             actions: [],
         };
+    const featureBacklog = actionPlan && !('kind' in actionPlan) ? actionPlan.feature_backlog : undefined;
+    const implementationPlan = actionPlan && !('kind' in actionPlan) ? actionPlan.implementation_plan : undefined;
+    const missingRequestedOutputs = [
+        ...(args.requestedOutputs.includes('FEATURE_BACKLOG') && !featureBacklog ? ['FEATURE_BACKLOG'] : []),
+        ...(args.requestedOutputs.includes('IMPLEMENTATION_PLAN') && !implementationPlan ? ['IMPLEMENTATION_PLAN'] : []),
+    ];
+    const persistedReaderBrief = actionPlan && !('kind' in actionPlan) ? actionPlan.reader_brief : undefined;
+    const readerBrief = persistedReaderBrief ?? (args.newDecisionContract ? fallbackReaderBrief({
+        graph,
+        judgeReport,
+        actionPlan,
+        openQuestions: mergeOpenQuestions(seats),
+        missingRequestedOutputs,
+        flags: args.flags,
+    }) : undefined);
     const counter = judgeReport.strongest_counter_case;
     const contributions = args.models.map((model) => ({
         provider: model.provider,
@@ -322,10 +414,15 @@ function buildDossier(args) {
         coverage,
         sensitivity,
         experiments,
+        ...(featureBacklog ? { featureBacklog } : {}),
+        ...(implementationPlan ? { implementationPlan } : {}),
+        ...(readerBrief ? { readerBrief } : {}),
+        missingRequestedOutputs,
         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,
+        seatStats,
         technical: {
             submissions: seats.map((seat) => ({
                 provider: seat.provider,
@@ -344,12 +441,19 @@ 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 newDecisionContract = 'success_bar' in contract;
+    const hasReaderBrief = Boolean(actionPlan && !('kind' in actionPlan) && actionPlan.reader_brief);
+    if (newDecisionContract && !hasReaderBrief && !flags.has('plan_skipped') && !flags.has('plan_fallback')) {
+        flags.add('plan_fallback');
+    }
     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 requestedOutputs = contract.requested_outputs
+        ?? ['DECISION'];
     const claims = graph.claims.map((claim) => {
         const stances = {};
         for (const id of claim.position_ids) {
@@ -361,7 +465,7 @@ export function buildDecisionReport(ctx, args) {
             text: claim.proposition,
             stances,
             verification: VERIFICATION_MAP[claim.evidence_state],
-            ruling: claimRuling(claim, rulingById.get(claim.id)),
+            ruling: claimRuling(graph, claim, rulingById.get(claim.id)),
             loadBearing: claim.load_bearing,
             sensitivity: claim.sensitivity,
         };
@@ -393,9 +497,6 @@ export function buildDecisionReport(ctx, args) {
     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).
@@ -403,6 +504,18 @@ export function buildDecisionReport(ctx, args) {
     const criticalWarning = criticalClaim
         ? `Unverified decisive assumption (if false, STOP): ${criticalClaim.proposition} — evidence ${criticalClaim.evidence_state}.`
         : null;
+    // Same framing problem as the critical warning above: an unsettled load-bearing claim rendered as
+    // its bare (often affirmatively-phrased) proposition reads as an endorsement, not a risk. Frame
+    // each explicitly, sort worst-first, and skip the claim already surfaced as the critical warning
+    // so it isn't double-counted.
+    const severityRank = { High: 0, Medium: 1, Low: 2 };
+    const risks = graph.claims
+        .filter((claim) => claim.load_bearing && claim.evidence_state !== 'SUPPORTED' && claim.id !== criticalClaim?.id)
+        .map((claim) => ({
+        risk: `Rests on unsettled claim: ${claim.proposition} (evidence ${claim.evidence_state}).`,
+        severity: SEVERITY_MAP[claim.sensitivity] ?? 'Medium',
+    }))
+        .sort((a, b) => severityRank[a.severity] - severityRank[b.severity]);
     const verificationResults = verifications.verifications.map((v) => {
         if ('claim_id' in v) {
             return {
@@ -467,6 +580,9 @@ export function buildDecisionReport(ctx, args) {
         actionPlan,
         rebuttals: args.rebuttals,
         rubric: args.rubric ?? [],
+        requestedOutputs,
+        newDecisionContract,
+        flags,
     });
     const decisionSnapshot = judgeReport.decision_snapshot ? {
         decisiveNumbers: judgeReport.decision_snapshot.decisive_numbers.map((item) => ({
@@ -552,55 +668,39 @@ export function buildDecisionReport(ctx, args) {
             ? actionPlan.actions.map((action) => ({ order: action.order, action: action.action, why: action.why, effort: action.effort, killSignal: action.kill_signal }))
             : [],
         openQuestions,
-        flags: [...ctx.flags],
+        flags: [...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);
+const RULE = '─'.repeat(48);
+function terminalLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
 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`,
-    ];
+    const projection = report.dossier.readerBrief ? buildReaderProjection(report) : undefined;
+    const candidates = projection
+        ? [...projection.sections.flatMap((section) => [section.summary, ...section.bullets]), ...projection.caveats, projection.nextStep]
+        : [...(report.keyFindings ?? []), ...report.verdict.conditions, report.verdict.primaryReason];
+    const takeaways = [...new Set(candidates.map(terminalLine).filter(Boolean))].slice(0, 3);
+    const nextStep = projection?.nextStep ?? report.recommendedActions[0]?.action ?? 'Open the report and choose the smallest decisive next action.';
     return [
-        report.mode === 'quick' ? 'SINGLE-MODEL DECISION REPORT' : 'MULTI-MODEL DECISION REPORT',
+        report.mode === 'quick' ? 'AIKI · SINGLE-MODEL DECISION' : 'AIKI · COUNCIL DECISION',
         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,
+        `Verdict: ${terminalLine(projection?.headline ?? report.verdict.summary)}`,
+        terminalLine(projection?.bottomLine ?? report.verdict.primaryReason),
+        ...(projection?.warnings[0] ? [`Warning: ${projection.warnings[0].message}`] : []),
         '',
-        ...(report.verdict.criticalWarning ? ['Critical warning:', report.verdict.criticalWarning, ''] : []),
-        ...(report.minority.dissent[0] ? ['Critical dissent:', report.minority.dissent[0], ''] : []),
-        'Verification:',
-        ...checks,
+        'Key takeaways:',
+        ...takeaways.map((item) => `- ${item}`),
         '',
-        ...(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}`,
+        `Next step: ${terminalLine(nextStep)}`,
+        `Report: ${paths.markdownPath}`,
     ].join('\n');
 }
 export async function s10Render(ctx, args) {

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

@@ -21,10 +21,12 @@ async function runSeat(ctx, seat, label, lane, prompt) {
     await ctx.writer.writeRoleOutput(label, output);
     return { provider: seat, sample: label, lane, output };
 }
-export async function s4Analyze(ctx, prompts) {
+export async function s4Analyze(ctx, prompts, needsSourceFallback = false) {
     const seats = ctx.roles.s4;
     const settled = await Promise.allSettled(seats.map((seat, index) => {
         const lane = IDEA_LANES[index % IDEA_LANES.length];
+        if (needsSourceFallback && ctx.mode !== 'quick' && seat === 'codex')
+            ctx.addFlag('source_fallback_search');
         return runSeat(ctx, seat, seat, lane, prompts[lane]);
     }));
     const survivors = [];

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

@@ -1,5 +1,23 @@
 // 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.
+/** A surviving scout seat with little output or evidence is weak. ponytail: thresholds are blunt on
+ * purpose; raise them only with benchmark evidence. */
+export function detectWeakSeat(positions, mode) {
+    if (mode === 'quick')
+        return [];
+    const seats = new Map();
+    for (const position of positions) {
+        const provider = position.id.split('/')[0].replace(/-coverage-fill$/, '');
+        const seat = seats.get(provider) ?? { positions: 0, evidenced: 0 };
+        seat.positions += 1;
+        if (position.evidence_ids?.length)
+            seat.evidenced += 1;
+        seats.set(provider, seat);
+    }
+    if (seats.size < 2)
+        return [];
+    return [...seats].filter(([, seat]) => seat.positions < 3 || seat.evidenced / seat.positions < 0.5).map(([provider]) => provider);
+}
 export function collectPositions(seats) {
     return seats.map((seat) => ({ provider: seat.provider, source_id: seat.sample ?? seat.provider, submission: seat.output }));
 }

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

@@ -4,6 +4,7 @@ import { compileDecisionGraph, coverageHoleQueue, positionId } from '../decision
 import { IdeaRoleOutputModel } from '../../schemas/index.js';
 import { isFatal } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
+import { detectWeakSeat } from './s6-positions.js';
 import { overlapCoefficient, tokenize } from '../cluster.js';
 const GROUP_SIMILARITY = 0.8;
 export function buildCoverageFillPrompt(task, holes) {
@@ -71,6 +72,8 @@ 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);
+    if (detectWeakSeat(graph.positions, ctx.mode ?? 'council').length)
+        ctx.addFlag('weak_seat');
     await ctx.writer.writeJson('decision-graph', graph);
     return graph;
 }

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

@@ -4,6 +4,7 @@ import { selectEscalations } from '../decision-graph.js';
 import { ClaimVerificationSet } from '../../schemas/index.js';
 import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
+import { loadSkill } from '../skills.js';
 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",
@@ -12,8 +13,21 @@ provided evidence cards and deterministic calculation checks. Output ONLY JSON:
 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.
+Judge each item independently; no verdict quota. JSON only.{{SKILL}}
 ITEMS: {{ITEMS_JSON}}`;
+export function selectVerificationTargets(claims, max) {
+    return claims
+        .map((claim, index) => ({ claim, index }))
+        .sort((left, right) => Number(right.claim.nature === 'FACTUAL') - Number(left.claim.nature === 'FACTUAL') || left.index - right.index)
+        .slice(0, max)
+        .map(({ claim }) => claim);
+}
+export function selectVerificationEscalations(graph, max = 8) {
+    const candidates = selectEscalations(graph, { max: graph.claims.length });
+    const byId = new Map(candidates.map((candidate) => [candidate.claim_id, candidate]));
+    const claims = candidates.map((candidate) => graph.claims.find((claim) => claim.id === candidate.claim_id));
+    return selectVerificationTargets(claims, max).map((claim) => byId.get(claim.id));
+}
 function evidenceIdsForClaim(graph, claimId) {
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
     const claim = graph.claims.find((item) => item.id === claimId);
@@ -25,12 +39,12 @@ function evidenceIdsForClaim(graph, claimId) {
         .flatMap((calculation) => calculation.inputs.flatMap((input) => input.evidence_ids));
     return new Set([...positionEvidence, ...calculationEvidence]);
 }
-function verifierInput(graph) {
+function verifierInput(graph, skill = '') {
     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 items = selectVerificationEscalations(graph).map((escalation) => {
         const claim = graph.claims.find((item) => item.id === escalation.claim_id);
         const linkedEvidenceIds = evidenceIdsForClaim(graph, claim.id);
         return {
@@ -64,13 +78,16 @@ function verifierInput(graph) {
             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 };
+    const prompt = S8_PROMPT
+        .replace('{{SKILL}}', skill ? `\n\n${skill}` : '')
+        .replace('{{ITEMS_JSON}}', JSON.stringify(items, null, 2));
+    return { prompt, evidenceRefs };
 }
-export function buildVerifierPrompt(graph) {
-    return verifierInput(graph).prompt;
+export function buildVerifierPrompt(graph, skill = '') {
+    return verifierInput(graph, skill).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)) {
+export function claimVerificationRefIssues(graph, verifications, expectedIds = selectVerificationEscalations(graph).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();
@@ -111,7 +128,7 @@ export function claimVerificationRefIssues(graph, verifications, expectedIds = s
     return issues;
 }
 export async function s8Verify(ctx, graph) {
-    const escalations = selectEscalations(graph, { max: 8 });
+    const escalations = selectVerificationEscalations(graph);
     if (escalations.length === 0) {
         const empty = { verifications: [] };
         await ctx.writer.writeJson('verifications', empty);
@@ -138,7 +155,7 @@ export async function s8Verify(ctx, graph) {
         return skipped;
     }
     try {
-        const input = verifierInput(graph);
+        const input = verifierInput(graph, loadSkill('idea-refinement', 'verifier'));
         // 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 = {

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

@@ -5,6 +5,7 @@ import { selectRebuttalEscalations, } from '../decision-graph.js';
 import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
 import { IDEA_MODE_PLANS } from '../modes.js';
+import { loadSkill } from '../skills.js';
 /** Internal protocol caps only. R6 owns exposing modes and changing the surrounding topology. */
 export const REBUTTAL_LIMITS = {
     quick: { maxNodes: 0, optionalCalls: 0 },
@@ -22,7 +23,7 @@ Output ONLY JSON:
 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.
+sources, URLs, claim IDs, or evidence IDs. JSON only.{{SKILL}}
 NODES: {{NODES_JSON}}`;
 function claimAuthors(graph, claimId) {
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
@@ -70,7 +71,7 @@ export function planRebuttalCalls(graph, escalations, scouts, judge) {
         return claim_ids?.length ? [{ provider, claim_ids }] : [];
     });
 }
-function rebuttalInput(graph, verifications, escalationById, assignment) {
+function rebuttalInput(graph, verifications, escalationById, assignment, skill = '') {
     const claimIds = new Set(assignment.claim_ids);
     const positionRefs = new Map();
     const evidenceRefs = new Map();
@@ -130,11 +131,16 @@ function rebuttalInput(graph, verifications, escalationById, assignment) {
         };
     });
     return {
-        prompt: REBUTTAL_PROMPT.replace('{{NODES_JSON}}', JSON.stringify(nodes, null, 2)),
+        prompt: buildRebuttalPrompt(nodes, skill),
         evidenceRefs,
         allowedEvidence,
     };
 }
+export function buildRebuttalPrompt(nodes, skill = '') {
+    return REBUTTAL_PROMPT
+        .replace('{{SKILL}}', skill ? `\n\n${skill}` : '')
+        .replace('{{NODES_JSON}}', JSON.stringify(nodes, null, 2));
+}
 function translateEvents(graph, assignment, input, output, startIndex) {
     const expected = new Set(assignment.claim_ids);
     const seen = new Set();
@@ -189,8 +195,9 @@ export async function s8bRebuttal(ctx, graph, verifications, mode = ctx.mode) {
     const assignments = planned.slice(0, optionalCalls);
     const escalationById = new Map(escalations.map((item) => [item.claim_id, item]));
     const events = [];
+    const skill = loadSkill('idea-refinement', 'rebuttal');
     for (const assignment of assignments) {
-        const input = rebuttalInput(graph, verifications, escalationById, assignment);
+        const input = rebuttalInput(graph, verifications, escalationById, assignment, skill);
         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));