aiki-cli 0.2.0

package/dist/orchestration/stages/cr-ladder.js

@@ -0,0 +1,63 @@
+// V4 escalation ladder — deterministic coverage-hole detection (pure). See BENCHMARK.md amendment L1.
+//
+// The ladder hunts cheap first (agy + codex, = Arm E's tier 1) and escalates a Claude call ONLY when it
+// is likely to matter: (a) a disputed finding → the Claude judge (Arm E already does this); (b) a COVERAGE
+// HOLE → one targeted Claude review over the risky hunks. This file owns (b)'s trigger: a pure function
+// over the diff + tier-1 findings, so it's fully unit-tested without any model call. RISK_DEFS are FROZEN
+// by the L1 pre-registration — do not tune them without a new amendment.
+import { parseDiffFiles } from '../git.js';
+/** FROZEN for L1 (BENCHMARK.md amendment L1): risk classes + their globs / keywords / covering categories. */
+export const RISK_DEFS = [
+    {
+        id: 'auth',
+        label: 'auth / access control',
+        categories: ['SECURITY'],
+        fileRe: /(auth|login|session|token|permission|acl|oauth|jwt|guard|middleware)/i,
+        keywordRe: /\b(authenticate|authoriz|password|jwt|bcrypt|session|cookie|csrf|isadmin|req\.user|\.role\b|permission)\b/i,
+    },
+    {
+        id: 'crypto',
+        label: 'cryptography',
+        categories: ['SECURITY'],
+        fileRe: /(crypto|encrypt|cipher|hash|sign)/i,
+        keywordRe: /\b(encrypt|decrypt|createhash|randombytes|createcipher|hmac|nonce|\biv\b|math\.random)\b/i,
+    },
+    {
+        id: 'payment',
+        label: 'payments / money',
+        categories: ['CORRECTNESS', 'SECURITY'],
+        fileRe: /(payment|billing|charge|invoice|checkout|stripe|order|price)/i,
+        keywordRe: /\b(charge|refund|amount|currency|\bprice\b|subtotal|\btotal\b|discount|\btax\b|balance)\b/i,
+    },
+    {
+        id: 'async',
+        label: 'async / concurrency',
+        categories: ['CONCURRENCY'],
+        fileRe: /(worker|queue|scheduler|\bjob\b|concurrent)/i,
+        keywordRe: /\b(async|await|promise\.all|promise\.race|settimeout|setinterval|mutex|\block\b|concurrent|parallel)\b/i,
+    },
+];
+/**
+ * A risk the diff touches (by file glob or added-line keyword) that tier-1 flagged NOTHING of the right
+ * category inside → escalate a targeted hunt. Deterministic + pure (BENCHMARK.md L1 §"Coverage hole").
+ */
+export function detectCoverageHoles(diff, findings) {
+    const files = parseDiffFiles(diff);
+    const added = diff
+        .split('\n')
+        .filter((l) => l.startsWith('+') && !l.startsWith('+++'))
+        .join('\n');
+    const holes = [];
+    for (const r of RISK_DEFS) {
+        const riskFiles = files.filter((f) => r.fileRe.test(f));
+        const triggered = riskFiles.length > 0 || r.keywordRe.test(added);
+        if (!triggered)
+            continue;
+        // Scope = the risk-glob files if any, else the whole diff (keyword-only trigger).
+        const scope = riskFiles.length ? riskFiles : files;
+        const covered = findings.some((f) => r.categories.includes(f.category) && scope.includes(f.file));
+        if (!covered)
+            holes.push({ risk: r.id, label: r.label, categories: r.categories, files: scope });
+    }
+    return holes;
+}

package/dist/orchestration/stages/cr-map.js

