aiki-cli 0.2.1 → 0.3.0

package/dist/orchestration/decision-graph.js

@@ -0,0 +1,256 @@
+import { evaluateCalculation } from './calculations.js';
+export function positionId(provider, localId, sourceId = provider) {
+    return `${sourceId}/${localId}`;
+}
+function classify(positions) {
+    const providers = new Set(positions.map((position) => position.provider));
+    const stances = new Set(positions.map((position) => position.stance));
+    const supporters = positions.filter((position) => position.stance === 'SUPPORT').map((position) => position.provider);
+    const opponents = positions.filter((position) => position.stance === 'OPPOSE').map((position) => position.provider);
+    if (supporters.some((supporter) => opponents.some((opponent) => opponent !== supporter)))
+        return 'DISAGREEMENT';
+    if (stances.has('SUPPORT') && stances.has('OPPOSE'))
+        return 'UNCERTAIN';
+    if (providers.size >= 2 && stances.size === 1 && stances.has('OPPOSE'))
+        return 'SHARED_CONCERN';
+    if (providers.size >= 2 && stances.size === 1 && !stances.has('UNKNOWN'))
+        return 'CONSENSUS';
+    if ([...stances].every((stance) => stance === 'UNKNOWN' || stance === 'MIXED'))
+        return 'UNCERTAIN';
+    if (providers.size === 1)
+        return 'UNIQUE';
+    return 'UNCERTAIN';
+}
+const restrictedClaim = /\b(current|today|latest|now|law|legal|regulat\w*|medic\w*|health\w*|financ\w*|market\w*|prices?|costs?|revenue|fees?|percent(?:age)?)\b|\d/i;
+function needsIndependentEvidence(positions, evidenceById) {
+    const evidence = positions.flatMap((position) => position.evidence_ids
+        .map((id) => evidenceById.get(positionId(position.provider, id, position.source_id)))
+        .filter((item) => item !== undefined));
+    return positions.some((position) => restrictedClaim.test(`${position.dimension_id} ${position.proposition}`))
+        || evidence.some((item) => item.freshness === 'CURRENT');
+}
+function evidenceState(positions, evidenceById) {
+    const requiresIndependent = needsIndependentEvidence(positions, evidenceById);
+    let unresolved = false;
+    for (const position of positions) {
+        const allowed = position.evidence_ids
+            .map((id) => evidenceById.get(positionId(position.provider, id, position.source_id)))
+            .filter((item) => item !== undefined)
+            .filter((item) => !requiresIndependent || item.source_kind !== 'MODEL_KNOWLEDGE');
+        const directions = new Set(allowed.map((item) => item.support));
+        const expected = position.stance === 'SUPPORT' ? 'SUPPORTS' : position.stance === 'OPPOSE' ? 'CONTRADICTS' : undefined;
+        if (!expected || !directions.has(expected))
+            unresolved = true;
+        const opposite = expected === 'SUPPORTS' ? 'CONTRADICTS' : expected === 'CONTRADICTS' ? 'SUPPORTS' : undefined;
+        if (opposite && directions.has(opposite))
+            return 'CONFLICTED';
+    }
+    return unresolved ? 'UNVERIFIED' : 'SUPPORTED';
+}
+const ifFalseRank = { STOP: 0, PIVOT: 1, CONDITION: 2, MINOR: 3 };
+function sensitivity(positions) {
+    if (!positions.some((position) => position.load_bearing))
+        return 'LOW';
+    const consequence = positions.map((position) => position.if_false).sort((a, b) => ifFalseRank[a] - ifFalseRank[b])[0];
+    return consequence === 'STOP' || consequence === 'PIVOT' ? 'DECISIVE' : consequence === 'CONDITION' ? 'MATERIAL' : 'LOW';
+}
+/** Required dimensions without an explicit anchored COVERED or reasoned NOT_APPLICABLE entry. */
+export function coverageHoleQueue(submissions, rubric) {
+    const covered = new Set();
+    for (const { submission } of submissions) {
+        const positions = new Map(submission.positions.map((position) => [position.local_id, position]));
+        for (const entry of submission.coverage) {
+            if (entry.status === 'NOT_APPLICABLE' && entry.rationale?.trim())
+                covered.add(entry.dimension_id);
+            if (entry.status === 'COVERED' && entry.position_ids.some((id) => positions.get(id)?.dimension_id === entry.dimension_id)) {
+                covered.add(entry.dimension_id);
+            }
+        }
+    }
+    return rubric.filter((item) => !covered.has(item.id)).map(({ id, label }) => ({ dimension_id: id, label }));
+}
+/** Compile validated analyst positions into stance-aware claims without rewriting proposition text. */
+export function compileDecisionGraph(submissions, rubric, semanticGroups = []) {
+    const positions = submissions.flatMap(({ provider, source_id = provider, submission }) => submission.positions.map((position) => ({
+        ...position,
+        id: positionId(provider, position.local_id, source_id),
+        provider,
+        source_id,
+    })));
+    const evidence = submissions.flatMap(({ provider, source_id = provider, submission }) => submission.evidence.map((item) => ({
+        ...item,
+        id: positionId(provider, item.id, source_id),
+        provider,
+        source_id,
+    })));
+    const byId = new Map(positions.map((position) => [position.id, position]));
+    const evidenceById = new Map(evidence.map((item) => [item.id, item]));
+    const grouped = new Set();
+    const groups = semanticGroups.flatMap((group) => {
+        const valid = group.filter((id) => byId.has(id) && !grouped.has(id));
+        if (valid.length < 2)
+            return [];
+        valid.forEach((id) => grouped.add(id));
+        return [valid];
+    });
+    for (const position of positions)
+        if (!grouped.has(position.id))
+            groups.push([position.id]);
+    const evidenceHoles = [];
+    let claims = groups.map((ids, index) => {
+        const members = ids.map((id) => byId.get(id));
+        const evidence_state = evidenceState(members, evidenceById);
+        const id = `G${index + 1}`;
+        if (members.some((member) => member.load_bearing) && evidence_state !== 'SUPPORTED') {
+            const reason = evidence_state === 'CONFLICTED'
+                ? 'load-bearing claim has conflicting evidence'
+                : needsIndependentEvidence(members, evidenceById)
+                    ? 'claim requires independently checkable evidence'
+                    : 'load-bearing claim has no settling evidence';
+            evidenceHoles.push({ claim_id: id, reason });
+        }
+        const baseState = classify(members);
+        return {
+            id,
+            proposition: members[0].proposition,
+            position_ids: ids,
+            state: evidence_state === 'UNVERIFIED' || evidence_state === 'CONFLICTED' ? 'UNCERTAIN' : baseState,
+            evidence_state,
+            load_bearing: members.some((member) => member.load_bearing),
+            if_false: members.map((member) => member.if_false).sort((a, b) => ifFalseRank[a] - ifFalseRank[b])[0],
+            sensitivity: sensitivity(members),
+        };
+    });
+    const claimByPosition = new Map(claims.flatMap((claim) => claim.position_ids.map((id) => [id, claim.id])));
+    const calculations = submissions.flatMap(({ provider, source_id = provider, submission }) => (submission.calculations ?? []).flatMap((calculation) => {
+        const claim_id = claimByPosition.get(positionId(provider, calculation.claim_id, source_id));
+        if (!claim_id)
+            return [];
+        return [{
+                ...calculation,
+                id: positionId(provider, calculation.id, source_id),
+                claim_id,
+                inputs: calculation.inputs.map((input) => ({
+                    ...input,
+                    evidence_ids: input.evidence_ids.map((id) => positionId(provider, id, source_id)),
+                })),
+                provider,
+                source_id,
+            }];
+    }));
+    const calculationChecks = calculations.map(evaluateCalculation);
+    const failedCalculationClaims = new Set(calculationChecks.filter((check) => check.status === 'FAIL').map((check) => check.claim_id));
+    for (const claimId of failedCalculationClaims) {
+        const existing = evidenceHoles.find((hole) => hole.claim_id === claimId);
+        if (existing)
+            existing.reason += '; deterministic calculation failed';
+        else
+            evidenceHoles.push({ claim_id: claimId, reason: 'deterministic calculation failed' });
+    }
+    claims = claims.map((claim) => failedCalculationClaims.has(claim.id)
+        ? { ...claim, state: 'UNCERTAIN', evidence_state: 'UNVERIFIED' }
+        : claim);
+    const edges = [];
+    const edgeKeys = new Set();
+    const addEdge = (edge) => {
+        const key = `${edge.from}:${edge.to}:${edge.type}`;
+        if (!edgeKeys.has(key)) {
+            edgeKeys.add(key);
+            edges.push(edge);
+        }
+    };
+    for (const position of positions) {
+        const from = claimByPosition.get(position.id);
+        for (const dependency of position.depends_on) {
+            const to = claimByPosition.get(dependency.includes('/') ? dependency : positionId(position.provider, dependency, position.source_id));
+            if (to && to !== from)
+                addEdge({ from, to, type: 'DEPENDS_ON' });
+        }
+        for (const evidenceId of position.evidence_ids) {
+            const item = evidenceById.get(positionId(position.provider, evidenceId, position.source_id));
+            if (!item)
+                continue;
+            addEdge({ from: item.id, to: from, type: item.support === 'CONTRADICTS' ? 'ATTACKS' : 'SUPPORTS' });
+        }
+    }
+    const coverageHoles = coverageHoleQueue(submissions, rubric);
+    return {
+        positions,
+        evidence,
+        calculations,
+        calculation_checks: calculationChecks,
+        claims,
+        edges,
+        holes: { coverage: coverageHoles, evidence: evidenceHoles },
+    };
+}
+function decisionCritical(claim) {
+    return claim.if_false !== 'MINOR' && claim.sensitivity !== 'LOW';
+}
+/** Select graph nodes that warrant independent verification, ordered by decision value. */
+export function selectEscalations(graph, limits) {
+    const selected = [];
+    const seen = new Set();
+    const add = (claim, reason, kind) => {
+        if (seen.has(claim.id) || selected.length >= limits.max)
+            return;
+        seen.add(claim.id);
+        selected.push({ claim_id: claim.id, reason, kind });
+    };
+    for (const claim of graph.claims) {
+        if (claim.state === 'DISAGREEMENT' && decisionCritical(claim)) {
+            add(claim, 'opposing provider stances', 'DISAGREEMENT');
+        }
+    }
+    for (const claim of graph.claims) {
+        if (claim.load_bearing && decisionCritical(claim) && claim.evidence_state === 'CONFLICTED') {
+            add(claim, 'conflicting evidence on a load-bearing claim', 'EVIDENCE_CONFLICT');
+        }
+    }
+    for (const claim of graph.claims) {
+        if (claim.state === 'UNIQUE' && claim.load_bearing && decisionCritical(claim)) {
+            add(claim, 'load-bearing unique claim', 'INDEPENDENT_CHALLENGE');
+        }
+    }
+    for (const hole of graph.holes.evidence) {
+        const claim = graph.claims.find((item) => item.id === hole.claim_id);
+        if (claim?.load_bearing && decisionCritical(claim)) {
+            add(claim, hole.reason, 'EVIDENCE_HOLE');
+        }
+    }
+    return selected;
+}
+/** R5's stricter queue: only verdict-flipping nodes may spend an optional rebuttal call. */
+export function selectRebuttalEscalations(graph, verifications, limits) {
+    const selected = [];
+    const seen = new Set();
+    const verificationById = new Map(verifications.verifications.map((item) => [item.claim_id, item]));
+    const add = (claim, reason, kind) => {
+        if (seen.has(claim.id) || selected.length >= limits.maxNodes)
+            return;
+        seen.add(claim.id);
+        selected.push({ claim_id: claim.id, reason, kind });
+    };
+    for (const claim of graph.claims) {
+        if (claim.state === 'DISAGREEMENT' && decisionCritical(claim)) {
+            add(claim, 'opposing provider stances on a decision-critical claim', 'DISAGREEMENT');
+        }
+    }
+    for (const claim of graph.claims) {
+        if (claim.load_bearing && decisionCritical(claim) && verificationById.get(claim.id)?.status === 'CONTRADICTED') {
+            add(claim, 'independent verification contradicted a load-bearing claim', 'EVIDENCE_CONFLICT');
+        }
+    }
+    for (const claim of graph.claims) {
+        if (claim.state === 'UNIQUE' && claim.load_bearing && decisionCritical(claim)) {
+            add(claim, 'load-bearing unique claim needs an independent challenge', 'INDEPENDENT_CHALLENGE');
+        }
+    }
+    for (const hole of graph.holes.evidence) {
+        const claim = graph.claims.find((item) => item.id === hole.claim_id);
+        if (claim?.load_bearing && decisionCritical(claim)) {
+            add(claim, `decision-critical evidence hole: ${hole.reason}`, 'EVIDENCE_HOLE');
+        }
+    }
+    return selected;
+}

