aiki-cli 0.3.2 → 0.3.5

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

@@ -7,7 +7,8 @@ import { ReaderBrief as ReaderBriefSchema, readerBriefIssues } from '../../schem
 import { DISPLAY_NAME } from '../../providers/types.js';
 import { overlap, tokenize } from '../cluster.js';
 import { interpretClaimOutcome } from '../decision-graph.js';
-import { buildReaderProjection, renderDecisionDossierMarkdown, sanitizeReaderText } from '../decision-dossier.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) {
@@ -90,8 +91,10 @@ export function computeConfidence(graph, flags) {
         ? 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);
@@ -440,6 +443,8 @@ 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);
@@ -494,7 +499,7 @@ 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';
     // Frame the slot as what it is — a decisive assumption that is NOT proven. Echoing the bare
@@ -538,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'] : []),
@@ -619,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,
@@ -669,7 +691,7 @@ export function buildDecisionReport(ctx, args) {
             : [],
         openQuestions,
         flags: [...flags],
-        receipt: { calls: ctx.calls.length, budget: ctx.budget.limit, byProvider, modelTimeMs, categories: receiptCategories(ctx) },
+        receipt: { calls: ctx.calls.length, budget: ctx.budget.limit, byProvider, modelTimeMs, categories: receiptCategories(ctx), tokens: { inputTokens, outputTokens, estimatedCalls } },
         dossier,
     };
 }
@@ -690,7 +712,8 @@ export function renderTerminalSummary(report, paths) {
     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' ? 'AIKI · SINGLE-MODEL DECISION' : 'AIKI · COUNCIL DECISION',
+        report.adaptiveAuto ? 'AIKI · ADAPTIVE DECISION'
+            : report.mode === 'quick' ? 'AIKI · SINGLE-MODEL DECISION' : 'AIKI · COUNCIL DECISION',
         RULE,
         `Verdict: ${terminalLine(projection?.headline ?? report.verdict.summary)}`,
         terminalLine(projection?.bottomLine ?? report.verdict.primaryReason),
@@ -700,6 +723,7 @@ export function renderTerminalSummary(report, paths) {
         ...takeaways.map((item) => `- ${item}`),
         '',
         `Next step: ${terminalLine(nextStep)}`,
+        ...(report.receipt.tokens ? [`Tokens: ${formatTokenLine(report.receipt.tokens)}`] : []),
         `Report: ${paths.markdownPath}`,
     ].join('\n');
 }

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

@@ -16,7 +16,13 @@ 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 };

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/s8-verify.js

@@ -1,6 +1,7 @@
 // S8 — independently verify graph-selected claims from stored evidence/calculation references.
 // Provider identity stays hidden; model output is translated back to graph evidence IDs before S9.
 import { selectEscalations } from '../decision-graph.js';
+import { sanitizeClaimGroups } from '../claim-groups.js';
 import { ClaimVerificationSet } from '../../schemas/index.js';
 import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