@@ -0,0 +1,62 @@
+// code-review disagreement map (§12.2, T10) — the deterministic analog of idea's S6/S7. Pure.
+//
+// Two consensus paths (grilled 2026-07-04):
+//   1. §487 matcher — both reviewers INDEPENDENTLY flagged the same defect (same file + overlapping
+//      lines + same category). Line-anchored, so tractable where idea's prose consensus wasn't.
+//   2. cross-exam CONFIRM — the other reviewer agreed a single-authored finding is a genuine defect.
+// A cross-exam REFUTE → disputed (adjudicated by S9). UNCERTAIN / unexamined → single-reviewer.
+// Findings are reindexed to stable global ids (G1..) because per-reviewer ids ("F1") collide.
+const SEV_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
+/** §487 matcher (BENCHMARK.md §3): same defect iff same file, overlapping lines, same category. Also
+ *  the seeded-bug scorer's match (T11) — a seeded bug is just a `FindingLoc`. */
+export function sameFinding(a, b) {
+    return a.file === b.file && a.category === b.category && a.line_start <= b.line_end && b.line_start <= a.line_end;
+}
+export function buildReviewMap(reviewers, cross) {
+    const consensus = [];
+    const disputed = [];
+    const single = [];
+    const [a, b] = reviewers;
+    const mergedA = new Set();
+    const mergedB = new Set();
+    // Path 1 — §487 independent-consensus merge.
+    if (a && b) {
+        for (const fa of a.findings) {
+            const match = b.findings.find((fb) => !mergedB.has(fb) && sameFinding(fa, fb));
+            if (!match)
+                continue;
+            mergedA.add(fa);
+            mergedB.add(match);
+            const rep = SEV_RANK[match.severity] < SEV_RANK[fa.severity] ? match : fa; // keep the higher-severity representative
+            consensus.push({ finding: rep, reviewers: [a.provider, b.provider], cross_verdict: 'NONE' });
+        }
+    }
+    // Path 2 — single-authored findings, classified by the OTHER reviewer's cross-exam verdict.
+    const classify = (author, skip) => {
+        for (const f of author.findings) {
+            if (skip.has(f))
+                continue;
+            const cv = cross.get(`${author.provider}/${f.id}`);
+            const anno = { finding: f, reviewers: [author.provider], cross_verdict: cv?.verdict ?? 'NONE' };
+            if (cv?.verdict === 'CONFIRM')
+                consensus.push(anno);
+            else if (cv?.verdict === 'REFUTE')
+                disputed.push({ ...anno, refutation: cv.note || cv.evidence });
+            else
+                single.push(anno); // UNCERTAIN or never examined
+        }
+    };
+    if (a)
+        classify(a, mergedA);
+    if (b)
+        classify(b, mergedB);
+    // Reindex to stable, unique global ids so S9 can reference disputed items and S10 can match them.
+    let n = 0;
+    const reindex = (arr) => arr.map((af) => ({ ...af, finding: { ...af.finding, id: `G${++n}` } }));
+    return {
+        consensus: reindex(consensus),
+        disputed: reindex(disputed),
+        single_reviewer: reindex(single),
+        per_reviewer: reviewers.map((r) => ({ provider: r.provider, raised: r.raised, kept: r.findings.length, dropped: r.dropped.length })),
+    };
+}

package/dist/orchestration/stages/cr-report.js

