aiki-cli 0.3.1 → 0.3.2

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

@@ -1,5 +1,23 @@
 // S6 — preserve validated analyst submissions for graph compilation. No lexical merging: positions
 // keep their original text and are grouped only by stable references in S7.
+/** A surviving scout seat with little output or evidence is weak. ponytail: thresholds are blunt on
+ * purpose; raise them only with benchmark evidence. */
+export function detectWeakSeat(positions, mode) {
+    if (mode === 'quick')
+        return [];
+    const seats = new Map();
+    for (const position of positions) {
+        const provider = position.id.split('/')[0].replace(/-coverage-fill$/, '');
+        const seat = seats.get(provider) ?? { positions: 0, evidenced: 0 };
+        seat.positions += 1;
+        if (position.evidence_ids?.length)
+            seat.evidenced += 1;
+        seats.set(provider, seat);
+    }
+    if (seats.size < 2)
+        return [];
+    return [...seats].filter(([, seat]) => seat.positions < 3 || seat.evidenced / seat.positions < 0.5).map(([provider]) => provider);
+}
 export function collectPositions(seats) {
     return seats.map((seat) => ({ provider: seat.provider, source_id: seat.sample ?? seat.provider, submission: seat.output }));
 }

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

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

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

@@ -4,6 +4,7 @@ import { selectEscalations } from '../decision-graph.js';
 import { ClaimVerificationSet } from '../../schemas/index.js';
 import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
+import { loadSkill } from '../skills.js';
 const S8_PROMPT = `ROLE: Independent verifier. Check each anonymous decision claim below against the
 provided evidence cards and deterministic calculation checks. Output ONLY JSON:
 {"verifications": [{"claim_id": "<G-id>", "status": "VERIFIED|PARTIAL|CONTRADICTED|UNVERIFIABLE",
@@ -12,8 +13,21 @@ provided evidence cards and deterministic calculation checks. Output ONLY JSON:
 VERIFIED = the proposition is supported. CONTRADICTED = it is refuted. PARTIAL = evidence is mixed or
 incomplete. UNVERIFIABLE = the supplied sources cannot decide. Cite only supplied evidence IDs. Model
 knowledge cannot verify a current, numeric, legal, medical, financial, market, or regulatory fact.
-Judge each item independently; no verdict quota. JSON only.
+Judge each item independently; no verdict quota. JSON only.{{SKILL}}
 ITEMS: {{ITEMS_JSON}}`;
