aiki-cli 0.2.1 → 0.3.0

package/dist/schemas/index.js

@@ -17,6 +17,15 @@ export const ProviderIdSchema = z.enum(['claude', 'codex', 'agy']);
 export const TaskTypeSchema = z.enum(['idea-refinement', 'code-review', 'other']);
 /** The two runnable v1 workflows (§12). Discriminates RoleOutput and tags RunMeta. */
 export const WorkflowIdSchema = z.enum(['idea-refinement', 'code-review']);
+/** Explicit user-selected idea protocol. There is deliberately no learned mode router. */
+export const IdeaModeSchema = z.enum(['quick', 'council', 'research']);
+export const DomainDimension = z
+    .object({
+    id: z.string().regex(/^D[1-5]$/),
+    label: z.string().min(1),
+    rationale: z.string().min(1),
+})
+    .strict();
 // ── S1: IntentContract (§13) ────────────────────────────────────────────────
 export const IntentContract = z
     .object({
@@ -25,8 +34,21 @@ export const IntentContract = z
     constraints: z.array(z.string()), // explicit constraints the user stated (may be empty)
     unknowns: z.array(z.string()), // things the request leaves unspecified
     success_criteria: z.array(z.string()), // what a good final output must contain
+    domain_dimensions: z.array(DomainDimension).min(3).max(5).optional(), // required by the idea preflight; optional for old/code-review contracts
 })
     .strict();
+/** R6 decision contract: the two-view preflight's single downstream boundary. */
+export const DecisionContract = IntentContract.extend({
+    alternatives: z.array(z.string().min(1)).max(8),
+    success_bar: z.string().min(1),
+    evidence_supplied: z.array(z.string().min(1)).max(12),
+    missing_evidence: z.array(z.string().min(1)).max(12),
+    core_rubric: z.array(z.string().min(1)).min(1),
+    user_confirmed: z.boolean(),
+    confirmation: z.enum(['user-confirmed', 'headless-defaulted']),
+}).strict();
+/** Code review and old idea runs keep the smaller v1 contract. */
+export const DecisionContractArtifact = z.union([DecisionContract, IntentContract]);
 // ── S2: Interpretation — per provider (§13) ─────────────────────────────────
 export const Interpretation = z
     .object({
@@ -65,6 +87,7 @@ const RunBriefDraftBase = z
     claims_to_test: z.array(z.string().min(1)).max(8),
     evidence_supplied: z.array(z.string().min(1)).max(8),
     missing_axes: z.array(z.string().min(1)).max(8),
+    domain_dimensions: z.array(DomainDimension).min(3).max(5),
     questions: z.array(RunBriefQuestion).min(3).max(4),
 })
     .strict();
@@ -77,7 +100,19 @@ function checkQuestionIds(questions, ctx) {
         seen.add(q.id);
     }
 }