@@ -0,0 +1,83 @@
+// code-review S10 — report rendering (§12.2, T10). Pure → final-report.md, a decision brief for the
+// reviewer: verdict → findings table (P0/P1 first) → disagreement map → per-reviewer stats → raw links.
+//
+// Confidence + false-positive exclusion are DERIVED here (one source of truth, §624), NOT taken from the
+// judge: consensus→HIGH, single-reviewer→MEDIUM, disputed+UPHOLD/UNRESOLVED→LOW (kept),
+// disputed+REJECT→false positive (excluded from the findings table, listed under Rejected).
+import { DISPLAY_NAME } from '../../providers/types.js';
+const SEV_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
+const disp = (id) => DISPLAY_NAME[id];
+const attrib = (ps) => ps.map(disp).join(' + ');
+/** Pure: assign each finding its derived confidence + disposition from the map + judge rulings. */
+export function scoreFindings(map, judge) {
+    const ruling = new Map(judge.adjudications.map((a) => [a.id, a.ruling]));
+    const out = [];
+    for (const af of map.consensus)
+        out.push({ finding: af.finding, reviewers: af.reviewers, confidence: 'HIGH', disposition: 'kept' });
+    for (const af of map.single_reviewer)
+        out.push({ finding: af.finding, reviewers: af.reviewers, confidence: 'MEDIUM', disposition: 'kept' });
+    for (const af of map.disputed) {
+        const r = ruling.get(af.finding.id) ?? 'UNRESOLVED';
+        out.push({ finding: af.finding, reviewers: af.reviewers, confidence: 'LOW', disposition: r === 'REJECT' ? 'rejected' : 'kept', ruling: r });
+    }
+    return out;
+}
+const bySeverity = (a, b) => SEV_RANK[a.finding.severity] - SEV_RANK[b.finding.severity];
+export function renderReviewReport(ctx, map, judge) {
+    const scored = scoreFindings(map, judge);
+    const kept = scored.filter((s) => s.disposition === 'kept').sort(bySeverity);
+    const rejected = scored.filter((s) => s.disposition === 'rejected');
+    const flags = [...ctx.flags];
+    const L = [];
+    L.push(`# Code Review — ${ctx.runId}`, '');
+    L.push(`- Reviewers: ${map.per_reviewer.map((r) => disp(r.provider)).join(', ')}  ·  Judge: ${disp(ctx.roles.judge)}  ·  calls: ${ctx.calls.length}/${ctx.budget.limit}`);
+    if (flags.length)
+        L.push(`- ⚠ Flags: ${flags.join(', ')}`);
+    L.push('');
+    L.push('## Verdict', '', judge.verdict, '');
+    const p0p1 = kept.filter((s) => s.finding.severity === 'P0' || s.finding.severity === 'P1');
+    L.push(`## Findings (${kept.length} kept${p0p1.length ? `, ${p0p1.length} P0/P1` : ''})`, '');
+    if (kept.length) {
+        L.push('| Sev | Location | Conf | Category | Finding | Reviewers |', '|---|---|---|---|---|---|');
+        for (const s of kept) {
+            const f = s.finding;
+            L.push(`| ${f.severity} | ${f.file}:${f.line_start}-${f.line_end} | ${s.confidence} | ${f.category} | ${f.claim} | ${attrib(s.reviewers)} |`);
+        }
+    }
+    else {
+        L.push('_No defects held after review._');
+    }
+    L.push('');
+    L.push('## Disagreement map', '');
+    L.push(`**Consensus (both reviewers or cross-confirmed):** ${map.consensus.length}`);
+    L.push(`**Single-reviewer:** ${map.single_reviewer.length}`);
+    L.push(`**Disputed → adjudicated:** ${map.disputed.length}`);
+    for (const d of map.disputed) {
+        const r = judge.adjudications.find((a) => a.id === d.finding.id);
+        L.push(`- **${d.finding.id}** ${d.finding.file}:${d.finding.line_start}-${d.finding.line_end}${r ? ` → ${r.ruling}` : ''}: ${d.finding.claim}`);
+        if (d.refutation)
+            L.push(`  - refutation: ${d.refutation}`);
+        if (r)
+            L.push(`  - judge: ${r.reasoning}`);
+    }
+    L.push('');
+    if (rejected.length) {
+        L.push(`## Rejected (adjudicated false positives): ${rejected.length}`, '');
+        for (const s of rejected)
+            L.push(`- ${s.finding.file}:${s.finding.line_start}-${s.finding.line_end} — ${s.finding.claim}`);
+        L.push('');
+    }
+    L.push('## Per-reviewer stats', '', '| Reviewer | Raised | Kept (valid) | Dropped (bad file:line) |', '|---|---|---|---|');
+    for (const r of map.per_reviewer)
+        L.push(`| ${disp(r.provider)} | ${r.raised} | ${r.kept} | ${r.dropped} |`);
+    L.push('');
+    L.push('## Dissent', '');
+    for (const d of judge.dissent)
+        L.push(`- ${d}`);
+    L.push('', `_Confidence: ${judge.confidence_notes}_`, '');
+    L.push('## Raw artifacts', '', '- reviewer findings: `04-role-outputs/`', '- cross-exam: `08-verifications.json`', '- disagreement map: `07-review-map.json`', '- judge report: `09-judge-report.json`', '- diff: `inputs/diff.patch`', '');
+    return L.join('\n');
+}
+export async function s10ReviewRender(ctx, map, judge) {
+    await ctx.writer.writeText('final-report', renderReviewReport(ctx, map, judge));
+}

package/dist/orchestration/stages/cr-s4-review.js

