aiki-cli 0.2.2 → 0.3.0

package/dist/bench/scoring/decision-insights.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+export const DecisionStance = z.enum(['SUPPORT', 'OPPOSE', 'QUALIFY', 'UNRESOLVED']);
+export const FactKind = z.enum(['CURRENT_FACT', 'DURABLE_FACT', 'INFERENCE']);
+export const EvidenceStatus = z.enum(['SUPPORTED', 'UNSUPPORTED', 'NOT_REQUIRED']);
+export const ExpectedDecisionClaim = z.object({
+    id: z.string().min(1),
+    proposition: z.string().min(1),
+    acceptable_stances: z.array(DecisionStance).min(1),
+    evidence_required: z.boolean(),
+});
+export const DecisionInsightAdjudication = z.object({
+    expected_claims: z.array(ExpectedDecisionClaim),
+    report_claims: z.array(z.object({
+        id: z.string().min(1),
+        stance: DecisionStance,
+        fact_kind: FactKind,
+        correct: z.boolean(),
+        relevant: z.boolean(),
+        evidence_status: EvidenceStatus,
+    })),
+    matches: z.array(z.object({
+        expected_claim_id: z.string().min(1),
+        report_claim_id: z.string().min(1),
+    })),
+}).superRefine((input, ctx) => {
+    const expectedIds = new Set(input.expected_claims.map((claim) => claim.id));
+    const reportIds = new Set(input.report_claims.map((claim) => claim.id));
+    if (expectedIds.size !== input.expected_claims.length || reportIds.size !== input.report_claims.length) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'expert and report claim ids must be unique' });
+    }
+    const expected = new Set();
+    const reported = new Set();
+    for (const match of input.matches) {
+        if (!expectedIds.has(match.expected_claim_id) || !reportIds.has(match.report_claim_id)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'claim matches must reference declared claim ids' });
+        }
+        if (expected.has(match.expected_claim_id) || reported.has(match.report_claim_id)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'claim matches must be one-to-one' });
+        }
+        expected.add(match.expected_claim_id);
+        reported.add(match.report_claim_id);
+    }
+});
+export const IdeaV3CaseManifest = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    set: z.enum(['build', 'holdout']),
+    provenance: z.enum(['INSPECTED_BUILD', 'AUTHORED_BUILD', 'SEALED_HOLDOUT']),
+    tags: z.array(z.string().min(1)).min(1),
+    input_file: z.string().min(1),
+    critical_claims: z.array(ExpectedDecisionClaim).min(1),
+    common_false_claims: z.array(z.object({
+        id: z.string().min(1),
+        claim: z.string().min(1),
+        reason: z.string().min(1),
+    })),
+    required_dimensions: z.array(z.string().min(1)).length(12),
+    source_pack: z.array(z.object({
+        id: z.string().min(1),
+        title: z.string().min(1),
+        as_of: z.string().min(1),
+        url: z.string().url().optional(),
+        local_file: z.string().min(1).optional(),
+    })),
+    acceptable_unresolved_outcomes: z.array(z.object({
+        claim_id: z.string().min(1),
+        reason: z.string().min(1),
+    })),
+});
+/** Score one blinded, human-adjudicated idea report. */
+export function scoreDecisionInsights(input) {
+    input = DecisionInsightAdjudication.parse(input);
+    const reportById = new Map(input.report_claims.map((claim) => [claim.id, claim]));
+    const isTruePositive = (claim) => claim.correct && claim.relevant && (claim.fact_kind !== 'CURRENT_FACT' || claim.evidence_status === 'SUPPORTED');
+    const truePositiveReports = input.report_claims.filter(isTruePositive).length;
+    const matched = input.matches.filter((match) => {
+        const expected = input.expected_claims.find((claim) => claim.id === match.expected_claim_id);
+        const report = reportById.get(match.report_claim_id);
+        return expected && report && isTruePositive(report) && expected.acceptable_stances.includes(report.stance)
+            && (!expected.evidence_required || report.evidence_status === 'SUPPORTED');
+    }).length;
+    const recall = input.expected_claims.length ? matched / input.expected_claims.length : 0;
+    const precision = input.report_claims.length ? truePositiveReports / input.report_claims.length : 0;
+    return {
+        expected: input.expected_claims.length,
+        matched,
+        reported: input.report_claims.length,
+        true_positive_reports: truePositiveReports,
+        recall,
+        precision,
+        f1: recall + precision ? (2 * recall * precision) / (recall + precision) : 0,
+    };
+}
+/** Micro-average case scores by summing claim counts before calculating rates. */
+export function summarizeDecisionInsights(scores) {
+    const sum = (key) => scores.reduce((total, score) => total + score[key], 0);
+    const expected = sum('expected');
+    const matched = sum('matched');
+    const reported = sum('reported');
+    const truePositiveReports = sum('true_positive_reports');
+    const recall = expected ? matched / expected : 0;
+    const precision = reported ? truePositiveReports / reported : 0;
+    return {
+        expected,
+        matched,
+        reported,
+        true_positive_reports: truePositiveReports,
+        recall,
+        precision,
+        f1: recall + precision ? (2 * recall * precision) / (recall + precision) : 0,
+    };
+}