-export const RunBriefDraft = RunBriefDraftBase.superRefine((brief, ctx) => checkQuestionIds(brief.questions, ctx));
+function checkDomainDimensionIds(dimensions, ctx) {
+    const seen = new Set();
+    for (const dimension of dimensions) {
+        if (seen.has(dimension.id)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['domain_dimensions'], message: `duplicate domain dimension id: ${dimension.id}` });
+        }
+        seen.add(dimension.id);
+    }
+}
+export const RunBriefDraft = RunBriefDraftBase.superRefine((brief, ctx) => {
+    checkQuestionIds(brief.questions, ctx);
+    checkDomainDimensionIds(brief.domain_dimensions, ctx);
+});
 export const GrillAnswer = z
     .object({
     question_id: z.string().min(1),
@@ -89,6 +124,7 @@ export const RunBrief = RunBriefDraftBase.extend({
     answers: z.array(GrillAnswer).min(3).max(4),
 }).superRefine((brief, ctx) => {
     checkQuestionIds(brief.questions, ctx);
+    checkDomainDimensionIds(brief.domain_dimensions, ctx);
     const questionIds = new Set(brief.questions.map((q) => q.id));
     const answerIds = new Set();
     for (const answer of brief.answers) {
@@ -106,6 +142,34 @@ export const RunBrief = RunBriefDraftBase.extend({
         }
     }
 });
+/** One of the two independent R6 preflight readings. */
+export const PreflightReading = z.object({
+    subject: z.string().min(1),
+    interpretation: z.string().min(1),
+    normalized_decision: z.string().min(1),
+    alternatives: z.array(z.string().min(1)).max(8),
+    target_user: z.string().min(1).nullable(),
+    constraints: z.array(z.string().min(1)).max(10),
+    success_bar: z.string().min(1),
+    success_criteria: z.array(z.string().min(1)).max(8),
+    claims_to_test: z.array(z.string().min(1)).max(8),
+    evidence_supplied: z.array(z.string().min(1)).max(8),
+    missing_evidence: z.array(z.string().min(1)).max(8),
+    domain_dimensions: z.array(DomainDimension).min(3).max(5),
+    questions: z.array(RunBriefQuestion).min(3).max(4),
+}).strict().superRefine((reading, ctx) => {
+    checkQuestionIds(reading.questions, ctx);
+    checkDomainDimensionIds(reading.domain_dimensions, ctx);
+});
+export const PreflightArtifact = z.object({
+    readings: z.array(z.object({ provider: ProviderIdSchema, reading: PreflightReading }).strict()).min(1).max(2),
+    clusters: z.array(z.object({ members: z.array(z.string()), representative: z.string().min(1) }).strict()),
+    chosen: z.object({
+        interpretation: z.string().min(1),
+        how: z.enum(['single-cluster', 'majority-cluster', 'user-selected', 'user-combined', 'user-typed']),
+    }).strict(),
+    dropped: z.array(z.object({ provider: ProviderIdSchema, error: z.string().min(1) }).strict()),
+}).strict();
 // ── S4: RoleOutput — workflow-discriminated union (§12, §13) ─────────────────
 //
 // The model output (§13) does NOT carry a `workflow` field; the engine injects the discriminator
@@ -126,7 +190,7 @@ const Attack = z
     severity: z.enum(['HIGH', 'MED', 'LOW']),
 })
     .strict();
-export const IdeaRoleOutput = z
+export const LegacyIdeaRoleOutput = z
     .object({
     workflow: z.literal('idea-refinement'),
     task_echo: z.string().min(1), // ≤2 sentence restatement (drift check, S5)
@@ -136,6 +200,174 @@ export const IdeaRoleOutput = z
     open_questions: z.array(z.string()).max(5),
 })
     .strict();
+export const ClaimPosition = z
+    .object({
+    local_id: z.string().min(1),
+    proposition: z.string().min(1),
+    dimension_id: z.string().min(1),
+    stance: z.enum(['SUPPORT', 'OPPOSE', 'MIXED', 'UNKNOWN']),
+    basis: z.enum(['EVIDENCE', 'INFERENCE', 'ASSUMPTION']),
+    load_bearing: z.boolean(),
+    if_false: z.enum(['STOP', 'PIVOT', 'CONDITION', 'MINOR']),
+    reasoning: z.string().min(1),
+    evidence_ids: z.array(z.string().min(1)),
+    depends_on: z.array(z.string().min(1)),
+})
+    .strict();
+const EvidenceCardBase = z
+    .object({
+    id: z.string().min(1),
+    claim_supported: z.string().min(1),
+    source_kind: z.enum(['USER', 'PRIMARY', 'SECONDARY', 'MODEL_KNOWLEDGE']),
+    title: z.string().min(1).optional(),
+    url: z.string().url().optional(),
+    published_at: z.string().min(1).optional(),
+    accessed_at: z.string().min(1).optional(),
+    locator: z.string().min(1).optional(),
+    support: z.enum(['SUPPORTS', 'CONTRADICTS', 'CONTEXT_ONLY']),
+    freshness: z.enum(['CURRENT', 'DATED', 'UNKNOWN']),
+})
+    .strict();
+function checkEvidenceCard(card, ctx) {
+    const external = card.source_kind === 'PRIMARY' || card.source_kind === 'SECONDARY';
+    if (external && !card.url && !card.locator) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['locator'], message: `${card.source_kind} evidence requires a URL or locator` });
+    }
+    if (external && card.freshness === 'CURRENT' && !card.accessed_at) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['accessed_at'], message: 'current external evidence requires accessed_at' });
+    }
+    if (card.source_kind === 'MODEL_KNOWLEDGE' && card.freshness === 'CURRENT') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['freshness'], message: 'model knowledge cannot claim current freshness' });
+    }
+}
+export const EvidenceCard = EvidenceCardBase.superRefine(checkEvidenceCard);
+export const CalculationInput = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    value: z.number().finite(),
+    unit: z.string().min(1),
+    evidence_ids: z.array(z.string().min(1)).min(1),
+}).strict();
+export const CalculationStep = z.object({
+    id: z.string().min(1),
+    operation: z.enum(['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE']),
+    left: z.string().min(1),
+    right: z.string().min(1),
+    result: z.number().finite(),
+    unit: z.string().min(1),
+}).strict();
+export const CalculationLedger = z.object({
+    id: z.string().min(1),
+    claim_id: z.string().min(1),
+    inputs: z.array(CalculationInput).min(1).max(12),
+    steps: z.array(CalculationStep).min(1).max(12),
+    result_step: z.string().min(1),
+}).strict();
+// Live 20260714-2142 killed both seats on shape ceremony the prompt never promised: rationale on
+// COVERED entries and a question id have no consumer, so the schema now matches the documented
+// either/or shape (NOT_APPLICABLE still requires its rationale).
+const CoverageEntryBase = z
+    .object({
+    dimension_id: z.string().min(1),
+    status: z.enum(['COVERED', 'NOT_APPLICABLE']),
+    position_ids: z.array(z.string().min(1)).default([]),
+    rationale: z.string().min(1).optional(),
+})
+    .strict();
+function checkCoverageEntry(entry, ctx) {
+    if (entry.status === 'NOT_APPLICABLE' && !entry.rationale) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['rationale'], message: 'NOT_APPLICABLE coverage requires a rationale' });
+    }
+}
+export const CoverageEntry = CoverageEntryBase.superRefine(checkCoverageEntry);
+export const DecisionQuestion = z
+    .object({
+    id: z.string().min(1).optional(),
+    question: z.string().min(1),
+    claim_ids: z.array(z.string().min(1)),
+})
+    .strict();
+const IdeaRoleOutputBase = z
+    .object({
+    workflow: z.literal('idea-refinement'),
+    task_echo: z.string().min(1),
+    strongest_version: z.string().min(1),
+    positions: z.array(ClaimPosition).max(12),
+    evidence: z.array(EvidenceCard).max(20),
+    calculations: z.array(CalculationLedger).max(8).default([]),
+    coverage: z.array(CoverageEntry).max(18), // 13 core + up to 5 preflight domain dimensions
+    decision_questions: z.array(DecisionQuestion).max(8),
+})
+    .strict();
+function checkSubmissionRefs(submission, ctx) {
+    const positionIds = new Set();
+    for (const [index, position] of submission.positions.entries()) {
+        if (positionIds.has(position.local_id))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['positions', index, 'local_id'], message: `duplicate position id: ${position.local_id}` });
+        positionIds.add(position.local_id);
+    }
+    const evidenceIds = new Set();
+    for (const [index, evidence] of submission.evidence.entries()) {
+        if (evidenceIds.has(evidence.id))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['evidence', index, 'id'], message: `duplicate evidence id: ${evidence.id}` });
+        evidenceIds.add(evidence.id);
+    }
+    const calculationIds = new Set();
+    for (const [index, calculation] of submission.calculations.entries()) {
+        if (calculationIds.has(calculation.id))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['calculations', index, 'id'], message: `duplicate calculation id: ${calculation.id}` });
+        calculationIds.add(calculation.id);
+        if (!positionIds.has(calculation.claim_id))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['calculations', index, 'claim_id'], message: `unknown position id: ${calculation.claim_id}` });
+        const refs = new Set(calculation.inputs.map((input) => input.id));
+        const inputIds = new Set();
+        const stepIds = new Set();
+        for (const [inputIndex, input] of calculation.inputs.entries()) {
+            if (inputIds.has(input.id))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['calculations', index, 'inputs', inputIndex, 'id'], message: `duplicate calculation input: ${input.id}` });
+            inputIds.add(input.id);
+            for (const evidenceId of input.evidence_ids) {
+                if (!evidenceIds.has(evidenceId))
+                    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['calculations', index, 'inputs', inputIndex, 'evidence_ids'], message: `unknown evidence id: ${evidenceId}` });
+            }
+        }
+        for (const [stepIndex, step] of calculation.steps.entries()) {
+            if (!refs.has(step.left))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['calculations', index, 'steps', stepIndex, 'left'], message: `unknown or forward calculation reference: ${step.left}` });
+            if (!refs.has(step.right))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['calculations', index, 'steps', stepIndex, 'right'], message: `unknown or forward calculation reference: ${step.right}` });
+            if (refs.has(step.id))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['calculations', index, 'steps', stepIndex, 'id'], message: `duplicate calculation reference: ${step.id}` });
+            refs.add(step.id);
+            stepIds.add(step.id);
+        }
+        if (!stepIds.has(calculation.result_step))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['calculations', index, 'result_step'], message: `unknown result step: ${calculation.result_step}` });
+    }
+    for (const [index, position] of submission.positions.entries()) {
+        for (const id of position.evidence_ids) {
+            if (!evidenceIds.has(id))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['positions', index, 'evidence_ids'], message: `unknown evidence id: ${id}` });
+        }
+        for (const id of position.depends_on) {
+            if (!positionIds.has(id))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['positions', index, 'depends_on'], message: `unknown position id: ${id}` });
+        }
+    }
+    for (const [index, entry] of submission.coverage.entries()) {
+        for (const id of entry.position_ids) {
+            if (!positionIds.has(id))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['coverage', index, 'position_ids'], message: `unknown position id: ${id}` });
+        }
+    }
+    for (const [index, question] of submission.decision_questions.entries()) {
+        for (const id of question.claim_ids) {
+            if (!positionIds.has(id))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['decision_questions', index, 'claim_ids'], message: `unknown position id: ${id}` });
+        }
+    }
+}
+export const IdeaRoleOutput = IdeaRoleOutputBase.superRefine(checkSubmissionRefs);
 /** Defect categories a finding (and a seeded bug, T11) can carry. BENCHMARK.md's "defect class" match
  *  is equality on this enum (off-by-one→CORRECTNESS, race→CONCURRENCY, unhandled-rejection→ERROR_HANDLING,
  *  auth-gap→SECURITY, N+1→PERF). */
