aiki-cli 0.3.1 → 0.3.3

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

@@ -3,37 +3,26 @@
 // 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 { evidenceOrigin } from '../evidence-origin.js';
+import { buildReaderProjection, formatTokenLine, 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,12 +85,16 @@ 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;
+    // v6: only independent EXTERNAL evidence counts as quality — the user's own material restated
+    // as cards inflated f740's coverage to theater (8 of 12 cards were the user's idea-brief).
     const evidenceQuality = graph.evidence.length
-        ? graph.evidence.filter((card) => card.source_kind !== 'MODEL_KNOWLEDGE').length / graph.evidence.length : 0;
+        ? graph.evidence.filter((card) => evidenceOrigin(card) === 'EXTERNAL').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);
@@ -109,22 +102,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 +218,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 +267,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 +342,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,9 +357,11 @@ 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;
@@ -290,6 +370,15 @@ function buildDossier(args) {
         ...(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,
@@ -330,11 +419,13 @@ function buildDossier(args) {
         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,
@@ -352,7 +443,14 @@ function buildDossier(args) {
 export function buildDecisionReport(ctx, args) {
     const { contract, seats, graph, verifications, judgeReport, actionPlan } = args;
     const mode = ctx.mode ?? 'council';
+    const adaptiveAuto = ctx.isAuto === true;
+    const autoEscalationReasons = ctx.autoEscalationReasons ?? [];
     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]));
@@ -372,7 +470,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,
         };
@@ -401,12 +499,9 @@ export function buildDecisionReport(ctx, args) {
         .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
+    const consensusType = adaptiveAuto || 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).
@@ -414,6 +509,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 {
@@ -436,16 +543,29 @@ export function buildDecisionReport(ctx, args) {
     });
     const byProvider = {};
     let modelTimeMs = 0;
+    let inputTokens = 0, outputTokens = 0, estimatedCalls = 0;
     for (const call of ctx.calls) {
         byProvider[call.provider] = (byProvider[call.provider] ?? 0) + 1;
         modelTimeMs += call.durationMs;
+        if (call.usage) {
+            inputTokens += call.usage.inputTokens ?? 0;
+            outputTokens += call.usage.outputTokens ?? 0;
+            if (call.usage.estimated)
+                estimatedCalls++;
+        }
     }
     const roles = ctx.roles;
-    const reportProviders = mode === 'quick' ? [...new Set(seats.map((seat) => seat.provider))] : ctx.available();
+    const reportProviders = adaptiveAuto
+        ? [...new Set([...seats.map((seat) => seat.provider), ...ctx.calls.map((call) => call.provider)])]
+        : 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: adaptiveAuto ? [
+            ...(seats.some((seat) => seat.provider === provider) ? ['primary analyst'] : []),
+            ...(ctx.calls.some((call) => call.provider === provider && call.stage.startsWith('P0-')) ? ['preflight reader'] : []),
+            ...(ctx.calls.some((call) => call.provider === provider && call.stage === 'S4b') ? ['delta challenger'] : []),
+        ] : mode === 'quick' ? ['single analyst'] : [
             ...(roles.analyst === provider ? ['analyst'] : []),
             ...(roles.judge === provider ? ['judge'] : []),
             ...(roles.verifier === provider ? ['verifier'] : []),
@@ -479,6 +599,8 @@ export function buildDecisionReport(ctx, args) {
         rebuttals: args.rebuttals,
         rubric: args.rubric ?? [],
         requestedOutputs,
+        newDecisionContract,
+        flags,
     });
     const decisionSnapshot = judgeReport.decision_snapshot ? {
         decisiveNumbers: judgeReport.decision_snapshot.decisive_numbers.map((item) => ({
@@ -515,6 +637,10 @@ export function buildDecisionReport(ctx, args) {
         reportId: ctx.runId,
         generatedAt: new Date().toISOString(),
         mode,
+        ...(ctx.fastPath ? { fastPath: true } : {}),
+        ...(adaptiveAuto ? { adaptiveAuto: true } : {}),
+        ...(autoEscalationReasons.length ? { autoEscalationReasons } : {}),
+        ...(adaptiveAuto && ctx.attemptedStages?.includes('S4b') ? { autoChallengeUsed: true } : {}),
         task: {
             original: args.original ?? contract.task,
             normalized: contract.task,
@@ -564,55 +690,41 @@ 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],
-        receipt: { calls: ctx.calls.length, budget: ctx.budget.limit, byProvider, modelTimeMs, categories: receiptCategories(ctx) },
+        flags: [...flags],
+        receipt: { calls: ctx.calls.length, budget: ctx.budget.limit, byProvider, modelTimeMs, categories: receiptCategories(ctx), tokens: { inputTokens, outputTokens, estimatedCalls } },
         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.adaptiveAuto ? 'AIKI · ADAPTIVE DECISION'
+            : 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.receipt.tokens ? [`Tokens: ${formatTokenLine(report.receipt.tokens)}`] : []),
+        `Report: ${paths.markdownPath}`,
     ].join('\n');
 }
 export async function s10Render(ctx, args) {

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

@@ -16,15 +16,23 @@ 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, lane, prompt) {
-    const model = await jsonCall(ctx, ctx.handle(seat), `S4-${label}`, prompt, IdeaRoleOutputModel, { salvage: salvageIdeaRoleOutputModel });
+    // v6 tail guard: an S4 repair may spend only when the worst case (both seats repairing) still
+    // leaves the reserved tail — 2 seat calls + 2 repairs + 3 (chair, planner, one tail repair).
+    // When disallowed, jsonCall's salvage floor keeps the seat alive (proven on the f740 payloads).
+    const model = await jsonCall(ctx, ctx.handle(seat), `S4-${label}`, prompt, IdeaRoleOutputModel, {
+        salvage: salvageIdeaRoleOutputModel,
+        repair: ctx.budget.limit - ctx.budget.used >= 7,
+    });
     const output = { workflow: 'idea-refinement', ...model };
     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/s4b-challenge.js

@@ -0,0 +1,97 @@
+// v7 Phase D — one auto-only delta challenge over hard-gated claim packets.
+import { ChallengeDeltaSet as ChallengeDeltaSetSchema, } from '../../schemas/index.js';
+import { canProduceNewInformation, } from '../auto-profile.js';
+import { isFatal, StageError } from '../context.js';
+import { jsonCall } from '../jsonStage.js';
+import { buildClaimPackets } from './s8-verify.js';
+const CHALLENGE_PROMPT = `ROLE: Independent delta challenger. You see only the targeted anonymous claim
+packets below, not the full task. Confirm, counter, narrow, replace, or leave each claim unresolved.
+
+Output ONLY JSON:
+{"deltas":[{"claimId":"<G-id>","response":"CONFIRM|COUNTER|NARROW|REPLACE|UNRESOLVED",
+"reasoning":"<precise reason>","newEvidenceIds":["<E-id>"],
+"changedDecisionImpact":"<what changes, or why the decision stays stable>"}]}
+
+Return exactly one delta per packet. Cite only evidence IDs shown in that packet. Do not invent a
+source, URL, claim ID, or evidence ID. JSON only.
+TARGET CLAIM PACKETS: {{PACKETS_JSON}}`;
+export function buildChallengePrompt(packets) {
+    return CHALLENGE_PROMPT.replace('{{PACKETS_JSON}}', JSON.stringify(packets, null, 2));
+}
+function validateAndTranslate(result, targetIds, evidenceRefs, allowedEvidence) {
+    const expected = new Set(targetIds);
+    const seen = new Set();
+    const issues = [];
+    for (const delta of result.deltas) {
+        if (!expected.has(delta.claimId))
+            issues.push(`unknown claim id: ${delta.claimId}`);
+        if (seen.has(delta.claimId))
+            issues.push(`duplicate claim delta: ${delta.claimId}`);
+        seen.add(delta.claimId);
+        const allowed = allowedEvidence.get(delta.claimId) ?? new Set();
+        for (const id of delta.newEvidenceIds)
+            if (!allowed.has(id))
+                issues.push(`invalid evidence id for ${delta.claimId}: ${id}`);
+    }
+    for (const id of expected)
+        if (!seen.has(id))
+            issues.push(`missing claim delta: ${id}`);
+    if (issues.length)
+        throw new StageError('S4b', 'BAD_OUTPUT', issues.join('; '));
+    return {
+        deltas: result.deltas.map((delta) => ({
+            ...delta,
+            newEvidenceIds: delta.newEvidenceIds.map((id) => evidenceRefs.get(id)),
+        })),
+    };
+}
+function challengerProvider(ctx, primaryProvider) {
+    return [...new Set([ctx.roles.verifier, ...ctx.roles.s4, ...ctx.available()])]
+        .find((provider) => provider !== primaryProvider && ctx.available().includes(provider));
+}
+/** At most one provider call; no repair call and no work for an information-free target. */
+export async function s4bChallenge(ctx, graph, gates, primaryProvider) {
+    const byClaim = new Map(gates.map((gate) => [gate.claimId, gate]));
+    const targets = [...byClaim.values()]
+        .filter((gate) => graph.claims.some((claim) => claim.id === gate.claimId))
+        .filter((gate) => canProduceNewInformation(graph, gate.claimId))
+        .slice(0, 3);
+    const provider = challengerProvider(ctx, primaryProvider);
+    if (!targets.length || !provider)
+        return { deltas: [] };
+    const packets = buildClaimPackets(graph, targets.map((gate) => ({
+        claim_id: gate.claimId,
+        kind: gate.kind,
+    })));
+    try {
+        const result = await jsonCall(ctx, ctx.handle(provider), 'S4b', buildChallengePrompt(packets.packets), ChallengeDeltaSetSchema, { repair: false });
+        const translated = validateAndTranslate(result, targets.map((gate) => gate.claimId), packets.evidenceRefs, packets.allowedEvidence);
+        await ctx.writer.writeJson('challenge-deltas', translated);
+        return translated;
+    }
+    catch (error) {
+        if (isFatal(error))
+            throw error;
+        const empty = { deltas: [] };
+        await ctx.writer.writeJson('challenge-deltas', empty);
+        return empty;
+    }
+}
+/** Derived graph overlay; the stored S7 artifact and every non-target claim stay untouched. */
+export function overlayChallengeDeltas(graph, deltas) {
+    if (!deltas.length)
+        return graph;
+    const stateById = new Map(deltas.map((delta) => [delta.claimId,
+        delta.response === 'CONFIRM' ? 'CONSENSUS'
+            : delta.response === 'COUNTER' ? 'DISAGREEMENT'
+                : 'UNCERTAIN']));
+    return {
+        ...graph,
+        claims: graph.claims.map((claim) => {
+            const state = stateById.get(claim.id);
+            if (!state || (state === 'CONSENSUS' && claim.state === 'DISAGREEMENT'))
+                return claim;
+            return { ...claim, state };
+        }),
+    };
+}

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

@@ -2,17 +2,27 @@
 // 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 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
+// — task + constraints + success_criteria (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.
 import { StageError } from '../context.js';
 import { overlapCoefficient, tokenize } from '../cluster.js';
-/** `task_echo` must share ≥ this fraction of its tokens with the contract task to count as on-task.
+/** `task_echo` must share ≥ this fraction of its tokens with the contract to count as on-task.
  *  Overlap coefficient (not Jaccard) so a short echo is not penalized against a longer contract
  *  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;
+/** The reference token set is the contract the seat was told to address — task + constraints +
+ *  success_criteria — NOT just the one-sentence task. Run 626e (2026-07-18, REAL QUORUM kill):
+ *  the prompt says "restate the task" and both seats paraphrased accurately, but against the
+ *  17-token model-authored task sentence they scored 0.294/0.250 < 0.3 and the run died with 18
+ *  good positions on disk. Against the full contract the same echoes score 0.680/0.500 while a
+ *  genuinely off-task echo stays ≤0.08 — paraphrase passes, drift still fails, threshold untouched. */
+function contractTokens(contract) {
+    return tokenize([contract.task, ...contract.constraints, ...contract.success_criteria].join(' '));
+}
 export async function s5Drift(ctx, contract, seats, minSeats = 2) {
-    const taskTokens = tokenize(contract.task);
+    const taskTokens = contractTokens(contract);
     const entries = [];
     const kept = [];
     const excluded = [];

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;
 }