package/dist/bench/scoring/seeded-bugs.js

@@ -19,11 +19,15 @@ export const BugManifest = z.object({ bugs: z.array(SeededBug) });
 /** Score one arm's findings against a case's seeded bugs (BENCHMARK.md §3). Pure. */
 export function scoreRun(findings, bugs) {
     const matchedBugIds = bugs.filter((bug) => findings.some((f) => sameFinding(f, bug))).map((b) => b.id);
+    const sameLocation = (finding, bug) => finding.file === bug.file && finding.line_start <= bug.line_end && bug.line_start <= finding.line_end;
+    const matchedRelaxed = bugs.filter((bug) => findings.some((finding) => sameLocation(finding, bug))).length;
     const unmatched = findings.filter((f) => !bugs.some((bug) => sameFinding(f, bug))).length;
     return {
         seeded: bugs.length,
         matched: matchedBugIds.length,
         recall: bugs.length === 0 ? 0 : matchedBugIds.length / bugs.length,
+        matchedRelaxed,
+        recallRelaxed: bugs.length === 0 ? 0 : matchedRelaxed / bugs.length,
         reported: findings.length,
         unmatched,
         matchedBugIds,

package/dist/cli/bench.js

@@ -4,7 +4,11 @@
 // quota). --resume continues the latest results file, keeping already-scored case×arm pairs.
 import { planBench, renderTable, runBench } from '../bench/harness.js';
 import { setupProviders } from '../orchestration/context.js';
-const VALID_ARMS = ['A', 'B', 'C', 'D', 'E'];
+import { chooseLaneDefault, importLaneAdjudications, planIdeaLaneBench, runIdeaLaneBench } from '../bench/idea-lane-rotation.js';
+import { IDEA_V3_ARM_IDS, planIdeaV3Bench, runIdeaV3Bench } from '../bench/idea-v3-bench.js';
+import { exportIdeaV3BlindBundle, importIdeaV3Ratings, writeFrozenIdeaV3Protocol, writeIdeaV3Results } from '../bench/idea-v3-rating.js';
+import { DISPLAY_NAME } from '../providers/types.js';
+const VALID_ARMS = ['A', 'B', 'C', 'D', 'E', 'L'];
 /** One-block pre-run summary: what will run + the ≈Opus cost, so the user commits knowingly (§19). */
 function renderPlan(plan) {
     const L = [`bench ${plan.suite} — set ${plan.set} — ${plan.cases.length} case(s) × arms ${plan.arms.join(',')}`];
@@ -15,8 +19,181 @@ function renderPlan(plan) {
     return L.join('\n');
 }
 export async function benchCommand(workflow, opts = {}) {
+    if (workflow === 'idea-v3') {
+        if (opts.freezeProtocol) {
+            try {
+                const result = await writeFrozenIdeaV3Protocol({ draftPath: opts.freezeProtocol });
+                process.stdout.write(`\nprotocol frozen: ${result.path}\n`);
+                process.stdout.write('Commit this file before opening holdout. No provider calls were made.\n\n');
+                return 0;
+            }
+            catch (error) {
+                process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 1;
+            }
+        }
+        if (opts.publishResults) {
+            try {
+                const result = await writeIdeaV3Results({ scoredPath: opts.publishResults });
+                process.stdout.write(`\nresults: ${result.path}\n`);
+                process.stdout.write(`frozen ship gate: ${result.gates.ship ? 'PASS' : 'FAIL'}\n\n`);
+                return 0;
+            }
+            catch (error) {
+                process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 1;
+            }
+        }
+        if (opts.importRatings) {
+            try {
+                const result = await importIdeaV3Ratings({ campaignPath: opts.campaign, resolutionPath: opts.importRatings });
+                process.stdout.write(`\nscored campaign: ${result.path}\n`);
+                for (const item of result.scored.summary) {
+                    process.stdout.write(`${item.arm}: recall ${item.score.recall.toFixed(3)} · precision ${item.score.precision.toFixed(3)} · F1 ${item.score.f1.toFixed(3)}\n`);
+                }
+                process.stdout.write('Raw locked ratings and hashes were retained. No provider calls were made.\n\n');
+                return 0;
+            }
+            catch (error) {
+                process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 1;
+            }
+        }
+        if (opts.exportBlind) {
+            try {
+                const result = await exportIdeaV3BlindBundle({ campaignPath: opts.campaign, outDir: opts.exportBlind });
+                process.stdout.write(`\nblinded rating packets: ${result.outDir}\n`);
+                process.stdout.write(`private mapping (do not give to raters): ${result.mappingPath}\n`);
+                process.stdout.write('Give each rater only their own rater-* directory. No provider calls were made.\n\n');
+                return 0;
+            }
+            catch (error) {
+                process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 1;
+            }
+        }
+        if (opts.set && opts.set !== 'build' && opts.set !== 'holdout') {
+            process.stderr.write(`idea-v3 set must be build or holdout (got "${opts.set}")\n`);
+            return 1;
+        }
+        const set = (opts.set ?? 'build');
+        const requested = opts.arms
+            ? opts.arms.split(',').map((value) => value.trim().toUpperCase()).filter(Boolean)
+            : set === 'build' ? ['B', 'C', 'D2', 'R'] : ['B', 'C', 'R'];
+        const invalid = requested.filter((arm) => !IDEA_V3_ARM_IDS.includes(arm));
+        if (invalid.length) {
+            process.stderr.write(`invalid idea-v3 arm(s): ${invalid.join(', ')}. Valid: B,C,D2,R\n`);
+            return 1;
+        }
+        const arms = requested;
+        const provider = opts.baselineProvider ?? 'claude';
+        if (!['claude', 'codex', 'agy'].includes(provider)) {
+            process.stderr.write(`invalid baseline provider "${provider}". Valid: claude,codex,agy\n`);
+            return 1;
+        }
+        let plan;
+        try {
+            plan = await planIdeaV3Bench({ set, arms, resume: opts.resume, baselineProvider: provider });
+        }
+        catch (error) {
+            process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+            return 1;
+        }
+        process.stdout.write(`\nidea-v3 protocol comparison — ${set} — ${plan.cases.length} case(s) × arms ${arms.join(',')}\n`);
+        process.stdout.write(`B/C baseline provider: ${DISPLAY_NAME[provider]}\n`);
+        if (plan.resumedFrom)
+            process.stdout.write(`resume: continuing ${plan.resumedFrom} — ${plan.skipCompleted} recorded pair(s) kept\n`);
+        process.stdout.write(`to run: ${plan.toRun.length} case×arm pair(s) → ≤${plan.estimatedProviderCalls} nominal provider call(s)\n`);
+        if (arms.includes('D2'))
+            process.stdout.write('D2 source: archived R0 runner at commit 680fba3 (supply --d2-import when executing)\n');
+        if (!plan.toRun.length) {
+            process.stdout.write('\nnothing to run — every requested pair is already recorded.\n\n');
+            return 0;
+        }
+        if (!opts.yes) {
+            process.stdout.write('\nRe-run with --yes to execute. Paid calls are never started by this dry-run.\n\n');
+            return 0;
+        }
+        try {
+            const result = await runIdeaV3Bench({
+                set,
+                arms,
+                resume: opts.resume,
+                baselineProvider: provider,
+                d2ImportPath: opts.d2Import,
+            });
+            process.stdout.write(`\nresults: ${result.path}\n`);
+            process.stdout.write('Reports remain unscored until the frozen blinded-rating import step.\n\n');
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+            return 1;
+        }
+    }
+    if (workflow === 'idea-refinement') {
+        if (opts.set && opts.set !== 'build') {
+            process.stderr.write('idea lane rotation is build-set-only; holdout remains sealed\n');
+            return 1;
+        }
+        // --import is offline: blind adjudications → frozen R0 scorer → filled campaign metrics. No provider calls.
+        if (opts.import) {
+            try {
+                const { path, scored, observations } = await importLaneAdjudications({ importPath: opts.import });
+                for (const o of scored) {
+                    process.stdout.write(`scored ${o.case_id}/${o.rotation} — recall ${o.decision_critical_recall} · evidence precision ${o.evidence_precision}\n`);
+                }
+                const pending = observations.filter((o) => o.decision_critical_recall === null || o.evidence_precision === null).length;
+                const selected = pending === 0 ? chooseLaneDefault(observations) : null;
+                process.stdout.write(`\nresults: ${path}\n`);
+                process.stdout.write(selected
+                    ? `default lane assignment: ${selected}\n\n`
+                    : pending > 0
+                        ? `${pending} pair(s) still unscored — the lane default stays provisional until every pair is adjudicated.\n\n`
+                        : 'all pairs scored but no winner (incomplete matrix or exact tie) — default stays provisional.\n\n');
+                return 0;
+            }
+            catch (error) {
+                process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 1;
+            }
+        }
+        const handles = await setupProviders();
+        let plan;
+        try {
+            plan = await planIdeaLaneBench({ handles, resume: opts.resume, caseId: opts.case });
+        }
+        catch (error) {
+            process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+            return 1;
+        }
+        if (plan.cases.length === 0) {
+            process.stderr.write('no cases found in bench/sets/idea-refinement/build/\n');
+            return 1;
+        }
+        process.stdout.write(`\nidea lane rotation — ${plan.cases.length} case(s) × 2 assignments\n`);
+        if (plan.resumedFrom)
+            process.stdout.write(`resume: continuing ${plan.resumedFrom} — completed pairs are kept, not re-run\n`);
+        process.stdout.write(`to run: ${plan.runs.length} council run(s) → ≈${plan.estimatedCalls} provider call(s)\n`);
+        if (plan.runs.length === 0) {
+            process.stdout.write('\nnothing to run — every case×rotation pair is already recorded.\n\n');
+            return 0;
+        }
+        if (!opts.yes) {
+            const resumeHint = opts.resume ? '' : ' (add --resume to continue a partial run across quota windows)';
+            process.stdout.write(`\nRe-run with --yes to execute${resumeHint}. Paid calls are never started by this dry-run.\n\n`);
+            return 0;
+        }
+        const result = await runIdeaLaneBench({ handles, resume: opts.resume, caseId: opts.case });
+        const selected = chooseLaneDefault(result.observations);
+        process.stdout.write(`\nresults: ${result.path}\n`);
+        process.stdout.write(selected
+            ? `default lane assignment: ${selected}\n\n`
+            : 'default remains provisional — blind-score recall/evidence precision before selection.\n\n');
+        return 0;
+    }
     if (workflow !== 'code-review') {
-        process.stderr.write(`bench supports only "code-review" in v1 (got "${workflow}")\n`);
+        process.stderr.write(`bench supports "code-review", "idea-refinement", or "idea-v3" (got "${workflow}")\n`);
         return 1;
     }
     const arms = (opts.arms ?? 'A,B,C,D')
@@ -24,7 +201,7 @@ export async function benchCommand(workflow, opts = {}) {
         .map((s) => s.trim().toUpperCase())
         .filter((a) => VALID_ARMS.includes(a));
     if (arms.length === 0) {
-        process.stderr.write(`no valid arms in "${opts.arms}". Valid: A,B,C,D\n`);
+        process.stderr.write(`no valid arms in "${opts.arms}". Valid: A,B,C,D,E,L\n`);
         return 1;
     }
     const set = opts.set ?? 'build';

package/dist/cli/doctor.js

@@ -18,19 +18,18 @@ const READONLY_LABEL = {
 };
 const pad = (s, w) => s.padEnd(w);
 /**
- * `aiki doctor` — detection + flag probe + (optional) smoke test, table output, actionable
- * fixes. Exit 0 iff ≥2 providers are "ready" (§5, §8 quorum). With smoke on, ready = smoke
- * passed; with --no-smoke, ready = detected.
- *
- * Smoke results are cached 6h in `.aiki/smoke-cache.json` (§242); `--fresh` bypasses the cache.
- * A cache entry is reused only when its provider version still matches (an upgrade re-smokes).
+ * The shared check engine behind `aiki doctor` and the TUI startup preflight: detection + flag
+ * probe + (optional) smoke test per provider. `onRow` fires as each provider finishes, so a UI
+ * can show live progress. Smoke results are cached 6h in `.aiki/smoke-cache.json` (§242);
+ * `fresh` bypasses the cache. A cache entry is reused only when its provider version still
+ * matches (an upgrade re-smokes).
  */
-export async function doctor(opts = {}) {
+export async function runDoctorChecks(opts = {}) {
     const runSmoke = opts.smoke !== false;
     const cache = runSmoke ? await readSmokeCache() : {};
     const now = Date.now();
     const updates = {};
-    const rows = await Promise.all(PROVIDER_IDS.map(async (id) => {
+    const check = async (id) => {
         const det = await detect(id);
         if (det.status !== 'READY')
             return { det };
@@ -44,23 +43,35 @@ export async function doctor(opts = {}) {
         const smoke = await smokeTest(id, flags);
         updates[id] = toEntry(smoke, det.version ?? null, new Date(now));
         return { det, flags, smoke };
+    };
+    const rows = await Promise.all(PROVIDER_IDS.map(async (id) => {
+        const row = await check(id);
+        opts.onRow?.(row);
+        return row;
     }));
     if (Object.keys(updates).length)
         await writeSmokeCache({ ...cache, ...updates });
+    return {
+        rows,
+        ready: rows.filter((row) => isReady(row, runSmoke)).length,
+        fixes: rows.flatMap(fixLines),
+    };
+}
+/**
+ * `aiki doctor` — runs the checks, prints the table + actionable fixes. Exit 0 iff ≥2 providers
+ * are "ready" (§5, §8 quorum). With smoke on, ready = smoke passed; with --no-smoke, ready = detected.
+ */
+export async function doctor(opts = {}) {
+    const runSmoke = opts.smoke !== false;
+    const { rows, ready, fixes } = await runDoctorChecks(opts);
     const lines = [];
     lines.push('');
     lines.push(`  aiki doctor — provider status${runSmoke ? '' : ' (smoke skipped)'}`);
     lines.push('');
     lines.push(`  ${pad('PROVIDER', 10)}${pad('VERSION', 11)}${pad('STATUS', 15)}${pad('JSON', 6)}${pad('READ-ONLY', 11)}${pad('SMOKE', 14)}ROLE`);
     lines.push(`  ${'─'.repeat(82)}`);
-    let ready = 0;
-    const fixes = [];
-    for (const row of rows) {
+    for (const row of rows)
         lines.push(renderRow(row, runSmoke));
-        if (isReady(row, runSmoke))
-            ready++;
-        fixes.push(...fixLines(row));
-    }
     lines.push('');
     lines.push(`  ${ready}/3 providers ready. Engine minimum quorum: 2.`);
     if (rows.some((r) => r.cached))
@@ -97,19 +108,40 @@ function renderSmoke(detected, runSmoke, smoke) {
         return `✔ ${(smoke.durationMs / 1000).toFixed(1)}s`;
     return `✖ ${smoke.error ?? 'FAIL'}`;
 }
-function fixLines(row) {
+/** The actionable fix for a failing row, or undefined when the row is healthy.
+ *  Fixes are user-facing (show display name) but reference the real binary for commands. */
+function fixFor(row) {
     const { det, smoke } = row;
-    const name = DISPLAY_NAME[det.id];
-    // Fixes are user-facing (show display name) but reference the real binary for commands.
-    if (det.status !== 'READY' && det.hint)
-        return [`  ${name}: ${det.hint}`];
+    if (det.status !== 'READY')
+        return det.hint;
     if (smoke && !smoke.ok) {
-        const fix = smoke.error === 'AUTH'
+        return smoke.error === 'AUTH'
             ? `run \`${det.id}\` once to log in`
             : smoke.error === 'QUOTA'
-                ? 'provider quota/rate limited — retry later'
+                ? 'retry later — quota/rate limit resets on its own'
                 : (smoke.detail ?? 'smoke failed');
-        return [`  ${name}: ${fix}`];
     }
-    return [];
+    return undefined;
+}
+function fixLines(row) {
+    const fix = fixFor(row);
+    return fix ? [`  ${DISPLAY_NAME[row.det.id]}: ${fix}`] : [];
+}
+/** One TUI preflight row: status icon + human label + the fix to show when it failed. */
+export function preflightLine(row) {
+    const name = DISPLAY_NAME[row.det.id];
+    if (row.det.status !== 'READY')
+        return { ok: false, label: `${name} — not installed`, fix: fixFor(row) };
+    const version = row.det.version ? ` ${row.det.version}` : '';
+    const { smoke } = row;
+    if (!smoke)
+        return { ok: true, label: `${name}${version} — CLI detected` };
+    if (smoke.ok) {
+        const timing = row.cached ? 'cached ≤6h' : `${(smoke.durationMs / 1000).toFixed(1)}s`;
+        return { ok: true, label: `${name}${version} — ready (smoke ${timing})` };
+    }
+    const reason = smoke.error === 'AUTH' ? 'auth failed'
+        : smoke.error === 'QUOTA' ? 'quota/rate limited'
+            : `smoke failed (${smoke.error ?? 'unknown'})`;
+    return { ok: false, label: `${name}${version} — ${reason}`, fix: fixFor(row) };
 }

package/dist/cli/index.js

@@ -46,14 +46,16 @@ program
     .description('Headless run of a workflow (§5). idea-refinement: text/file. code-review: git diff or --diff.')
     .argument('<workflow>', 'workflow id: idea-refinement | code-review')
     .argument('[input]', 'idea-refinement: inline text or a path to a .md file')
-    .option('--budget <n>', 'max provider calls for this run (default 12)', (v) => parseInt(v, 10))
+    .option('--budget <n>', 'max provider calls for this run (default is mode-aware)', (v) => parseInt(v, 10))
     .option('--base <ref>', 'code-review: base git ref to diff from (default: detected default branch)')
     .option('--head <ref>', 'code-review: head git ref to diff to (default HEAD)')
     .option('--diff <file>', 'code-review: review a patch file instead of computing a git diff')
+    .option('--evidence <path>', 'idea-refinement: local source file/directory (stores paths + hashes, not copies)')
+    .option('--mode <mode>', 'idea-refinement: quick | council | research (default council)')
     .option('--cheap', 'code-review: Gemini+Codex review, Claude judges only disputes (~⅓ the Opus; experimental)')
     .option('--yes', 'skip the run-cost confirmation prompt')
     .action(async (workflow, input, opts) => {
-    process.exit(await runCommand(workflow, input, { budget: opts.budget, base: opts.base, head: opts.head, diff: opts.diff, cheap: opts.cheap, yes: opts.yes }));
+    process.exit(await runCommand(workflow, input, { budget: opts.budget, base: opts.base, head: opts.head, diff: opts.diff, evidence: opts.evidence, mode: opts.mode, cheap: opts.cheap, yes: opts.yes }));
 });
 program
     .command('show')
@@ -89,14 +91,37 @@ program
 });
 program
     .command('bench')
-    .description('Run benchmark arms A–D on a task set; writes bench/results/*.json + summary table (§17).')
-    .argument('<workflow>', 'workflow id (v1: code-review)')
-    .option('--arms <list>', 'comma-separated arms to run', 'A,B,C,D')
+    .description('Run code-review, idea lane, or frozen idea-v3 benchmark arms; writes bench/results/*.json.')
+    .argument('<workflow>', 'code-review | idea-refinement | idea-v3')
+    .option('--arms <list>', 'comma-separated arms to run (code review defaults A,B,C,D; idea-v3 defaults B,C,D2,R on build)')
     .option('--set <name>', 'task set: build | holdout', 'build')
     .option('--resume', 'continue the latest results file: keep already-scored case×arm pairs, retry the rest')
     .option('--yes', 'actually run; without it, print the pre-run Opus-call estimate and exit')
+    .option('--import <file>', 'idea-refinement: import blind adjudications into the latest campaign file (offline, frozen R0 scorer)')
+    .option('--case <id>', 'idea-refinement: restrict the metered run to one build case (combine with --resume)')
+    .option('--baseline-provider <id>', 'idea-v3 build tuning: provider used for B/C (claude | codex | agy)', 'claude')
+    .option('--d2-import <file>', 'idea-v3 build: observations produced by the archived R0 runner at commit 680fba3')
+    .option('--export-blind <dir>', 'idea-v3: export 3 independently ordered offline rating packets from a complete campaign')
+    .option('--import-ratings <file>', 'idea-v3: score a locked three-rater resolution once (offline, frozen R0 scorer)')
+    .option('--freeze-protocol <draft-file>', 'idea-v3: freeze a complete scored build protocol once (offline)')
+    .option('--publish-results <scores-file>', 'idea-v3: write RESULTS-IDEA-V3.md from frozen holdout scores (offline)')
+    .option('--campaign <file>', 'idea-v3 offline operation: explicit campaign file (default: latest)')
     .action(async (workflow, opts) => {
-    process.exit(await benchCommand(workflow, { arms: opts.arms, set: opts.set, resume: opts.resume, yes: opts.yes }));
+    process.exit(await benchCommand(workflow, {
+        arms: opts.arms,
+        set: opts.set,
+        resume: opts.resume,
+        yes: opts.yes,
+        import: opts.import,
+        case: opts.case,
+        baselineProvider: opts.baselineProvider,
+        d2Import: opts.d2Import,
+        exportBlind: opts.exportBlind,
+        importRatings: opts.importRatings,
+        freezeProtocol: opts.freezeProtocol,
+        publishResults: opts.publishResults,
+        campaign: opts.campaign,
+    }));
 });
 program
     .command('models')

package/dist/cli/resolve.js

@@ -9,12 +9,12 @@ import { createInterface } from 'node:readline';
 import { scoreFindings } from '../orchestration/stages/cr-report.js';
 import { readJsonArtifact, resolveRunId, runDir } from '../storage/runs-read.js';
 import { appendFeedback, buildFeedbackEntries, FeedbackError, parseVerdictFlags, VERDICT_VOCAB } from '../storage/feedback.js';
+import { adaptLegacyDecisionGraph } from '../orchestration/legacy-idea-adapter.js';
 /** Build the annotatable list for an idea-refinement run (adjudicated contradictions). */
-function ideaItems(judge, map) {
+function ideaItems(judge, graph) {
     return judge.adjudications.map((a) => {
-        const c = map?.contradictions.find((x) => x.id === a.id);
-        const dispute = c?.attacks[0]?.argument ?? '';
-        return { id: a.id, ruling: a.ruling, label: `[${a.ruling}] ${dispute || a.reasoning}` };
+        const claim = graph?.claims.find((item) => item.id === a.id);
+        return { id: a.id, ruling: a.ruling, label: `[${a.ruling}] ${claim?.proposition ?? a.reasoning}` };
     });
 }
 /** Build the annotatable list for a code-review run (kept findings from the report). */
@@ -114,8 +114,9 @@ export async function resolve(runArg, opts = {}) {
             process.stdout.write(`  run ${match.runId} has no adjudicated disputes to annotate.\n`);
             return 0;
         }
-        const map = await readJsonArtifact(dir, '07-disagreement-map.json');
-        items = ideaItems(judge, map);
+        const storedGraph = await readJsonArtifact(dir, '07-decision-graph.json');
+        const legacyMap = storedGraph ? null : await readJsonArtifact(dir, '07-disagreement-map.json');
+        items = ideaItems(judge, storedGraph ?? (legacyMap ? adaptLegacyDecisionGraph(legacyMap) : null));
         itemType = 'adjudication';
     }
     if (items.length === 0) {

package/dist/cli/resume.js

@@ -9,6 +9,7 @@ import { resolveRunsRoot } from '../storage/paths.js';
 import { buildReplayCache } from '../storage/replay.js';
 import { findSession } from '../storage/sessions.js';
 import { readJsonArtifact, resolveRunId, runDir } from '../storage/runs-read.js';
+import { EvidencePack } from '../orchestration/evidence-pack.js';
 export async function resumeCommand(runArg, opts = {}) {
     if (!runArg) {
         process.stderr.write('usage: aiki resume <session-id>   (see `aiki sessions`)\n');
@@ -46,6 +47,11 @@ export async function resumeCommand(runArg, opts = {}) {
         }
         workflow = meta.workflow;
     }
+    const previousMeta = await readJsonArtifact(oldDir, 'meta.json');
+    if (!previousMeta) {
+        process.stderr.write(`cannot read meta.json for ${oldId} — nothing to resume.\n`);
+        return 1;
+    }
     // Recover the original input the run was started with.
     const inputFile = workflow === 'code-review' ? 'diff.patch' : 'idea.md';
     let input;
@@ -56,6 +62,16 @@ export async function resumeCommand(runArg, opts = {}) {
         process.stderr.write(`cannot recover the input (inputs/${inputFile}) for ${oldId} — nothing to resume.\n`);
         return 1;
     }
+    let evidencePack;
+    const savedEvidencePack = await readJsonArtifact(oldDir, 'inputs/evidence-pack.json');
+    if (savedEvidencePack) {
+        const parsed = EvidencePack.safeParse(savedEvidencePack);
+        if (!parsed.success) {
+            process.stderr.write(`cannot validate inputs/evidence-pack.json for ${oldId} — nothing to resume.\n`);
+            return 1;
+        }
+        evidencePack = parsed.data;
+    }
     const replay = await buildReplayCache(oldDir);
     if (replay.size === 0) {
         process.stderr.write(`no completed calls found for ${oldId} — start a fresh run instead.\n`);
@@ -74,6 +90,7 @@ export async function resumeCommand(runArg, opts = {}) {
     }
     process.stdout.write(`  resuming ${oldId} (${workflow}) — replaying ${replay.size} completed call(s); only the rest will hit a model.\n`);
     const outcome = await runEngine(workflow, input, {
+        mode: previousMeta.mode,
         budget: cfg.budget,
         deadlineMs: cfg.deadlineMs,
         roleOverrides: cfg.roles,
@@ -82,6 +99,7 @@ export async function resumeCommand(runArg, opts = {}) {
         replay,
         resumedFrom: oldId,
         providerModels: cfg.models,
+        evidencePack,
     });
     if (outcome.ok) {
         process.stdout.write(`\n  ✔ resumed run ${outcome.runId} complete — ${outcome.callCount} new provider call(s)\n  artifacts: ${outcome.dir}\n\n`);