@@ -161,16 +393,123 @@ export const CodeReviewRoleOutput = z
     findings: z.array(Finding).max(12),
 })
     .strict();
-export const RoleOutput = z.discriminatedUnion('workflow', [IdeaRoleOutput, CodeReviewRoleOutput]);
+export const RoleOutput = z.union([IdeaRoleOutput, CodeReviewRoleOutput]);
 /** The exact JSON a code-review S4 reviewer returns: `CodeReviewRoleOutput` WITHOUT the `workflow`
  *  discriminator (§13 — model output carries no `workflow`). Mirrors `IdeaRoleOutputModel` (T6); S4
  *  validates the raw call against this, injects `workflow`, then persists as `RoleOutput` (T10). */
 export const CodeReviewRoleOutputModel = CodeReviewRoleOutput.omit({ workflow: true });
-/** The exact JSON the model returns for an idea-refinement S4 seat: `IdeaRoleOutput` WITHOUT the
- *  `workflow` discriminator (§13 — model output carries no `workflow`). S4 validates the raw call
- *  against this, then injects `workflow` and re-validates as `RoleOutput` before persisting.
- *  `.omit` preserves the object's strict mode, so extra keys still trigger the §14 repair retry. */
-export const IdeaRoleOutputModel = IdeaRoleOutput.omit({ workflow: true });
+const StrictIdeaRoleOutputModel = IdeaRoleOutputBase.omit({ workflow: true }).superRefine((submission, ctx) => checkSubmissionRefs({ workflow: 'idea-refinement', ...submission }, ctx));
+/** Case-insensitive match to an exact canonical enum word (plus known aliases); prose never matches. */
+function canonicalEnum(value, canon, aliases = {}) {
+    if (typeof value !== 'string')
+        return value;
+    const upper = value.toUpperCase();
+    const mapped = aliases[upper] ?? upper;
+    return canon.includes(mapped) ? mapped : value;
+}
+/** Match a leading canonical/alias token with trailing prose ("OPPOSES: <reason>"), the observed
+ *  20260714-2142 codex vocabulary. The FIRST word must itself be the token; free prose whose first
+ *  word is not a known token still never matches. */
+function canonicalEnumLeadingToken(value, canon, aliases = {}) {
+    if (typeof value !== 'string')
+        return value;
+    const token = value.trim().match(/^[A-Za-z_]+/)?.[0]?.toUpperCase();
+    if (!token)
+        return value;
+    const mapped = aliases[token] ?? token;
+    return canon.includes(mapped) ? mapped : value;
+}
+/** Canonicalize enum spellings observed in live provider repairs (SUPPORT, current, Current);
+ *  anything that is not the exact word in some casing stays invalid. */
+function canonicalizeIdeaRoleOutputModel(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return input;
+    const output = input;
+    if (!Array.isArray(output.evidence))
+        return input;
+    return {
+        ...output,
+        evidence: output.evidence.map((item) => {
+            if (!item || typeof item !== 'object' || Array.isArray(item))
+                return item;
+            const evidence = item;
+            return {
+                ...evidence,
+                support: canonicalEnumLeadingToken(evidence.support, ['SUPPORTS', 'CONTRADICTS', 'CONTEXT_ONLY'], { SUPPORT: 'SUPPORTS', OPPOSES: 'CONTRADICTS', OPPOSE: 'CONTRADICTS' }),
+                freshness: canonicalEnum(evidence.freshness, ['CURRENT', 'DATED', 'UNKNOWN']),
+            };
+        }),
+    };
+}
+/** Deterministic last resort after a failed §14 repair. Three live failures shaped it:
+ *  run 20260712-0011 wrote evidence prose into `support`; run 20260713-1503 added an unknown `content`
+ *  key to every card and leaked `MODEL_KNOWLEDGE` into a position's `basis`; run 20260714-2142 killed
+ *  BOTH seats via an over-cap calculation ledger and coverage/question entries the old salvage never
+ *  touched. Policy, strictly deterministic (never invents a value):
+ *  - unknown extra keys are stripped (zod `.strip()` re-parse);
+ *  - an evidence card that still fails is dropped, and its id scrubbed from positions;
+ *  - a position that still fails is dropped, and its id scrubbed from depends_on / coverage /
+ *    decision_questions — one bad position costs one position, not the whole seat;
+ *  - a calculation that still fails, or whose position/evidence anchors were dropped, is dropped;
+ *    the survivors are truncated to the schema cap in order (one bad ledger costs one ledger);
+ *  - a coverage entry or decision question that still fails is dropped (a dropped coverage entry
+ *    becomes a visible structural hole downstream, never a dead seat);
+ *  - a seat with NO surviving position stays a hard failure (nothing to analyze). */
+export function salvageIdeaRoleOutputModel(input) {
+    const canonical = canonicalizeIdeaRoleOutputModel(input);
+    if (!canonical || typeof canonical !== 'object' || Array.isArray(canonical))
+        return canonical;
+    const output = canonical;
+    if (!Array.isArray(output.evidence) || !Array.isArray(output.positions))
+        return canonical;
+    const evidence = output.evidence
+        .map((item) => EvidenceCardBase.strip().superRefine(checkEvidenceCard).safeParse(item))
+        .flatMap((result) => (result.success ? [result.data] : []));
+    const keptEvidence = new Set(evidence.map((card) => card.id));
+    const parsedPositions = output.positions
+        .map((item) => ClaimPosition.strip().safeParse(item))
+        .flatMap((result) => (result.success ? [result.data] : []));
+    if (parsedPositions.length === 0)
+        return canonical; // empty claim set → let strict validation fail it
+    const keptPositions = new Set(parsedPositions.map((position) => position.local_id));
+    const positions = parsedPositions.map((position) => ({
+        ...position,
+        evidence_ids: position.evidence_ids.filter((id) => keptEvidence.has(id)),
+        depends_on: position.depends_on.filter((id) => keptPositions.has(id)),
+    }));
+    const scrubIds = (value, key) => {
+        if (!Array.isArray(value))
+            return value;
+        return value.map((item) => {
+            if (!item || typeof item !== 'object' || Array.isArray(item))
+                return item;
+            const entry = item;
+            if (!Array.isArray(entry[key]))
+                return item;
+            return { ...entry, [key]: entry[key].filter((id) => keptPositions.has(id)) };
+        });
+    };
+    const parseOrDrop = (value, parse) => Array.isArray(value)
+        ? value.map((item) => parse(item)).flatMap((result) => (result.success ? [result.data] : []))
+        : value;
+    const calculations = Array.isArray(output.calculations)
+        ? parseOrDrop(output.calculations, (item) => CalculationLedger.strip().safeParse(item))
+            .filter((calc) => keptPositions.has(calc.claim_id)
+            && calc.inputs.every((input) => input.evidence_ids.every((id) => keptEvidence.has(id))))
+            .slice(0, 8)
+        : output.calculations;
+    return {
+        ...output,
+        evidence,
+        positions,
+        calculations,
+        coverage: parseOrDrop(scrubIds(output.coverage, 'position_ids'), (item) => CoverageEntryBase.strip().superRefine(checkCoverageEntry).safeParse(item)),
+        decision_questions: parseOrDrop(scrubIds(output.decision_questions, 'claim_ids'), (item) => DecisionQuestion.strip().safeParse(item)),
+    };
+}
+/** The model-facing S4 shape. Exact known enum aliases are canonicalized, then the strict schema validates
+ *  the full output; persisted `IdeaRoleOutput` remains canonical-only. */
+export const IdeaRoleOutputModel = z.preprocess(canonicalizeIdeaRoleOutputModel, StrictIdeaRoleOutputModel);
 // ── S3: StagePrompts (§9, §13) ──────────────────────────────────────────────
 //
 // S3 output: the role-specific S4 prompts with every {{SLOT}} filled. Deterministic validator