@@ -9,12 +10,18 @@ const S8_PROMPT = `ROLE: Independent verifier. Check each anonymous decision cla
 provided evidence cards and deterministic calculation checks. Output ONLY JSON:
 {"verifications": [{"claim_id": "<G-id>", "status": "VERIFIED|PARTIAL|CONTRADICTED|UNVERIFIABLE",
   "reasoning": "<concise reason>", "evidence_ids": ["<E-id>"],
-  "calculation_check": "PASS|FAIL|NOT_APPLICABLE", "missing_evidence": ["<gap>"]}]}
+  "calculation_check": "PASS|FAIL|NOT_APPLICABLE", "missing_evidence": ["<gap>"]}],
+ "claim_groups": [{"ids": ["<G-id>", "<G-id>"], "relation": "SAME|OPPOSES"}]}
 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.{{SKILL}}
-ITEMS: {{ITEMS_JSON}}`;
+Judge each item independently; no verdict quota.
+claim_groups: scan ALL CLAIMS below (not only ITEMS). Group ids that assert the SAME proposition in
+different words (relation "SAME") and pair ids that directly contradict each other (relation
+"OPPOSES"). Only group claims from different seats; use existing claim ids only; omit the field when
+there are none. JSON only.{{SKILL}}
+ITEMS: {{ITEMS_JSON}}
+ALL CLAIMS (id, proposition, seat — for claim_groups only): {{CLAIMS_JSON}}`;
 export function selectVerificationTargets(claims, max) {
     return claims
         .map((claim, index) => ({ claim, index }))
@@ -39,14 +46,18 @@ function evidenceIdsForClaim(graph, claimId) {
         .flatMap((calculation) => calculation.inputs.flatMap((input) => input.evidence_ids));
     return new Set([...positionEvidence, ...calculationEvidence]);
 }
-function verifierInput(graph, skill = '') {
+/** Slim, reusable packet seam: selected claims plus only their linked evidence/calculations. */
+export function buildClaimPackets(graph, targets = selectVerificationEscalations(graph)) {
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
     const evidenceRefs = new Map(graph.evidence.map((evidence, index) => [`E${index + 1}`, evidence.id]));
     const aliasByEvidence = new Map([...evidenceRefs].map(([alias, id]) => [id, alias]));
     const evidenceById = new Map(graph.evidence.map((evidence) => [evidence.id, evidence]));
-    const items = selectVerificationEscalations(graph).map((escalation) => {
+    const allowedEvidence = new Map();
+    const packets = targets.map((escalation) => {
         const claim = graph.claims.find((item) => item.id === escalation.claim_id);
         const linkedEvidenceIds = evidenceIdsForClaim(graph, claim.id);
+        allowedEvidence.set(claim.id, new Set([...linkedEvidenceIds]
+            .map((id) => aliasByEvidence.get(id)).filter((id) => id !== undefined)));
         return {
             id: claim.id,
             kind: escalation.kind,
@@ -78,9 +89,26 @@ function verifierInput(graph, skill = '') {
             evidence_hole: graph.holes.evidence.find((hole) => hole.claim_id === claim.id)?.reason,
         };
     });
+    return { packets, evidenceRefs, allowedEvidence };
+}
+function verifierInput(graph, skill = '') {
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const { packets, evidenceRefs } = buildClaimPackets(graph);
+    // Anonymous seat aliases (provider identity stays hidden): S1, S2, … by first appearance.
+    const seatAlias = new Map();
+    for (const position of graph.positions) {
+        if (!seatAlias.has(position.provider))
+            seatAlias.set(position.provider, `S${seatAlias.size + 1}`);
+    }
+    const claimsIndex = graph.claims.map((claim) => ({
+        id: claim.id,
+        proposition: claim.proposition,
+        seats: [...new Set(claim.position_ids.map((id) => seatAlias.get(positionById.get(id)?.provider ?? '') ?? '?'))],
+    }));
     const prompt = S8_PROMPT
         .replace('{{SKILL}}', skill ? `\n\n${skill}` : '')
-        .replace('{{ITEMS_JSON}}', JSON.stringify(items, null, 2));
+        .replace('{{ITEMS_JSON}}', JSON.stringify(packets, null, 2))
+        .replace('{{CLAIMS_JSON}}', JSON.stringify(claimsIndex, null, 2));
     return { prompt, evidenceRefs };
 }
 export function buildVerifierPrompt(graph, skill = '') {
@@ -89,12 +117,19 @@ export function buildVerifierPrompt(graph, skill = '') {
 /** Validate every S8 claim/evidence reference before the chair can see it. */
 export function claimVerificationRefIssues(graph, verifications, expectedIds = selectVerificationEscalations(graph).map((item) => item.claim_id)) {
     const expected = new Set(expectedIds);
+    const known = new Set(graph.claims.map((claim) => claim.id));
     const evidence = new Map(graph.evidence.map((item) => [item.id, item]));
     const seen = new Set();
     const issues = [];
     for (const verification of verifications.verifications) {
-        if (!expected.has(verification.claim_id))
+        // A claim id absent from the graph is a dangling reference (fatal even when the caller's
+        // expected set is derived from the verifications themselves, as S9's is).
+        if (!known.has(verification.claim_id)) {
             issues.push(`unknown claim id: ${verification.claim_id}`);
+            continue;
+        }
+        if (!expected.has(verification.claim_id))
+            issues.push(`unexpected claim verification: ${verification.claim_id}`);
         if (seen.has(verification.claim_id))
             issues.push(`duplicate claim verification: ${verification.claim_id}`);
         seen.add(verification.claim_id);
@@ -158,11 +193,13 @@ export async function s8Verify(ctx, 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 claimGroups = sanitizeClaimGroups(graph, result.claim_groups);
         const translated = {
             verifications: result.verifications.map((verification) => ({
                 ...verification,
                 evidence_ids: verification.evidence_ids.map((id) => input.evidenceRefs.get(id) ?? id),
             })),
+            ...(claimGroups.length ? { claim_groups: claimGroups } : {}),
         };
         const issues = claimVerificationRefIssues(graph, translated, escalations.map((item) => item.claim_id));
         if (issues.length)

package/dist/orchestration/stages/s9-judge.js

@@ -5,7 +5,7 @@ import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
 import { claimShortLabel } from '../decision-dossier.js';
 import { loadSkill } from '../skills.js';
-import { claimVerificationRefIssues, selectVerificationEscalations } from './s8-verify.js';
+import { claimVerificationRefIssues } from './s8-verify.js';
 const EMPTY_REBUTTALS = {
     round: 1,
     selected_claim_ids: [],
@@ -148,10 +148,14 @@ export function adjudicationEvidenceViolations(report, verifications) {
             return [`${item.id}: missing evidence_ids`];
         const allowed = new Set(verification.evidence_ids);
         const bad = item.evidence_ids.filter((id) => !allowed.has(id));
-        const unsettled = (verification.status === 'PARTIAL' || verification.status === 'UNVERIFIABLE') && item.ruling !== 'UNRESOLVED';
+        // v6: PARTIAL/UNVERIFIABLE no longer forces UNRESOLVED — the chair may rule on judgment with
+        // the caveat carried in its reasoning (run f740 lost 5 nuanced HOLDS rulings and a 125s Opus
+        // repair to the old rule). The one indefensible combination stays fatal: ruling HOLDS on
+        // positively CONTRADICTED evidence.
+        const contradicted = verification.status === 'CONTRADICTED' && (item.ruling === 'HOLDS' || item.ruling === 'UPHOLD');
         return [
             ...(bad.length ? [`${item.id}: invalid evidence ids ${bad.join(', ')}`] : []),
-            ...(unsettled ? [`${item.id}: ${verification.status} verification requires UNRESOLVED`] : []),
+            ...(contradicted ? [`${item.id}: CONTRADICTED verification cannot rule HOLDS`] : []),
         ];
     });
 }
@@ -216,7 +220,10 @@ function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProv
         ])];
     const evidenceRefs = new Map(citedEvidence.map((id, index) => [`E${index + 1}`, id]));
     const aliasByEvidence = new Map([...evidenceRefs].map(([alias, id]) => [id, alias]));
-    const selectedIds = selectVerificationEscalations(graph).map((item) => item.claim_id);
+    // Chair scope = the claims S8 actually verified (see s9Judge) — recomputing the escalation
+    // selection here on the overlaid graph would ask the chair to rule on claims that have no
+    // verifier record, which adjudicationEvidenceViolations then rejects after a paid call.
+    const selectedIds = verifications.verifications.map((item) => item.claim_id);
     const eligibleIds = judgeProvider ? adjudicableClaimIds(graph, selectedIds, judgeProvider) : selectedIds;
     const escalationIds = new Set(eligibleIds);
     const escalations = graph.claims.filter((claim) => escalationIds.has(claim.id)).map((claim) => {
@@ -265,7 +272,15 @@ function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProv
     return { prompt, evidenceRefs };
 }
 export async function s9Judge(ctx, contract, graph, verifications, rubric, rebuttals = EMPTY_REBUTTALS) {
-    const selectedIds = selectVerificationEscalations(graph).map((item) => item.claim_id);
+    // The chair adjudicates what S8 ACTUALLY verified (persisted in 08, replay-safe) — never a
+    // re-ranked selection. S8 picks targets from the pre-overlay graph and validates its own output
+    // against them; overlayClaimGroups (built from S8's OWN claim_groups) then shifts claim states,
+    // so re-running selectVerificationEscalations on the joined graph can disagree with a selection
+    // S8 could not have predicted. Run e1ce (2026-07-18): the re-selection dropped G2 / added G7 and
+    // rejected a fully-compliant verification set. The chair also structurally requires a
+    // verification per adjudicated claim (adjudicationEvidenceViolations), so the verified set IS
+    // the chair's scope; dangling/duplicate/evidence-linkage guards below still apply.
+    const selectedIds = verifications.verifications.map((item) => item.claim_id);
     const verificationIssues = claimVerificationRefIssues(graph, verifications, selectedIds);
     if (verificationIssues.length)
         throw new StageError('S9', 'BAD_OUTPUT', `invalid verification references: ${verificationIssues.join('; ')}`);

package/dist/orchestration/stages/s9b-plan.js

@@ -1,10 +1,10 @@
 // S9b — idea validation plan. This is the one report-v3 model call after the judge: it turns the
 // adjudicated risks, blind spots, and open questions into anchored validation actions. Rendering stays
 // deterministic; if the planner fails or produces unanchored actions, we write flagged unavailability.
-import { ActionPlan, FeatureBacklog, ImplementationPlan, ReaderBrief, readerBriefIssues } from '../../schemas/index.js';
+import { ActionPlan, FeatureBacklog, ImplementationPlan, ReaderBrief } from '../../schemas/index.js';
 import { z } from 'zod';
 import { BudgetExceeded, isFatal } from '../context.js';
-import { jsonCall } from '../jsonStage.js';
+import { coerceToSchema, jsonCall } from '../jsonStage.js';
 import { loadSkill } from '../skills.js';
 import { mergeOpenQuestions } from './s10-render.js';
 import { interpretClaimOutcome } from '../decision-graph.js';
@@ -235,19 +235,21 @@ function normalizeSourceIds(ids, allowed) {
     });
     return [...new Set(normalized)];
 }
+/** v6: requested deliverables the accepted plan still lacks — the caller decides whether that is
+ *  worth a repair call or an honest `plan_partial` flag. Never a reason to discard the plan. */
+export function missingDeliverables(plan, requestedOutputs) {
+    return requestedOutputs.filter((output) => (output === 'FEATURE_BACKLOG' && !plan.feature_backlog)
+        || (output === 'IMPLEMENTATION_PLAN' && !plan.implementation_plan));
+}
 export function anchoredActionPlan(plan, anchors, requestedOutputs = [], requireReaderBrief = false) {
-    if (requestedOutputs.includes('FEATURE_BACKLOG') && !plan.feature_backlog)
-        return null;
-    if (requestedOutputs.includes('IMPLEMENTATION_PLAN') && !plan.implementation_plan)
-        return null;
     if (requireReaderBrief && !plan.reader_brief)
         return null;
+    // v6: a reader brief citing known claim ids is KEPT — sanitizeReaderText already substitutes
+    // labels at render time; rejecting here cost run f740 a paid repair for zero reader benefit.
     const readerBrief = plan.reader_brief ? {
         ...plan.reader_brief,
         source_ids: normalizeSourceIds(plan.reader_brief.source_ids, anchors.sourceIds),
     } : undefined;
-    if (readerBrief && readerBriefIssues(readerBrief, anchors.knownReaderIds ?? anchors.claimIds).length)
-        return null;
     const actions = plan.actions
         .filter((a) => validAnchor(a.validates, anchors))
         .sort((a, b) => a.order - b.order)
@@ -288,7 +290,7 @@ function hasExplicitSchedule(context) {
     }));
 }
 export function normalizePlannerOutput(plan, calendarAllowed = true) {
-    return ActionPlan.parse({
+    const built = {
         actions: plan.actions.map((action, i) => ({
             ...action,
             order: i + 1,
@@ -303,7 +305,16 @@ export function normalizePlannerOutput(plan, calendarAllowed = true) {
                 })),
             } } : {}),
         ...(plan.reader_brief ? { reader_brief: plan.reader_brief } : {}),
-    });
+    };
+    const parsed = ActionPlan.safeParse(built);
+    if (parsed.success)
+        return parsed.data;
+    // v6 deterministic floor for offline/replay callers (jsonCall applies the same floor live):
+    // clip over-cap strings, truncate over-cap arrays — never discard a complete plan over cosmetics.
+    const eased = ActionPlan.safeParse(coerceToSchema(ActionPlan, built, true));
+    if (eased.success)
+        return eased.data;
+    return ActionPlan.parse(built);
 }
 function unavailablePlan(reason, contract, risks, blindSpots, openQuestions) {
     const unresolved = openQuestions.length ? openQuestions : [
@@ -341,18 +352,31 @@ export async function s9bPlan(ctx, contract, seats, graph, judgeReport, original
         return fallback('plan_skipped');
     const prompt = buildActionPlannerPrompt(answerContext, loadSkill('idea-refinement', 'planner'));
     const calendarAllowed = hasExplicitSchedule(answerContext);
+    // v6: a plan the model actually produced is never replaced by PlannerUnavailable. Complete →
+    // accept; missing a requested deliverable → one repair when budget allows, else accept partial
+    // with an honest `plan_partial` flag. PlannerUnavailable is reserved for nothing-parseable.
+    const accept = async (plan) => {
+        if (missingDeliverables(plan, requestedOutputs).length)
+            ctx.addFlag('plan_partial');
+        await ctx.writer.writeJson('action-plan', plan);
+        return plan;
+    };
+    let anchored = null;
     try {
         const first = normalizePlannerOutput(await jsonCall(ctx, ctx.handle(ctx.roles.judge), 'S9b-plan', prompt, PlannerOutput, {
             repair: ctx.budget.limit - ctx.budget.used >= 2,
         }), calendarAllowed);
-        const anchored = anchoredActionPlan(first, anchors, requestedOutputs, requireReaderBrief);
-        if (anchored) {
+        anchored = anchoredActionPlan(first, anchors, requestedOutputs, requireReaderBrief);
+        if (anchored && missingDeliverables(anchored, requestedOutputs).length === 0) {
             await ctx.writer.writeJson('action-plan', anchored);
             return anchored;
         }
-        if (ctx.budget.limit - ctx.budget.used < 1)
+        if (ctx.budget.limit - ctx.budget.used < 1) {
+            if (anchored)
+                return accept(anchored);
             return fallback('plan_fallback');
-        const repair = `${prompt}\n\n---\nYour previous response had invalid anchors, omitted a requested deliverable or reader_brief, used internal audit language, or cited an unknown source id.\n` +
+        }
+        const repair = `${prompt}\n\n---\nYour previous response had invalid anchors, omitted a requested deliverable or reader_brief, or cited an unknown source id.\n` +
             `Valid graph claim ids: ${anchors.claimIds.join(', ') || '(none)'}\n` +
             `Valid blind spots: ${anchors.blindSpots.join(' | ') || '(none)'}\n` +
             `Valid open questions: ${anchors.openQuestions.join(' | ') || '(none)'}\n` +
@@ -361,15 +385,20 @@ export async function s9bPlan(ctx, contract, seats, graph, judgeReport, original
             `Output ONLY corrected JSON with every action anchored, reader_brief present, and every requested deliverable present.`;
         const repaired = normalizePlannerOutput(await jsonCall(ctx, ctx.handle(ctx.roles.judge), 'S9b-anchor-repair', repair, PlannerOutput, { repair: false }), calendarAllowed);
         const repairedAnchored = anchoredActionPlan(repaired, anchors, requestedOutputs, requireReaderBrief);
-        if (repairedAnchored) {
+        if (repairedAnchored && missingDeliverables(repairedAnchored, requestedOutputs).length === 0) {
             await ctx.writer.writeJson('action-plan', repairedAnchored);
             return repairedAnchored;
         }
+        const best = repairedAnchored ?? anchored;
+        if (best)
+            return accept(best);
         return fallback('plan_fallback');
     }
     catch (e) {
         if (isFatal(e) && !(e instanceof BudgetExceeded))
             throw e;
+        if (anchored)
+            return accept(anchored);
         return fallback('plan_fallback');
     }
 }

package/dist/orchestration/url-sources.js

@@ -56,6 +56,13 @@ async function assertPublicUrl(url, resolveHostname) {
         throw new Error('private or local URLs are not allowed');
     }
 }
+/** Validate an attached URL before the browser shows a FETCH_URL permission card. This performs
+ *  the same public-network guard as snapshotting, but does not fetch the page. */
+export async function validatePublicUrl(raw, resolveHostname = true) {
+    const url = new URL(raw);
+    await assertPublicUrl(url, resolveHostname);
+    return url.toString();
+}
 function npmRegistryUrl(url) {
     if (url.hostname !== 'npmjs.com' && url.hostname !== 'www.npmjs.com')
         return undefined;
@@ -198,3 +205,17 @@ export async function snapshotUrlSources(input, options = {}) {
     const sources = await Promise.all(extractPublicUrls(input).map((url, index) => snapshotOne(url, index, options)));
     return UrlSourceSet.parse({ sources });
 }
+/** v6 T10: a URL the user attached is presumptively decision-relevant — if it cannot be read, the
+ *  run must stop BEFORE any paid call and ask, instead of spending the full council budget on a
+ *  conditional verdict (run f740 burned 12 calls around a 403'd hackathon page). Returns the stop
+ *  message, or null to proceed. Quick mode and an explicit override proceed as before. */
+export function blockedSourceStop(sources, mode, allowBlockedSources) {
+    if (mode === 'quick' || allowBlockedSources)
+        return null;
+    const unreadable = sources.sources.filter((source) => source.status !== 'FETCHED');
+    if (unreadable.length === 0)
+        return null;
+    const details = unreadable.map((source) => `${source.url} (${source.status}${source.error ? `: ${source.error}` : ''})`).join('; ');
+    return `a source you attached could not be read — ${details}. The council would have to decide without the fact you attached it for. `
+        + 'Paste the relevant text into your idea input and rerun, or rerun with --allow-blocked-sources to proceed without it (the report will be conditional).';
+}

package/dist/providers/adapter-core.js

@@ -118,7 +118,7 @@ export async function runAdapter(spec, req, flags, deps = {}) {
                 return { ok: false, error: 'BAD_OUTPUT', stderrTail: raw.stderr, durationMs: raw.durationMs };
             }
         }
-        return { ok: true, text, json, durationMs: raw.durationMs, providerMeta: spec.meta?.(raw.stdout) };
+        return { ok: true, text, json, durationMs: raw.durationMs, providerMeta: spec.meta?.(raw.stdout), usage: spec.usage?.(raw.stdout, raw.stderr) };
     };
     const first = await attempt();
     if (first.ok)

package/dist/providers/claude.js

@@ -1,4 +1,8 @@
 import { runAdapter } from './adapter-core.js';
+/** Only accept a finite non-negative number; anything else → undefined (field omitted). */
+function num(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
+}
 function envelope(stdout) {
     try {
         const v = JSON.parse(stdout);
@@ -49,6 +53,20 @@ const claudeSpec = {
             usage: env.usage,
         };
     },
+    usage(stdout) {
+        const env = envelope(stdout);
+        if (!env)
+            return undefined;
+        const u = (env.usage ?? {});
+        return {
+            inputTokens: num(u.input_tokens),
+            outputTokens: num(u.output_tokens),
+            cacheReadTokens: num(u.cache_read_input_tokens),
+            cacheWriteTokens: num(u.cache_creation_input_tokens),
+            estimated: false,
+            reportedCostUsd: num(env.total_cost_usd),
+        };
+    },
 };
 export const claude = {
     id: 'claude',