aiki-cli 0.3.1 → 0.3.3

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

@@ -1,19 +1,40 @@
 // 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';
+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",
   "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.
-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 }))
+        .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,14 +46,18 @@ function evidenceIdsForClaim(graph, claimId) {
         .flatMap((calculation) => calculation.inputs.flatMap((input) => input.evidence_ids));
     return new Set([...positionEvidence, ...calculationEvidence]);
 }
-function verifierInput(graph) {
+/** 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 = selectEscalations(graph, { max: 8 }).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,
@@ -64,20 +89,47 @@ 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 };
+    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(packets, null, 2))
+        .replace('{{CLAIMS_JSON}}', JSON.stringify(claimsIndex, 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 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);
@@ -111,7 +163,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,14 +190,16 @@ 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 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/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));

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

@@ -1,9 +1,10 @@
 // S9 — chair adjudication over graph-selected escalations. Consensus and shared concerns are
 // read-only context; anonymous position text and the verifier record cross the boundary unchanged.
-import { selectEscalations } from '../decision-graph.js';
 import { IdeaChairReportModel } from '../../schemas/index.js';
 import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
+import { claimShortLabel } from '../decision-dossier.js';
+import { loadSkill } from '../skills.js';
 import { claimVerificationRefIssues } from './s8-verify.js';
 const EMPTY_REBUTTALS = {
     round: 1,
@@ -39,7 +40,7 @@ Output ONLY JSON matching the judge schema:
 - key_points: 4-8 standalone decision-relevant bullets.
 - dissent: a JSON array of strings (an array even when there is only one) — the strongest arguments
   against your verdict.
-- confidence_notes: explain calibrated confidence.
+- confidence_notes: explain calibrated confidence.{{SKILL}}
 ESCALATED CLAIMS + VERIFICATION: {{ESCALATIONS_JSON}}
 APPEND-ONLY REBUTTAL EVENTS: {{REBUTTALS_JSON}}
 SETTLED/UNRESOLVED CONTEXT: {{CONTEXT_JSON}}`;
@@ -147,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`] : []),
         ];
     });
 }
@@ -173,19 +178,40 @@ export function adjudicableClaimIds(graph, ids, judgeProvider) {
     return [...ids].filter((id) => !claimById.get(id)?.position_ids
         .some((positionId) => positionById.get(positionId)?.provider === judgeProvider));
 }
+/** One condition per distinct claim behind an evidence hole, claim-labeled instead of a generic
+ *  placeholder reason. Deduped by claim_id and capped at 4 so the fallback conditions list doesn't
+ *  drown in near-identical entries. */
+export function evidenceHoleConditions(graph) {
+    const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
+    const seen = new Set();
+    const out = [];
+    for (const hole of graph.holes.evidence) {
+        if (seen.has(hole.claim_id))
+            continue;
+        seen.add(hole.claim_id);
+        const claim = claimById.get(hole.claim_id);
+        out.push(`Obtain independent evidence for: "${claimShortLabel(claim?.proposition ?? 'a load-bearing claim')}".`);
+        if (out.length === 4)
+            break;
+    }
+    return out;
+}
 function fallbackConditions(graph, adjudications) {
     const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
     const upheld = adjudications
         .filter((item) => item.ruling === 'UPHOLD')
         .map((item) => `Proceed only if you can resolve: ${claimById.get(item.id)?.proposition ?? item.id}.`);
     const holes = graph.holes.coverage.map((hole) => `Proceed only after examining the ${hole.label} gap.`);
-    const evidenceHoles = graph.holes.evidence.map((hole) => `Proceed only after resolving evidence gap ${hole.claim_id}: ${hole.reason}.`);
+    const evidenceHoles = evidenceHoleConditions(graph);
     return [...upheld, ...holes, ...evidenceHoles, 'Proceed only after one cheap test confirms the core user need.'].slice(0, 6);
 }
-export function buildJudgePrompt(contract, graph, verifications, rubric, rebuttals = EMPTY_REBUTTALS, judgeProvider) {
-    return judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProvider).prompt;
+export function buildJudgePrompt(contract, graph, verifications, rubric, rebuttals = EMPTY_REBUTTALS, judgeProvider, skill = '') {
+    return judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProvider, skill).prompt;
+}
+export function buildChairRepairPrompt(basePrompt, corrections) {
+    return `${basePrompt}\n\n---\nCorrect these problems:\n${corrections}Output ONLY corrected JSON.`;
 }
-function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProvider) {
+function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProvider, skill = '') {
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
     const verificationById = new Map(verifications.verifications.map((item) => [item.claim_id, item]));
     const citedEvidence = [...new Set([
@@ -194,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 = selectEscalations(graph, { max: 8 }).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) => {
@@ -234,6 +263,7 @@ function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProv
         ...(event.narrowed_proposition ? { narrowed_proposition: event.narrowed_proposition } : {}),
     }));
     const prompt = S9_PROMPT
+        .replace('{{SKILL}}', skill ? `\n\n${skill}` : '')
         .replace('{{RUBRIC_JSON}}', JSON.stringify(rubric.map((item) => item.label)))
         .replace('{{ESCALATIONS_JSON}}', JSON.stringify(escalations, null, 2))
         .replace('{{REBUTTALS_JSON}}', JSON.stringify(rebuttalContext, null, 2))
@@ -242,13 +272,21 @@ 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 = selectEscalations(graph, { max: 8 }).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('; ')}`);
     const ids = adjudicableClaimIds(graph, selectedIds, ctx.roles.judge);
     const selfAuthored = new Set(selectedIds.filter((id) => !ids.includes(id)));
-    const input = judgeInput(contract, graph, verifications, rubric, rebuttals, ctx.roles.judge);
+    const input = judgeInput(contract, graph, verifications, rubric, rebuttals, ctx.roles.judge, loadSkill('idea-refinement', 'chair'));
     const basePrompt = input.prompt;
     const judge = ctx.handle(ctx.roles.judge);
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
@@ -291,13 +329,13 @@ export async function s9Judge(ctx, contract, graph, verifications, rubric, rebut
     ];
     if ((violations.length || evidenceViolations.length || report.dissent.length === 0 || recIssues.length || chairIssues.length)
         && ctx.budget.limit - ctx.budget.used > 1) {
-        const repair = `${basePrompt}\n\n---\nCorrect these problems:\n`
+        const corrections = ''
             + (violations.length ? `- adjudications may reference only [${ids.join(', ')}], not ${violations.join(', ')}\n` : '')
             + (evidenceViolations.length ? `- evidence reference errors: ${evidenceViolations.join('; ')}\n` : '')
             + (report.dissent.length === 0 ? '- dissent must contain at least one item\n' : '')
             + (recIssues.length ? `- ${recIssues.join('; ')}\n` : '')
-            + (chairIssues.length ? `- chair contract errors: ${chairIssues.join('; ')}\n` : '')
-            + 'Output ONLY corrected JSON.';
+            + (chairIssues.length ? `- chair contract errors: ${chairIssues.join('; ')}\n` : '');
+        const repair = buildChairRepairPrompt(basePrompt, corrections);
         try {
             report = translateChairReport(await jsonCall(ctx, judge, 'S9-repair', repair, IdeaChairReportModel, {
                 repair: ctx.budget.limit - ctx.budget.used > 2,