@@ -191,10 +530,59 @@ export const ClaimGroups = z
     groups: z.array(z.array(z.string().min(1)).min(2)),
 })
     .strict();
+// ── R2: typed decision graph ────────────────────────────────────────────────
+const GraphPosition = ClaimPosition.extend({
+    id: z.string().min(1),
+    provider: ProviderIdSchema,
+    source_id: z.string().min(1),
+});
+const GraphEvidence = EvidenceCardBase.extend({
+    id: z.string().min(1),
+    provider: ProviderIdSchema,
+    source_id: z.string().min(1),
+}).superRefine(checkEvidenceCard);
+const GraphCalculation = CalculationLedger.extend({
+    id: z.string().min(1),
+    claim_id: z.string().min(1),
+    provider: ProviderIdSchema,
+    source_id: z.string().min(1),
+});
+export const CalculationCheck = z.object({
+    calculation_id: z.string().min(1),
+    claim_id: z.string().min(1),
+    status: z.enum(['PASS', 'FAIL']),
+    issues: z.array(z.string()),
+}).strict();
+export const DecisionClaim = z.object({
+    id: z.string().min(1),
+    proposition: z.string().min(1),
+    position_ids: z.array(z.string().min(1)).min(1),
+    state: z.enum(['CONSENSUS', 'SHARED_CONCERN', 'DISAGREEMENT', 'UNIQUE', 'UNCERTAIN']),
+    evidence_state: z.enum(['SUPPORTED', 'CONFLICTED', 'UNVERIFIED']),
+    load_bearing: z.boolean(),
+    if_false: z.enum(['STOP', 'PIVOT', 'CONDITION', 'MINOR']),
+    sensitivity: z.enum(['DECISIVE', 'MATERIAL', 'LOW']),
+});
+export const DecisionGraph = z.object({
+    positions: z.array(GraphPosition),
+    evidence: z.array(GraphEvidence),
+    calculations: z.array(GraphCalculation).default([]),
+    calculation_checks: z.array(CalculationCheck).default([]),
+    claims: z.array(DecisionClaim),
+    edges: z.array(z.object({
+        from: z.string().min(1),
+        to: z.string().min(1),
+        type: z.enum(['DEPENDS_ON', 'SUPPORTS', 'ATTACKS', 'CONTRADICTS']),
+    })),
+    holes: z.object({
+        coverage: z.array(z.object({ dimension_id: z.string().min(1), label: z.string().min(1) })),
+        evidence: z.array(z.object({ claim_id: z.string().min(1), reason: z.string().min(1) })),
+    }),
+});
 // ── S8: Verification (§13) ──────────────────────────────────────────────────
 //
 // `Verification` is the per-item verdict (§9 "per-item Verification"). `VerificationSet` is the