@@ -0,0 +1,69 @@
+// code-review S4 — parallel blind review (§12.2, T10). Each reviewer (claude + codex) independently
+// reviews the diff at repo-root cwd and returns findings. Immediately after, a DETERMINISTIC file:line
+// validator (§605) drops any finding whose file isn't in the diff / present at HEAD, or whose line
+// range is out of bounds — BEFORE the cross-exam sees it. Dropping is per-finding (keep the valid ones,
+// §grill 2026-07-04); a reviewer ending with 0 valid findings is legal, not a failure.
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CodeReviewRoleOutputModel } from '../../schemas/index.js';
+import { isFatal, StageError } from '../context.js';
+import { jsonCall } from '../jsonStage.js';
+/**
+ * Pure file:line validator (§12.2/§605). A finding is valid iff its file appears in the diff AND is
+ * present at HEAD (has a line count) AND 1 ≤ line_start ≤ line_end ≤ lineCount.
+ */
+export function filterValidFindings(findings, diffFiles, lineCounts) {
+    const valid = [];
+    const dropped = [];
+    for (const f of findings) {
+        const lc = lineCounts.get(f.file);
+        const ok = diffFiles.has(f.file) && lc !== undefined && f.line_start >= 1 && f.line_end >= f.line_start && f.line_end <= lc;
+        (ok ? valid : dropped).push(f);
+    }
+    return { valid, dropped };
+}
+/** Line count per file at HEAD (reads the repo tree). A missing/unreadable file is simply absent. */
+export async function countLines(repoRoot, files) {
+    const out = new Map();
+    await Promise.all(files.map(async (f) => {
+        try {
+            out.set(f, (await readFile(join(repoRoot, f), 'utf8')).split('\n').length);
+        }
+        catch {
+            /* file not at HEAD (e.g. deleted) → left out → findings on it are rejected */
+        }
+    }));
+    return out;
+}
+async function reviewOne(ctx, seat, prompt, diffSet, lineCounts) {
+    const model = await jsonCall(ctx, ctx.handle(seat), `S4-${seat}`, prompt, CodeReviewRoleOutputModel);
+    // Persist the RAW reviewer output (all findings) for forensics; downstream uses only the valid set.
+    await ctx.writer.writeRoleOutput(seat, { workflow: 'code-review', ...model });
+    const { valid, dropped } = filterValidFindings(model.findings, diffSet, lineCounts);
+    return { provider: seat, findings: valid, dropped, raised: model.findings.length };
+}
+export async function s4Review(ctx, prompt, diffFiles) {
+    const seats = ctx.roles.s4;
+    const lineCounts = await countLines(ctx.cwd, diffFiles); // ctx.cwd = repo root for code-review
+    const diffSet = new Set(diffFiles);
+    const settled = await Promise.allSettled(seats.map((seat) => reviewOne(ctx, seat, prompt, diffSet, lineCounts)));
+    const survivors = [];
+    const dropped = [];
+    for (let i = 0; i < settled.length; i++) {
+        const r = settled[i];
+        if (r.status === 'fulfilled')
+            survivors.push(r.value);
+        else if (isFatal(r.reason))
+            throw r.reason; // budget/deadline/abort → abort the run
+        else
+            dropped.push(`${seats[i]}:${r.reason instanceof Error ? r.reason.message : String(r.reason)}`);
+    }
+    if (survivors.length === 0) {
+        throw new StageError('S4', 'QUORUM', `no reviewers survived (dropped: ${dropped.join('; ')})`);
+    }
+    // Exactly one reviewer → no cross-exam is possible (nothing to examine against). The run still
+    // produces single-reviewer findings; flag the reduced diversity (§8).
+    if (survivors.length < 2)
+        ctx.addFlag('low_diversity');
+    return survivors;
+}

package/dist/orchestration/stages/cr-s8-crossexam.js