package/dist/orchestration/engine.js

@@ -50,13 +50,14 @@ export async function executeRun(ctx, input, fn) {
  */
 export async function run(workflow, input, opts = {}) {
     const handles = await setupProviders(opts.providerModels);
-    if (handles.length < 2) {
+    const requiredProviders = workflow === 'idea-refinement' && opts.mode === 'quick' ? 1 : 2;
+    if (handles.length < requiredProviders) {
         return {
             ok: false,
             runId: '(none)',
             dir: '',
             callCount: 0,
-            error: { code: 'QUORUM', message: `need ≥2 providers, found ${handles.length} — run \`aiki doctor\`` },
+            error: { code: 'QUORUM', message: `need ≥${requiredProviders} provider${requiredProviders === 1 ? '' : 's'}, found ${handles.length} — run \`aiki doctor\`` },
         };
     }
     const runId = makeRunId(workflow);
@@ -65,6 +66,7 @@ export async function run(workflow, input, opts = {}) {
     const ctx = new RunCtx({
         runId,
         workflow,
+        mode: opts.mode,
         handles,
         roles,
         writer,
@@ -74,6 +76,7 @@ export async function run(workflow, input, opts = {}) {
         signal: opts.signal,
         events: opts.events,
         replay: opts.replay,
+        evidencePack: opts.evidencePack,
     });
     // Register the session (V6.3) so `aiki sessions`/`resume` can find it from anywhere. run() is a
     // real-CLI entry (setupProviders); tests use executeRun directly and never touch the global registry.

package/dist/orchestration/evidence-pack.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { lstat, readFile, readdir, realpath } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve, sep } from 'node:path';
+import { z } from 'zod';
+export const EvidencePack = z.object({
+    root: z.string().min(1),
+    files: z.array(z.object({
+        path: z.string().min(1),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    }).strict()).min(1),
+}).strict();
+const CREDENTIAL_DIRS = ['.Codex', '.codex', '.gemini', '.antigravity'].map((name) => join(homedir(), name));
+function assertSafePath(path) {
+    if (CREDENTIAL_DIRS.some((dir) => path === dir || path.startsWith(`${dir}${sep}`))) {
+        throw new Error(`refusing evidence path inside credential directory: ${path}`);
+    }
+}
+async function collectFiles(path) {
+    assertSafePath(path);
+    const info = await lstat(path);
+    if (info.isSymbolicLink())
+        throw new Error(`evidence packs do not follow symbolic links: ${path}`);
+    if (info.isFile())
+        return [path];
+    if (!info.isDirectory())
+        return [];
+    const entries = await readdir(path, { withFileTypes: true });
+    const nested = await Promise.all(entries.sort((a, b) => a.name.localeCompare(b.name)).map((entry) => collectFiles(join(path, entry.name))));
+    return nested.flat();
+}
+/** Resolve a user-scoped file/directory into a paths+hashes manifest; file contents are never copied. */
+export async function buildEvidencePack(inputPath) {
+    const requested = resolve(inputPath);
+    assertSafePath(requested); // reject credential paths before even resolving/reading them
+    const root = await realpath(requested);
+    assertSafePath(root);
+    const paths = await collectFiles(root);
+    if (paths.length === 0)
+        throw new Error(`evidence pack contains no regular files: ${root}`);
+    const files = await Promise.all(paths.map(async (path) => ({
+        path,
+        sha256: createHash('sha256').update(await readFile(path)).digest('hex'),
+    })));
+    return EvidencePack.parse({ root, files });
+}

package/dist/orchestration/idea-lanes.js

@@ -0,0 +1,20 @@
+import { loadSkill } from './skills.js';
+export const IDEA_LANES = ['market-adoption', 'economics-delivery'];
+const CORE_OWNERSHIP = {
+    'market-adoption': new Set(['R1', 'R2', 'R3', 'R9', 'R10', 'R13']),
+    'economics-delivery': new Set(['R4', 'R5', 'R6', 'R7', 'R8', 'R11', 'R12']),
+};
+export function buildLanePrompts(basePrompt, rubric) {
+    const domainIds = rubric.filter((item) => item.id.startsWith('D')).map((item) => item.id);
+    const prompt = (lane, domainParity) => {
+        const owned = rubric.filter((item) => {
+            const domainIndex = domainIds.indexOf(item.id);
+            return CORE_OWNERSHIP[lane].has(item.id) || (domainIndex >= 0 && domainIndex % 2 === domainParity);
+        });
+        return `${basePrompt}\n\nLANE: ${lane}\nOWNED DIMENSIONS — include one explicit coverage entry for every item:\n${owned.map((item) => `- ${item.id}: ${item.label}`).join('\n')}\n\n${loadSkill('idea-refinement', lane)}`;
+    };
+    return {
+        'market-adoption': prompt('market-adoption', 0),
+        'economics-delivery': prompt('economics-delivery', 1),
+    };
+}

package/dist/orchestration/jsonStage.js

@@ -6,7 +6,65 @@
 // instruction, exactly once. A second failure → StageError('BAD_OUTPUT'), which the stage turns
 // into its §9 failure handling (S1/S3 abort the run).
 import { StageError } from './context.js';
+/** Generic deterministic shape coercion — the §14 boundary floor for EVERY jsonCall stage.
+ *  Two live failures shaped it (run 20260715-1516): the S9 chair's only defect was `dissent` as a
+ *  string, and the paid repair it triggered flipped the verdict PIVOT→PWC and died on 7 conditions
+ *  vs max 6. Policy:
+ *  - LOSSLESS (always): a lone value where an array is expected becomes a one-element array. Runs
+ *    BEFORE the paid repair — a wrappable-only defect costs zero extra calls.
+ *  - LOSSY (`lossy: true`, last resort after the repair failed): arrays beyond their schema max are
+ *    truncated in order — one extra condition costs one condition, never the run.
+ *  Never invents a value. The full schema still validates the result; anything else stays invalid. */
+export function coerceToSchema(schema, value, lossy) {
+    const def = schema?._def;
+    if (!def)
+        return value;
+    const kind = def.typeName;
+    if (kind === 'ZodOptional' || kind === 'ZodNullable' || kind === 'ZodDefault' || kind === 'ZodReadonly' || kind === 'ZodCatch') {
+        return value === undefined || value === null ? value : coerceToSchema(def.innerType, value, lossy);
+    }
+    if (kind === 'ZodEffects')
+        return coerceToSchema(def.schema, value, lossy); // refine/preprocess wrappers
+    if (kind === 'ZodPipeline')
+        return coerceToSchema(def.in, value, lossy);
+    if (kind === 'ZodArray') {
+        if (value === undefined || value === null)
+            return value;
+        const wrapped = Array.isArray(value) ? value : [value];
+        const max = def.maxLength?.value;
+        const bounded = lossy && typeof max === 'number' && wrapped.length > max ? wrapped.slice(0, max) : wrapped;
+        return bounded.map((item) => coerceToSchema(def.type, item, lossy));
+    }
+    if (kind === 'ZodObject') {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return value;
+        const shape = typeof def.shape === 'function' ? def.shape() : def.shape;
+        const out = { ...value };
+        for (const key of Object.keys(shape)) {
+            if (key in out)
+                out[key] = coerceToSchema(shape[key], out[key], lossy);
+        }
+        return out;
+    }
+    return value;
+}
 export async function jsonCall(ctx, handle, stage, prompt, schema, opts = {}) {
+    // Deterministic last resort once the repair path is spent: stage-specific salvage first, then the
+    // generic lossy floor (truncate over-cap arrays), then both composed. No extra provider call.
+    const trySalvage = (json) => {
+        const candidates = [];
+        if (opts.salvage) {
+            const staged = opts.salvage(json);
+            candidates.push(staged, coerceToSchema(schema, staged, true));
+        }
+        candidates.push(coerceToSchema(schema, json, true));
+        for (const candidate of candidates) {
+            const saved = schema.safeParse(candidate);
+            if (saved.success)
+                return saved.data;
+        }
+        return undefined;
+    };
     const first = await ctx.call(handle, { prompt, expectJson: true, cwd: opts.cwd }, stage);
     if (!first.ok) {
         // AUTH/QUOTA/NOT_FOUND fail fast; TIMEOUT/CRASH/BAD_OUTPUT were already retried once by the adapter.
@@ -15,16 +73,30 @@ export async function jsonCall(ctx, handle, stage, prompt, schema, opts = {}) {
     const parsed = schema.safeParse(first.json);
     if (parsed.success)
         return parsed.data;
+    // Lossless coercion BEFORE the paid repair: a wrappable-only defect never costs a second call
+    // (and never lets the repair rewrite an already-complete answer — run 20260715-1516's verdict flip).
+    const wrapped = schema.safeParse(coerceToSchema(schema, first.json, false));
+    if (wrapped.success)
+        return wrapped.data;
+    if (opts.repair === false) {
+        throw new StageError(stage, 'BAD_OUTPUT', `output failed validation: ${zodMessage(parsed.error)}`);
+    }
     // §14 repair retry — one attempt, same provider.
     const repairPrompt = `${prompt}\n\n---\nYour previous output failed validation:\n${zodMessage(parsed.error)}\n` +
         `Output ONLY the corrected JSON, nothing else.`;
     const second = await ctx.call(handle, { prompt: repairPrompt, expectJson: true, cwd: opts.cwd }, `${stage}-repair`);
     if (!second.ok) {
+        const saved = trySalvage(first.json); // quota can kill the repair call itself; the first output may still salvage
+        if (saved !== undefined)
+            return saved;
         throw new StageError(stage, second.error, `repair retry failed (${second.error})`);
     }
     const reparsed = schema.safeParse(second.json);
     if (reparsed.success)
         return reparsed.data;
+    const saved = trySalvage(second.json) ?? trySalvage(first.json);
+    if (saved !== undefined)
+        return saved;
     throw new StageError(stage, 'BAD_OUTPUT', `output failed validation after repair: ${zodMessage(reparsed.error)}`);
 }
 function zodMessage(err) {

package/dist/orchestration/legacy-idea-adapter.js

@@ -0,0 +1,102 @@
+import { IdeaRoleOutput, LegacyIdeaRoleOutput, } from '../schemas/index.js';
+/** Read old assumption/attack artifacts without treating an assumption or self-attack as a stance. */
+export function adaptIdeaOutput(input) {
+    const current = IdeaRoleOutput.safeParse(input);
+    if (current.success)
+        return current.data;
+    const legacy = LegacyIdeaRoleOutput.parse(input);
+    const positions = legacy.assumptions.map((assumption) => ({
+        local_id: assumption.id,
+        proposition: assumption.statement,
+        dimension_id: 'R12',
+        stance: 'UNKNOWN',
+        basis: 'ASSUMPTION',
+        load_bearing: assumption.load_bearing,
+        if_false: assumption.load_bearing ? 'STOP' : 'MINOR',
+        reasoning: `Legacy ${assumption.type.toLowerCase()} assumption; no stance or evidence was recorded.`,
+        evidence_ids: [],
+        depends_on: [],
+    }));
+    const assumptionIds = new Set(positions.map((position) => position.local_id));
+    const decision_questions = [
+        ...legacy.open_questions.map((question, index) => ({ id: `Q${index + 1}`, question, claim_ids: [] })),
+        ...legacy.attacks.map((attack) => ({
+            id: attack.id,
+            question: attack.argument,
+            claim_ids: assumptionIds.has(attack.target_assumption) ? [attack.target_assumption] : [],
+        })),
+    ];
+    return IdeaRoleOutput.parse({
+        workflow: 'idea-refinement',
+        task_echo: legacy.task_echo,
+        strongest_version: legacy.strongest_version,
+        positions,
+        evidence: [],
+        coverage: positions.length > 0
+            ? [{ dimension_id: 'R12', status: 'COVERED', position_ids: positions.map((position) => position.local_id), rationale: 'Migrated legacy assumptions.' }]
+            : [],
+        decision_questions,
+    });
+}
+/** Convert pre-R2 disagreement artifacts for read-only display/regression compatibility. */
+export function adaptLegacyDecisionGraph(map) {
+    const contradictionByClaim = new Map(map.contradictions.flatMap((item) => item.claim_ids.map((id) => [id, item])));
+    const claims = [...map.consensus, ...map.unique].map((legacy) => {
+        const dispute = contradictionByClaim.get(legacy.id);
+        const supporting = legacy.providers.map((provider) => ({
+            id: `${provider}/${legacy.id}`,
+            provider,
+            source_id: provider,
+            local_id: legacy.id,
+            proposition: legacy.statement,
+            dimension_id: 'R12',
+            stance: 'SUPPORT',
+            basis: 'ASSUMPTION',
+            load_bearing: false,
+            if_false: 'MINOR',
+            reasoning: 'Migrated legacy assumption.',
+            evidence_ids: [],
+            depends_on: [],
+        }));
+        const opposing = (dispute?.attacks ?? []).map((attack, index) => ({
+            id: `${attack.provider}/${dispute.id}-X${index + 1}`,
+            provider: attack.provider,
+            source_id: attack.provider,
+            local_id: `${dispute.id}-X${index + 1}`,
+            proposition: legacy.statement,
+            dimension_id: 'R12',
+            stance: 'OPPOSE',
+            basis: 'ASSUMPTION',
+            load_bearing: false,
+            if_false: 'MINOR',
+            reasoning: attack.argument,
+            evidence_ids: [],
+            depends_on: [],
+        }));
+        return {
+            claim: {
+                id: dispute?.id ?? legacy.id,
+                proposition: legacy.statement,
+                position_ids: [...supporting, ...opposing].map((position) => position.id),
+                state: dispute ? 'DISAGREEMENT' : legacy.providers.length >= 2 ? 'CONSENSUS' : 'UNIQUE',
+                evidence_state: 'UNVERIFIED',
+                load_bearing: false,
+                if_false: 'MINOR',
+                sensitivity: 'LOW',
+            },
+            positions: [...supporting, ...opposing],
+        };
+    });
+    return {
+        positions: claims.flatMap((item) => item.positions),
+        evidence: [],
+        calculations: [],
+        calculation_checks: [],
+        claims: claims.map((item) => item.claim),
+        edges: [],
+        holes: {
+            coverage: map.blind_spots.map((label) => ({ dimension_id: label, label })),
+            evidence: [],
+        },
+    };
+}

package/dist/orchestration/modes.js

@@ -0,0 +1,33 @@
+const MINUTE = 60 * 1000;
+/** Nominal calls exclude schema repairs; the adaptive default leaves a small repair cushion.
+ *  `deadlineMs` is the wall-clock outer bound — research gets more headroom because it does 2-3× the
+ *  work (repairs + coverage-fill + verify + rebuttal + chair + planner). The per-call timeout (900s)
+ *  stays the real runaway guard; this only bounds the SUM. 45 min matches the bench's proven ceiling
+ *  for a hard research case (run 20260715-1404 died at S9 on the flat 20-min cap after valid work). */
+export const IDEA_MODE_PLANS = {
+    quick: { baseCalls: 3, optionalCalls: 0, maxCalls: 3, reservedCalls: 0, defaultBudget: 4, deadlineMs: 20 * MINUTE },
+    council: { baseCalls: 6, optionalCalls: 2, maxCalls: 8, reservedCalls: 2, defaultBudget: 10, deadlineMs: 20 * MINUTE },
+    research: { baseCalls: 6, optionalCalls: 4, maxCalls: 10, reservedCalls: 2, defaultBudget: 12, deadlineMs: 45 * MINUTE },
+};
+export const LEGACY_DEFAULT_BUDGET = 18;
+export const LEGACY_DEADLINE_MS = 20 * MINUTE;
+export function defaultBudgetFor(workflow, mode = 'council') {
+    return workflow === 'idea-refinement' ? IDEA_MODE_PLANS[mode].defaultBudget : LEGACY_DEFAULT_BUDGET;
+}
+/** Mode-aware wall-clock default, mirroring defaultBudgetFor. Code-review keeps the legacy 20-min cap. */
+export function defaultDeadlineFor(workflow, mode = 'council') {
+    return workflow === 'idea-refinement' ? IDEA_MODE_PLANS[mode].deadlineMs : LEGACY_DEADLINE_MS;
+}
+export function callCategory(stage) {
+    if (stage.toLowerCase().includes('repair'))
+        return 'repair';
+    if (stage.startsWith('S9b'))
+        return 'planning';
+    if (stage.startsWith('S8') || stage === 'S9' || stage.startsWith('S9-'))
+        return 'verification';
+    return 'discovery';
+}
+/** Logical optional work. Replayed attempts still count so resume cannot widen the protocol. */
+export function isOptionalStage(stage) {
+    return stage === 'S7-coverage-fill' || stage === 'S8' || stage.startsWith('S8b-');
+}