-// actual S8 stage output: the array plus the mandatory justification when zero REFUTEs (§13).
+// actual S8 stage output. Each item is judged independently; no verdict distribution is required.
 export const Verification = z
     .object({
     target_id: z.string().min(1),
@@ -206,10 +594,65 @@ export const Verification = z
 export const VerificationSet = z
     .object({
     verifications: z.array(Verification),
-    // Required by the S8 prompt only when the verifier issued zero REFUTEs (§13).
+    // Accepted for backward compatibility with pre-R1 artifacts; the R1 prompt no longer requests it.
     all_confirmed_justification: z.string().optional(),
 })
     .strict();
+export const ClaimVerification = z.object({
+    claim_id: z.string().min(1),
+    status: z.enum(['VERIFIED', 'PARTIAL', 'CONTRADICTED', 'UNVERIFIABLE']),
+    reasoning: z.string().min(1),
+    evidence_ids: z.array(z.string().min(1)),
+    calculation_check: z.enum(['PASS', 'FAIL', 'NOT_APPLICABLE']).optional(),
+    missing_evidence: z.array(z.string().min(1)),
+}).strict();
+export const ClaimVerificationSet = z.object({
+    verifications: z.array(ClaimVerification),
+}).strict();
+// ── R5: bounded, append-only rebuttal events ───────────────────────────────
+const RebuttalResponseBase = z.object({
+    claim_id: z.string().min(1),
+    response: z.enum(['CONCEDE', 'COUNTER', 'NARROW', 'UNRESOLVED']),
+    reasoning: z.string().min(1),
+    evidence_ids: z.array(z.string().min(1)),
+    narrowed_proposition: z.string().min(1).optional(),
+}).strict();
+const checkNarrowedRebuttal = (event, ctx) => {
+    if (event.response === 'NARROW' && !event.narrowed_proposition) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['narrowed_proposition'],
+            message: 'NARROW requires narrowed_proposition',
+        });
+    }
+};
+export const RebuttalResponse = RebuttalResponseBase.superRefine(checkNarrowedRebuttal);
+/** Exact model output for one scout's single rebuttal round. */
+export const RebuttalResponseSet = z.object({
+    events: z.array(RebuttalResponse).max(3),
+}).strict();
+export const RebuttalEvent = RebuttalResponseBase.extend({
+    id: z.string().min(1),
+    round: z.literal(1),
+    responder: ProviderIdSchema,
+    target_position_ids: z.array(z.string().min(1)),
+}).superRefine(checkNarrowedRebuttal);
+/** Persisted separately from DecisionGraph so original claims/evidence remain immutable. */
+export const RebuttalEventSet = z.object({
+    round: z.literal(1),
+    selected_claim_ids: z.array(z.string().min(1)).max(3),
+    events: z.array(RebuttalEvent).max(6),
+    stop_reason: z.enum([
+        'NO_ESCALATIONS',
+        'NO_ELIGIBLE_SCOUT',
+        'BUDGET_RESERVED',
+        'ROUND_COMPLETE',
+        'NO_NEW_EVIDENCE',
+        'CALL_CAP_REACHED',
+    ]),
+}).strict();
+/** Shared artifact slot: code review keeps the v1 cross-exam shape; idea refinement uses R4 claims. */
+export const VerificationArtifact = z.union([VerificationSet, ClaimVerificationSet]);
 // ── S7: DisagreementMap (§7, §9) ────────────────────────────────────────────
 //
 // The plan (§7/§9) names only the four arrays. `Claim` shape is from §6. NOTE two under-specified