@@ -0,0 +1,104 @@
+// code-review S8 — mutual cross-exam (§12.2, T10; teeth added V1). Each reviewer receives the OTHER
+// reviewer's findings ANONYMIZED ("the other reviewer") and rules CONFIRM / REFUTE / UNCERTAIN per
+// finding, with its own evidence. The prompt forces an adversarial pass: rank weakest-first, actively
+// try to refute the weakest with file:line evidence, REFUTE only with evidence else UNCERTAIN. A
+// rubber stamp (all CONFIRM, no weakest-first justification) triggers ONE sharper re-ask (mirrors S9);
+// if it still rubber-stamps, raise synthesis_suspect. Two exams (skip a side whose target has 0
+// findings, §grill). Verdict is finding-centric: CONFIRM = genuine defect, REFUTE = false positive.
+import { VerificationSet } from '../../schemas/index.js';
+import { isFatal } from '../context.js';
+import { jsonCall } from '../jsonStage.js';
+const S8_PROMPT = `ROLE: Senior code reviewer performing a peer cross-examination. Below are findings from
+ANOTHER reviewer (source withheld). Your job is to CHALLENGE them, not rubber-stamp them.
+
+Do ALL of the following, in order:
+1. Rank the findings from WEAKEST (most likely a false positive) to strongest.
+2. Take the weakest finding — and any other you doubt — and actively try to REFUTE it: open the
+   referenced file:lines yourself and look for a concrete reason the reported defect is NOT real
+   (guarded upstream, unreachable path, misread line, wrong category, already-correct code).
+3. Decide each verdict:
+   - REFUTE only when you have concrete file:line evidence it is a false positive.
+   - If you doubt a finding but cannot prove it false, use UNCERTAIN and state the specific doubt.
+   - CONFIRM only a finding you genuinely could not weaken.
+
+Output ONLY JSON:
+{"verifications": [{"target_id": "<finding id>", "verdict": "CONFIRM|REFUTE|UNCERTAIN",
+  "evidence": "<your own file:line reasoning>", "note": "<≤2 sentences>"}]}
+CONFIRM = a real defect worth reporting. REFUTE = a false positive / not a genuine issue. UNCERTAIN =
+cannot determine. If — and ONLY if — every finding survives your attack and you CONFIRM them all, you
+MUST set "all_confirmed_justification" naming the single weakest finding and the file:line reason it
+still holds. JSON only, no prose outside it.
+FINDINGS TO EXAMINE: {{FINDINGS_JSON}}`;
+/** Anonymized view of a reviewer's findings for the examiner (no provider attribution, no self_confidence). */
+function anonymize(author) {
+    return author.findings.map((f) => ({ id: f.id, file: f.file, line_start: f.line_start, line_end: f.line_end, severity: f.severity, category: f.category, claim: f.claim, evidence: f.evidence }));
+}
+async function callExam(ctx, examiner, label, prompt) {
+    try {
+        // Examiner runs at repo-root cwd (default) so it can investigate the code; it's a verified read-only reviewer.
+        return await jsonCall(ctx, ctx.handle(examiner), label, prompt, VerificationSet);
+    }
+    catch (e) {
+        if (isFatal(e))
+            throw e; // budget/deadline/abort → abort the run
+        return null; // examiner down / bad output → treat as "no cross-exam" (findings stay single-reviewer)
+    }
+}
+/** Rubber stamp = confirmed everything without the mandatory weakest-first justification. The teeth we
+ *  want are a REFUTE/UNCERTAIN (a genuine pushback) OR, if all really do hold, the justification. */
+function isRubberStamp(graded, vset) {
+    return graded.length > 0 && graded.every((v) => v.verdict === 'CONFIRM') && !vset.all_confirmed_justification;
+}
+/** One cross-exam: initial call, then — on a rubber stamp — one sharper re-ask (mirrors S9's retry).
+ *  Returns the accepted verification set (the pushed-back re-ask if it improved, else the original) and
+ *  whether it is STILL a rubber stamp so the caller can flag `synthesis_suspect`. */
+async function examine(ctx, examiner, author) {
+    const prompt = S8_PROMPT.replace('{{FINDINGS_JSON}}', JSON.stringify(anonymize(author), null, 2));
+    const vset = await callExam(ctx, examiner, `S8-${examiner}`, prompt);
+    if (!vset)
+        return null;
+    const known = new Set(author.findings.map((f) => f.id));
+    const graded = vset.verifications.filter((v) => known.has(v.target_id));
+    if (!isRubberStamp(graded, vset))
+        return { vset, graded, rubberStamp: false };
+    // Rubber stamp → one sharper re-ask. Accept it only if it actually pushed back (a non-CONFIRM verdict)
+    // or supplied the missing weakest-first justification; otherwise keep the original and flag.
+    const fix = `${prompt}\n\n---\nYour previous cross-examination CONFIRMED every finding and gave no weakest-first ` +
+        `justification — that reads as a rubber stamp, not a peer cross-examination. Re-examine: rank the ` +
+        `findings weakest-first, open the file:lines of the single weakest, and either REFUTE it with concrete ` +
+        `evidence or mark it UNCERTAIN with the specific doubt. If every finding truly survives, set ` +
+        `"all_confirmed_justification" naming the weakest and the file:line reason it holds. Output ONLY the corrected JSON.`;
+    const retry = await callExam(ctx, examiner, `S8-${examiner}-repair`, fix);
+    if (retry) {
+        const rg = retry.verifications.filter((v) => known.has(v.target_id));
+        if (!isRubberStamp(rg, retry))
+            return { vset: retry, graded: rg, rubberStamp: false };
+    }
+    return { vset, graded, rubberStamp: true };
+}
+export async function s8CrossExam(ctx, reviewers) {
+    const byKey = new Map();
+    const all = [];
+    // Cross-exam is defined for exactly two reviewers examining each other. With <2 (a single survivor)
+    // there is nothing to cross-examine; write an empty artifact and leave every finding single-reviewer.
+    if (reviewers.length === 2) {
+        const [a, b] = reviewers;
+        for (const [examiner, author] of [[a, b], [b, a]]) {
+            if (author.findings.length === 0)
+                continue; // skip-empty (nothing to examine)
+            const result = await examine(ctx, examiner.provider, author);
+            if (!result)
+                continue;
+            const { graded, rubberStamp } = result;
+            // A rubber stamp that survived the sharper re-ask stays flagged (still no pushback, no justification).
+            if (rubberStamp)
+                ctx.addFlag('synthesis_suspect');
+            for (const v of graded) {
+                byKey.set(`${author.provider}/${v.target_id}`, { verdict: v.verdict, note: v.note, evidence: v.evidence, examiner: examiner.provider });
+                all.push({ ...v, target_id: `${author.provider}/${v.target_id}` }); // namespace for the artifact (ids collide across reviewers)
+            }
+        }
+    }
+    // NB: the 08-verifications artifact is written by the workflow AFTER 07-review-map (ascending order).
+    return { byKey, verifications: all };
+}

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