+export function selectVerificationTargets(claims, max) {
+    return claims
+        .map((claim, index) => ({ claim, index }))
+        .sort((left, right) => Number(right.claim.nature === 'FACTUAL') - Number(left.claim.nature === 'FACTUAL') || left.index - right.index)
+        .slice(0, max)
+        .map(({ claim }) => claim);
+}
+export function selectVerificationEscalations(graph, max = 8) {
+    const candidates = selectEscalations(graph, { max: graph.claims.length });
+    const byId = new Map(candidates.map((candidate) => [candidate.claim_id, candidate]));
+    const claims = candidates.map((candidate) => graph.claims.find((claim) => claim.id === candidate.claim_id));
+    return selectVerificationTargets(claims, max).map((claim) => byId.get(claim.id));
+}
 function evidenceIdsForClaim(graph, claimId) {
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
     const claim = graph.claims.find((item) => item.id === claimId);
@@ -25,12 +39,12 @@ function evidenceIdsForClaim(graph, claimId) {
         .flatMap((calculation) => calculation.inputs.flatMap((input) => input.evidence_ids));
     return new Set([...positionEvidence, ...calculationEvidence]);
 }
-function verifierInput(graph) {
+function verifierInput(graph, skill = '') {
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
     const evidenceRefs = new Map(graph.evidence.map((evidence, index) => [`E${index + 1}`, evidence.id]));
     const aliasByEvidence = new Map([...evidenceRefs].map(([alias, id]) => [id, alias]));
     const evidenceById = new Map(graph.evidence.map((evidence) => [evidence.id, evidence]));
-    const items = selectEscalations(graph, { max: 8 }).map((escalation) => {
+    const items = selectVerificationEscalations(graph).map((escalation) => {
         const claim = graph.claims.find((item) => item.id === escalation.claim_id);
         const linkedEvidenceIds = evidenceIdsForClaim(graph, claim.id);
         return {
@@ -64,13 +78,16 @@ function verifierInput(graph) {
             evidence_hole: graph.holes.evidence.find((hole) => hole.claim_id === claim.id)?.reason,
         };
     });
-    return { prompt: S8_PROMPT.replace('{{ITEMS_JSON}}', JSON.stringify(items, null, 2)), evidenceRefs };
+    const prompt = S8_PROMPT
+        .replace('{{SKILL}}', skill ? `\n\n${skill}` : '')
+        .replace('{{ITEMS_JSON}}', JSON.stringify(items, null, 2));
+    return { prompt, evidenceRefs };
 }
-export function buildVerifierPrompt(graph) {
-    return verifierInput(graph).prompt;
+export function buildVerifierPrompt(graph, skill = '') {
+    return verifierInput(graph, skill).prompt;
 }
 /** Validate every S8 claim/evidence reference before the chair can see it. */
-export function claimVerificationRefIssues(graph, verifications, expectedIds = selectEscalations(graph, { max: 8 }).map((item) => item.claim_id)) {
+export function claimVerificationRefIssues(graph, verifications, expectedIds = selectVerificationEscalations(graph).map((item) => item.claim_id)) {
     const expected = new Set(expectedIds);
     const evidence = new Map(graph.evidence.map((item) => [item.id, item]));
     const seen = new Set();
@@ -111,7 +128,7 @@ export function claimVerificationRefIssues(graph, verifications, expectedIds = s
     return issues;
 }
 export async function s8Verify(ctx, graph) {
-    const escalations = selectEscalations(graph, { max: 8 });
+    const escalations = selectVerificationEscalations(graph);
     if (escalations.length === 0) {
         const empty = { verifications: [] };
         await ctx.writer.writeJson('verifications', empty);
@@ -138,7 +155,7 @@ export async function s8Verify(ctx, graph) {
         return skipped;
     }
     try {
-        const input = verifierInput(graph);
+        const input = verifierInput(graph, loadSkill('idea-refinement', 'verifier'));
         // Optional work gets no model repair: one logical optional call must remain one call.
         const result = await jsonCall(ctx, ctx.handle(ctx.roles.verifier), 'S8', input.prompt, ClaimVerificationSet, { repair: false });
         const translated = {

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

@@ -5,6 +5,7 @@ import { selectRebuttalEscalations, } from '../decision-graph.js';
 import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
 import { IDEA_MODE_PLANS } from '../modes.js';
+import { loadSkill } from '../skills.js';
 /** Internal protocol caps only. R6 owns exposing modes and changing the surrounding topology. */
 export const REBUTTAL_LIMITS = {
     quick: { maxNodes: 0, optionalCalls: 0 },
@@ -22,7 +23,7 @@ Output ONLY JSON:
 CONCEDE = your position changes. COUNTER = retain it using a cited supplied card or a precise logical
 rebuttal. NARROW = state the smaller proposition actually supported. UNRESOLVED = evidence cannot decide.
 Return exactly one event per assigned claim. Cite only evidence IDs shown for that claim. Do not invent
-sources, URLs, claim IDs, or evidence IDs. JSON only.
+sources, URLs, claim IDs, or evidence IDs. JSON only.{{SKILL}}
 NODES: {{NODES_JSON}}`;
 function claimAuthors(graph, claimId) {
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
@@ -70,7 +71,7 @@ export function planRebuttalCalls(graph, escalations, scouts, judge) {
         return claim_ids?.length ? [{ provider, claim_ids }] : [];
     });
 }
-function rebuttalInput(graph, verifications, escalationById, assignment) {
+function rebuttalInput(graph, verifications, escalationById, assignment, skill = '') {
     const claimIds = new Set(assignment.claim_ids);
     const positionRefs = new Map();
     const evidenceRefs = new Map();
@@ -130,11 +131,16 @@ function rebuttalInput(graph, verifications, escalationById, assignment) {
         };
     });
     return {
-        prompt: REBUTTAL_PROMPT.replace('{{NODES_JSON}}', JSON.stringify(nodes, null, 2)),
+        prompt: buildRebuttalPrompt(nodes, skill),
         evidenceRefs,
         allowedEvidence,
     };
 }
+export function buildRebuttalPrompt(nodes, skill = '') {
+    return REBUTTAL_PROMPT
+        .replace('{{SKILL}}', skill ? `\n\n${skill}` : '')
+        .replace('{{NODES_JSON}}', JSON.stringify(nodes, null, 2));
+}
 function translateEvents(graph, assignment, input, output, startIndex) {
     const expected = new Set(assignment.claim_ids);
     const seen = new Set();
@@ -189,8 +195,9 @@ export async function s8bRebuttal(ctx, graph, verifications, mode = ctx.mode) {
     const assignments = planned.slice(0, optionalCalls);
     const escalationById = new Map(escalations.map((item) => [item.claim_id, item]));
     const events = [];
+    const skill = loadSkill('idea-refinement', 'rebuttal');
     for (const assignment of assignments) {
-        const input = rebuttalInput(graph, verifications, escalationById, assignment);
+        const input = rebuttalInput(graph, verifications, escalationById, assignment, skill);
         try {
             const output = await jsonCall(ctx, ctx.handle(assignment.provider), `S8b-${assignment.provider}`, input.prompt, RebuttalResponseSet, { repair: false });
             events.push(...translateEvents(graph, assignment, input, output, events.length));

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

@@ -1,10 +1,11 @@
 // 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 { claimVerificationRefIssues } from './s8-verify.js';
+import { claimShortLabel } from '../decision-dossier.js';
+import { loadSkill } from '../skills.js';
+import { claimVerificationRefIssues, selectVerificationEscalations } from './s8-verify.js';
 const EMPTY_REBUTTALS = {
     round: 1,
     selected_claim_ids: [],
@@ -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}}`;
@@ -173,19 +174,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 +216,7 @@ 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);
+    const selectedIds = selectVerificationEscalations(graph).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 +256,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 +265,13 @@ 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);
+    const selectedIds = selectVerificationEscalations(graph).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 +314,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,