@@ -280,16 +723,69 @@ const Adjudication = z
     id: z.string().min(1), // disputed item id
     ruling: z.enum(['UPHOLD', 'REJECT', 'UNRESOLVED']),
     reasoning: z.string().min(1), // ≤3 sentences
-    evidence_cited: z.string().min(1),
+    evidence_cited: z.string().min(1).optional(), // code-review / legacy idea artifacts
+    evidence_ids: z.array(z.string().min(1)).optional(), // R4 idea chair citations, validated by reference
+    effect_on_decision: z.string().min(1).optional(), // R5 idea chair; optional for legacy/code-review artifacts
+    what_would_change_it: z.string().min(1).optional(), // required by S9 when an idea ruling is UNRESOLVED
 })
-    .strict();
+    .strict()
+    .refine((item) => item.evidence_cited || item.evidence_ids?.length, { message: 'adjudication requires evidence' });
 export const Recommendation = z.enum(['PROCEED', 'PROCEED_WITH_CONDITIONS', 'PIVOT', 'STOP']);
+const DecisionSnapshotItem = z.object({
+    label: z.string().min(1),
+    value: z.string().min(1),
+    meaning: z.string().min(1),
+    claim_ids: z.array(z.string().min(1)).min(1).max(4),
+}).strict();
+const DecisionOption = z.object({
+    label: z.string().min(1),
+    commitment: z.string().min(1),
+    commitment_kind: z.enum(['KNOWN', 'TARGET_CAP', 'UNKNOWN']),
+    tradeoff: z.string().min(1),
+    claim_ids: z.array(z.string().min(1)).max(4),
+}).strict().superRefine((option, ctx) => {
+    if (option.commitment_kind !== 'UNKNOWN' && option.claim_ids.length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['claim_ids'],
+            message: 'known commitments and target caps require a graph claim anchor',
+        });
+    }
+});
+/** Reader-first, graph-anchored numeric comparison for decision tasks where amounts or thresholds matter. */
+export const DecisionSnapshot = z.object({
+    decisive_numbers: z.array(DecisionSnapshotItem).min(1).max(5),
+    payback: z.object({
+        status: z.enum(['ACHIEVED', 'NOT_ACHIEVED', 'NOT_COMPUTABLE']),
+        result: z.string().min(1),
+        basis: z.string().min(1),
+        claim_ids: z.array(z.string().min(1)).min(1).max(4),
+    }).strict().optional(),
+    options: z.array(DecisionOption).min(2).max(4),
+    tripwire: z.object({
+        metric: z.string().min(1),
+        threshold: z.string().min(1),
+        decision_rule: z.string().min(1),
+        claim_ids: z.array(z.string().min(1)).min(1).max(4),
+    }).strict().optional(),
+}).strict();
 const JudgeReportBase = z
     .object({
     adjudications: z.array(Adjudication),
     verdict: z.string().min(1), // the recommendation + core reason (idea: 2-5 sentences; grounded in adjudicated + consensus claims)
     recommendation: Recommendation.optional(), // idea workflow; code-review omits it
     conditions: z.array(z.string().min(1)).max(6).optional(), // present only for PROCEED_WITH_CONDITIONS
+    recommendation_claim_ids: z.array(z.string().min(1)).min(1).max(8).optional(),
+    condition_claim_ids: z.array(z.string().min(1)).min(1).max(8).optional(),
+    pivot: z.object({
+        changed_claim_id: z.string().min(1),
+        new_risk_claim_id: z.string().min(1),
+    }).strict().optional(),
+    strongest_counter_case: z.object({
+        claim_ids: z.array(z.string().min(1)).min(1).max(4),
+        reasoning: z.string().min(1),
+    }).strict().optional(),
+    decision_snapshot: DecisionSnapshot.optional(),
     key_points: z.array(z.string()).max(10).optional(), // chairman's bulleted reasoning (idea workflow); code-review omits it
     dissent: z.array(z.string()).min(1), // ≥1 — empty dissent is invalid (§9); strongest counter-argument
     confidence_notes: z.string().min(1), // which conclusions are HIGH/MEDIUM/LOW and why
@@ -319,6 +815,27 @@ export const JudgeReport = JudgeReportBase.superRefine((r, ctx) => {
 export const JudgeReportModel = JudgeReportBase.extend({
     dissent: z.array(z.string()),
 });
+/** R5 idea-chair boundary. Persisted JudgeReport keeps its legacy adjudication names so code-review
+ *  and old run readers stay compatible; S9 translates only after this exact model shape validates. */
+export const IdeaChairRuling = z.object({
+    claim_id: z.string().min(1),
+    ruling: z.enum(['HOLDS', 'FAILS', 'UNRESOLVED']),
+    reasoning: z.string().min(1),
+    evidence_ids: z.array(z.string().min(1)).min(1),
+    effect_on_decision: z.string().min(1),
+    what_would_change_it: z.string().min(1).optional(),
+}).strict().superRefine((ruling, ctx) => {
+    if (ruling.ruling === 'UNRESOLVED' && !ruling.what_would_change_it) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['what_would_change_it'],
+            message: 'UNRESOLVED requires what_would_change_it',
+        });
+    }
+});
+export const IdeaChairReportModel = JudgeReportModel.omit({ adjudications: true }).extend({
+    adjudications: z.array(IdeaChairRuling),
+});
 // ── S9b: ActionPlan (idea-refinement report v3) ─────────────────────────────
 export const ActionPlan = z
     .object({
@@ -338,6 +855,31 @@ export const ActionPlan = z
     sequencing_note: z.string().min(1),
 })
     .strict();
+export const PlannerUnavailable = z.object({
+    kind: z.literal('PlannerUnavailable'),
+    reason: z.enum(['budget_exhausted', 'planner_failed']),
+    unresolved_questions: z.array(z.string().min(1)).min(1).max(10),
+}).strict();
+export const ActionPlanArtifact = z.union([ActionPlan, PlannerUnavailable]);
+/** R6 quick mode: one strong analyst produces the analysis, recommendation, and plan in one call. */
+export const QuickDecisionModel = z.object({
+    analysis: IdeaRoleOutputModel,
+    verdict: z.string().min(1),
+    recommendation: Recommendation,
+    conditions: z.array(z.string().min(1)).max(6),
+    key_points: z.array(z.string().min(1)).min(2).max(8),
+    dissent: z.array(z.string().min(1)).min(1).max(4),
+    confidence_notes: z.string().min(1),
+    action_plan: ActionPlan,
+}).strict().superRefine((decision, ctx) => {
+    const hasConditions = decision.conditions.length > 0;
+    if (decision.recommendation === 'PROCEED_WITH_CONDITIONS' && !hasConditions) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['conditions'], message: 'conditions are required for PROCEED_WITH_CONDITIONS' });
+    }
+    if (decision.recommendation !== 'PROCEED_WITH_CONDITIONS' && hasConditions) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['conditions'], message: 'conditions are only valid for PROCEED_WITH_CONDITIONS' });
+    }
+});
 // ── RunMeta (§15, §16) ──────────────────────────────────────────────────────
 //
 // Written by the artifact writer; assembled by the engine's RunCtx (T5). Internal → not strict.