@@ -0,0 +1,89 @@
+// code-review S9 — judge adjudication (§12.2, T10). The judge (agy/Gemini — it authored NO finding, so
+// it can adjudicate cleanly) rules on the DISPUTED findings only (those one reviewer flagged as a false
+// positive in cross-exam). Ruling polarity is finding-centric here (NOT idea S9's attack-centric one):
+//   UPHOLD = genuine defect, keep it   ·   REJECT = false positive, drop it   ·   UNRESOLVED = undecided.
+//
+// SAFETY (grilled 2026-07-04): the judge runs with cwd = the RUN DIR, never the repo — it only sees
+// findings text in its prompt, so agy's unverified --sandbox write-blocking can't touch the repo. Zero
+// disputes → no judge call; synthesize a deterministic verdict.
+import { JudgeReportModel } from '../../schemas/index.js';
+import { isFatal } from '../context.js';
+import { jsonCall } from '../jsonStage.js';
+import { adjudicationScopeViolations } from './s9-judge.js';
+import { loadSkill } from '../skills.js';
+const S9_PROMPT = `ROLE: Judge on a code review. Two independent reviewers disagreed on the findings below:
+one reviewer reported each as a defect; another flagged it as a likely FALSE POSITIVE (see "refutation").
+For EACH disputed finding, rule from the evidence and refutation given (you have findings text only):
+- UPHOLD = it IS a genuine defect (keep it),
+- REJECT = it is a false positive (drop it),
+- UNRESOLVED = genuinely undecided.{{SKILL}}
+Output ONLY JSON matching the judge schema:
+- adjudications: for EACH disputed id → {id, ruling: UPHOLD|REJECT|UNRESOLVED, reasoning ≤3 sentences, evidence_cited}.
+- verdict: ≤80 words — overall assessment of the change (roughly how many real defects, worst severity).
+- dissent: ≥1 item — the strongest argument against your own verdict. Empty dissent is invalid.
+- confidence_notes: which findings you hold HIGH/MEDIUM/LOW and why.
+DISPUTED FINDINGS: {{DISPUTED_JSON}}`;
+/**
+ * Fill the judge template: {{DISPUTED_JSON}} → the disputes, {{SKILL}} → the judge playbook (or nothing).
+ * An empty skill collapses the slot, so the prompt is byte-for-byte the pre-skill baseline.
+ */
+export function buildJudgePrompt(disputes, skill) {
+    return S9_PROMPT.replace('{{DISPUTED_JSON}}', JSON.stringify(disputes, null, 2)).replace('{{SKILL}}', skill ? `\n\n${skill}` : '');
+}
+export async function s9ReviewJudge(ctx, map) {
+    const disputeIds = map.disputed.map((d) => d.finding.id);
+    // No disputes → nothing to adjudicate; synthesize a verdict deterministically (save the call).
+    if (disputeIds.length === 0) {
+        const kept = map.consensus.length + map.single_reviewer.length;
+        const report = {
+            adjudications: [],
+            verdict: `${kept} finding(s) reported, none disputed by the reviewers.`,
+            dissent: ['(no disputed findings — nothing to contest)'],
+            confidence_notes: 'Consensus findings HIGH; single-reviewer findings MEDIUM.',
+        };
+        await ctx.writer.writeJson('judge-report', report);
+        return report;
+    }
+    const disputes = map.disputed.map((d) => ({
+        id: d.finding.id,
+        file: d.finding.file,
+        lines: `${d.finding.line_start}-${d.finding.line_end}`,
+        severity: d.finding.severity,
+        category: d.finding.category,
+        claim: d.finding.claim,
+        evidence: d.finding.evidence,
+        refutation: d.refutation ?? '',
+    }));
+    const basePrompt = buildJudgePrompt(disputes, loadSkill('code-review', 'judge'));
+    // Judge runs on cwd = run dir (NOT the repo) — sidesteps agy's unverified sandbox.
+    const judge = ctx.handle(ctx.roles.judge);
+    const opts = { cwd: ctx.writer.dir };
+    let report = await jsonCall(ctx, judge, 'S9', basePrompt, JudgeReportModel, opts);
+    // Anti-scope + mandatory-dissent guard → one targeted re-ask (mirrors idea S9).
+    let violations = adjudicationScopeViolations(report, disputeIds);
+    if (violations.length || report.dissent.length === 0) {
+        const fix = `${basePrompt}\n\n---\nYour previous output had problems:\n` +
+            (violations.length ? `- adjudications must reference ONLY these disputed ids [${disputeIds.join(', ')}]; not: ${violations.join(', ')}\n` : '') +
+            (report.dissent.length === 0 ? `- dissent must contain at least one item.\n` : '') +
+            `Output ONLY the corrected JSON.`;
+        try {
+            report = await jsonCall(ctx, judge, 'S9-repair', fix, JudgeReportModel, opts);
+            violations = adjudicationScopeViolations(report, disputeIds);
+        }
+        catch (e) {
+            if (isFatal(e))
+                throw e; // keep the first report on a non-fatal repair failure
+        }
+    }
+    const inScope = report.adjudications.filter((a) => new Set(disputeIds).has(a.id));
+    if (inScope.length !== report.adjudications.length)
+        ctx.addFlag('synthesis_suspect');
+    let dissent = report.dissent;
+    if (dissent.length === 0) {
+        ctx.addFlag('synthesis_suspect');
+        dissent = ['(none produced — flagged synthesis_suspect)'];
+    }
+    const final = { ...report, adjudications: inScope, dissent, recommendation: undefined, conditions: undefined };
+    await ctx.writer.writeJson('judge-report', final);
+    return final;
+}