@@ -345,6 +887,7 @@ export const ActionPlan = z
 export const CallRecord = z.object({
     provider: ProviderIdSchema,
     stage: z.string(), // e.g. "S4", "S1"
+    category: z.enum(['discovery', 'verification', 'repair', 'planning']).optional(),
     durationMs: z.number().nonnegative(),
     error: z.enum(['NOT_FOUND', 'AUTH', 'QUOTA', 'TIMEOUT', 'BAD_OUTPUT', 'CRASH']).optional(),
 });
@@ -360,6 +903,7 @@ const FlagProfileSchema = z.object({
 export const RunMeta = z.object({
     run_id: z.string().min(1), // encodes the timestamp (e.g. 20260702-1412-idea-refinement-a3f9)
     workflow: WorkflowIdSchema,
+    mode: IdeaModeSchema.optional(),
     provider_versions: z.record(ProviderIdSchema, z.string()), // detected `--version` strings
     flag_profiles: z.record(ProviderIdSchema, FlagProfileSchema),
     roles: z.record(z.string(), ProviderIdSchema), // role name → assigned provider
@@ -367,8 +911,23 @@ export const RunMeta = z.object({
     calls: z.array(CallRecord),
     call_count: z.number().int().nonnegative(),
     budget: z.object({ limit: z.number().int().positive(), used: z.number().int().nonnegative() }),
+    receipt: z.object({
+        discovery: z.number().int().nonnegative(),
+        verification: z.number().int().nonnegative(),
+        repair: z.number().int().nonnegative(),
+        planning: z.number().int().nonnegative(),
+    }).optional(),
     exit_status: z.enum(['ok', 'failed', 'aborted', 'partial']),
     aborted: z.boolean(), // §16: Ctrl+C finalizes meta with aborted:true
     // §16 report-header flags; absent = none.
-    flags: z.array(z.enum(['synthesis_suspect', 'low_diversity', 'plan_skipped', 'plan_fallback'])).optional(),
+    flags: z.array(z.enum([
+        'synthesis_suspect',
+        'low_diversity',
+        'plan_skipped',
+        'plan_fallback',
+        'headless_intent',
+        'verification_skipped',
+        'research_ungrounded',
+        'single_model',
+    ])).optional(),
 });