package/dist/orchestration/stages/s0-grill.js

@@ -0,0 +1,79 @@
+// S0 - contextual grill / intent preflight. One cheap front-loaded model call generates
+// 3-4 context-specific questions; interactive surfaces answer them before the full council runs.
+import { RunBrief, RunBriefDraft } from '../../schemas/index.js';
+import { jsonCall } from '../jsonStage.js';
+const S0_PROMPT = `You are the intent preflight analyst for aiki, a professional multi-model council.
+Read the user's idea below. Do not evaluate the idea yet. Instead, produce a concise run brief and
+exactly 3 or 4 context-specific questions that would materially improve the later council's verdict.
+
+Output ONLY JSON matching this shape:
+{
+  "subject": "<short subject>",
+  "decision_frame": "<what decision the user seems to need, or null>",
+  "evaluation_lens": "<lens the council should use, or null>",
+  "target_user": "<target user stated or implied, or null>",
+  "constraints": ["<explicit constraints>"],
+  "claims_to_test": ["<load-bearing claims worth testing>"],
+  "evidence_supplied": ["<evidence or proof already supplied>"],
+  "missing_axes": ["<important missing context>"],
+  "questions": [
+    {
+      "id": "Q1",
+      "axis": "decision_frame|evaluation_lens|target_user|success_bar|non_negotiables|risk_context|evidence|alternatives|scope",
+      "question": "<one direct question>",
+      "why_it_matters": "<one sentence>",
+      "suggested_answers": ["<2-5 short options>"]
+    }
+  ]
+}
+
+Rules:
+- Ask only questions whose answers could change the analysis or verdict.
+- Make the questions specific to this idea, not generic startup intake.
+- Prefer decision frame, target user, success bar, constraints, evidence, and risk context.
+- Do not ask more than 4 questions.
+
+USER IDEA:
+{{RAW_INPUT}}`;
+export function defaultGrillAnswers(brief) {
+    return brief.questions.map((q) => ({
+        question_id: q.id,
+        answer: 'Use best judgment from the supplied prompt.',
+        source: 'default',
+    }));
+}
+function normalizeAnswers(brief, answers) {
+    const byQuestion = new Map((answers ?? []).map((a) => [a.question_id, a]));
+    return brief.questions.map((q) => {
+        const found = byQuestion.get(q.id);
+        const answer = found?.answer.trim();
+        if (found && answer)
+            return { question_id: q.id, answer, source: found.source };
+        return { question_id: q.id, answer: 'Use best judgment from the supplied prompt.', source: 'default' };
+    });
+}
+export async function s0Grill(ctx, rawInput) {
+    const analyst = ctx.handle(ctx.roles.analyst);
+    const draft = await jsonCall(ctx, analyst, 'S0', S0_PROMPT.replace('{{RAW_INPUT}}', rawInput), RunBriefDraft);
+    const answers = normalizeAnswers(draft, ctx.events?.grill ? await ctx.events.grill(draft) : defaultGrillAnswers(draft));
+    const brief = RunBrief.parse({ ...draft, answers });
+    await ctx.writer.writeJson('run-brief', brief);
+    return brief;
+}
+export function renderGrilledInput(rawInput, brief) {
+    const sections = [
+        `Subject: ${brief.subject}`,
+        brief.decision_frame ? `Decision frame: ${brief.decision_frame}` : null,
+        brief.evaluation_lens ? `Evaluation lens: ${brief.evaluation_lens}` : null,
+        brief.target_user ? `Target user: ${brief.target_user}` : null,
+        brief.constraints.length ? `Constraints: ${brief.constraints.join('; ')}` : null,
+        brief.claims_to_test.length ? `Claims to test: ${brief.claims_to_test.join('; ')}` : null,
+        brief.evidence_supplied.length ? `Evidence supplied: ${brief.evidence_supplied.join('; ')}` : null,
+        brief.missing_axes.length ? `Missing context: ${brief.missing_axes.join('; ')}` : null,
+    ].filter((line) => line !== null);
+    const answers = brief.questions.map((q) => {
+        const answer = brief.answers.find((a) => a.question_id === q.id);
+        return `- ${q.question}\n  Answer: ${answer?.answer ?? 'Use best judgment from the supplied prompt.'}`;
+    });
+    return `${rawInput.trim()}\n\n---\nAiki intent preflight\n${sections.join('\n')}\n\nAnswers:\n${answers.join('\n')}\n`;
+}

package/dist/orchestration/stages/s1-intent.js

@@ -0,0 +1,25 @@
+// S1 — intent contract (§9, §13). Analyst normalizes the raw request into a typed IntentContract.
+// Failure handling (§9): invalid JSON → one repair retry (in jsonCall) → StageError('BAD_OUTPUT'),
+// which aborts the run with a message.
+import { IntentContract } from '../../schemas/index.js';
+import { jsonCall } from '../jsonStage.js';
+// §13 S1 prompt, verbatim.
+const S1_PROMPT = `You are the intake analyst for a professional multi-model orchestration system.
+Read the user's request below. Produce ONLY a JSON object matching this schema, nothing else:
+
+{"task": "<one-paragraph normalized restatement>",
+ "task_type": "idea-refinement|code-review|other",
+ "constraints": ["<explicit constraints stated by the user>"],
+ "unknowns": ["<things the request leaves unspecified>"],
+ "success_criteria": ["<what a good final output must contain>"]}
+
+Rules: do not answer the request. Do not add constraints the user did not state.
+USER REQUEST:
+{{RAW_INPUT}}`;
+export async function s1Intent(ctx, rawInput) {
+    const analyst = ctx.handle(ctx.roles.analyst);
+    const prompt = S1_PROMPT.replace('{{RAW_INPUT}}', rawInput);
+    const contract = await jsonCall(ctx, analyst, 'S1', prompt, IntentContract);
+    await ctx.writer.writeJson('intent-contract', contract);
+    return contract;
+}