aiki-cli 0.3.1 → 0.3.2

package/dist/orchestration/stages/s9b-plan.js

@@ -1,12 +1,13 @@
 // S9b — idea validation plan. This is the one report-v3 model call after the judge: it turns the
 // adjudicated risks, blind spots, and open questions into anchored validation actions. Rendering stays
 // deterministic; if the planner fails or produces unanchored actions, we write flagged unavailability.
-import { ActionPlan, FeatureBacklog, ImplementationPlan } from '../../schemas/index.js';
+import { ActionPlan, FeatureBacklog, ImplementationPlan, ReaderBrief, readerBriefIssues } from '../../schemas/index.js';
 import { z } from 'zod';
 import { BudgetExceeded, isFatal } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
 import { loadSkill } from '../skills.js';
 import { mergeOpenQuestions } from './s10-render.js';
+import { interpretClaimOutcome } from '../decision-graph.js';
 const PlannerOutput = z.object({
     actions: z.array(z.object({
         order: z.number().int().min(1).optional(),
@@ -15,25 +16,46 @@ const PlannerOutput = z.object({
         validates: z.string().min(1),
         effort: z.string().min(1).optional(),
         kill_signal: z.string().min(1),
-    }).strict()).min(1).max(7),
+    }).strict()).max(7),
     sequencing_note: z.string().min(1),
     feature_backlog: FeatureBacklog.optional(),
     implementation_plan: ImplementationPlan.optional(),
-}).strict();
-const S9B_PROMPT = `ROLE: Validation planner. You write the requested practical outputs after an idea
-council has debated and judged the idea. The actions list remains validation work: test unsettled risks,
-blind spots, or open questions, with the cheapest decisive test first.{{SKILL}}
+    reader_brief: ReaderBrief.optional(),
+}).strict().superRefine((plan, ctx) => {
+    if (plan.actions.length === 0 && !plan.reader_brief) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['actions'], message: 'an empty planner answer requires reader_brief' });
+    }
+});
+const S9B_PROMPT = `ROLE: User answer editor and action planner. The council has already done the analysis.
+Turn its strongest supported findings and both scouts' proposals into a useful answer to the original user.{{SKILL}}
 
 Output ONLY JSON matching the ActionPlan schema:
-- actions: 1-7 ordered actions, each imperative and concrete.
+- reader_brief is REQUIRED. It contains:
+  - headline: a concrete answer, not a report label.
+  - bottom_line: the direct recommendation and why, with no process talk.
+  - sections: 2-6 useful sections {heading,summary,bullets}; synthesize the requested deliverables and explain
+    why standout ideas matter. Prefer concrete product language over due-diligence language. Explain the verdict,
+    selection logic, and trade-offs; do not restate the feature backlog or milestone list.
+  - next_step: one action the user should take next.
+  - caveats: at most 3 honest limitations that materially affect the answer.
+  - source_ids: only ids present in CONTEXT.sources; use [] when no source supports the reader answer.
+- reader_brief must never mention graph/claim ids, verification enums, evidence coverage, structural scoring,
+  provider-call mechanics, or the fact that an answer editor assembled it.
+- CONTEXT.chair is decision reasoning, not factual proof. Treat its recommendation, rationale, conditions, and
+  claim outcomes as judgment. Do not call a proposition supported, verified, proven, or factual unless the same
+  proposition appears in supported_findings; otherwise frame it as a recommendation, risk, or hypothesis.
+- actions: 1-4 ordered validation actions, each imperative and concrete.
 - validates MUST anchor to one of:
   - a graph claim id from upheld_risks, e.g. "G3"
   - a blind spot label as "blind:<label>"
   - an open-question prefix as "Q:<question prefix>"
 - why ties the action to the risk, blind spot, or question.
 - kill_signal is the result that should stop or reshape the idea.
-- Preserve the chair's numeric distinctions: operating break-even is not capital payback, and a target cap
-  is not a known cost. Do not introduce or reinterpret a number that is absent from decision_snapshot.
+- Preserve CONTEXT.chair's numeric distinctions: operating break-even is not capital payback, and a target cap
+  is not a known cost. Do not introduce or reinterpret a number that is absent from CONTEXT.chair.decision_snapshot.
+- CONTEXT.as_of_date is the evidence snapshot date, not a deadline. Compare it with any sourced deadline.
+- Treat stated deadlines and available time as hard boundaries. When CONTEXT has no numeric deadline or capacity,
+  do not invent a day-count calendar; use ordered phases with explicit acceptance tests.
 - sequencing_note explains why this order is cheapest and decisive.
 - Read requested_outputs in CONTEXT. When it includes FEATURE_BACKLOG, include feature_backlog with
   must/should/later items {feature,user_value,rationale,effort:S|M|L} and wont items {feature,reason}.
@@ -41,6 +63,8 @@ Output ONLY JSON matching the ActionPlan schema:
 - When requested_outputs includes IMPLEMENTATION_PLAN, include implementation_plan.milestones with
   {order,timebox,outcome,tasks,acceptance_test}. This is a concrete build sequence, not validation prose.
 - Do not omit a requested output and do not invent an unrequested product surface.
+- Use deliverable_proposals from BOTH seats as options, then select and improve the strongest coherent set.
+- Treat supported_findings and sources as factual boundaries. Proposals are product judgment, not proof.
 
 CONTEXT: {{CONTEXT_JSON}}`;
 function clip(s, n) {
@@ -53,19 +77,21 @@ function sevRank(s) {
 function norm(s) {
     return s.trim().toLowerCase();
 }
-function unresolvedRisks(graph, judgeReport) {
+export function unresolvedRisks(graph, judgeReport) {
     const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
     const rulingById = new Map(judgeReport.adjudications.map((a) => [a.id, a]));
     const risks = graph.claims
         .map((claim) => {
         const adj = rulingById.get(claim.id);
-        if (adj?.ruling !== 'UPHOLD')
+        const outcome = interpretClaimOutcome(graph, claim, adj);
+        if ((!adj && outcome.decisionEffect !== 'FAILED')
+            || (outcome.propositionTruth === 'HOLDS' && outcome.decisionEffect === 'HELD'))
             return null;
         return {
             id: claim.id,
             assumption: claim.proposition,
             severity: claim.sensitivity === 'DECISIVE' ? 'HIGH' : claim.sensitivity === 'MATERIAL' ? 'MED' : 'LOW',
-            reasoning: adj.reasoning,
+            reasoning: adj?.reasoning ?? 'This supported concern works against the decision.',
         };
     })
         .filter((risk) => risk !== null);
@@ -85,6 +111,96 @@ function unresolvedRisks(graph, judgeReport) {
     }
     return risks.sort((a, b) => sevRank(a.severity) - sevRank(b.severity));
 }
+const ANSWER_MATERIAL_FLAGS = new Set([
+    'synthesis_suspect', 'low_diversity', 'weak_seat', 'deliverable_gap', 'headless_intent',
+    'verification_skipped', 'research_ungrounded', 'source_fallback_search',
+]);
+function safePublicUrl(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const url = new URL(raw);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.toString() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Canonical, decision-relevant input to the existing S9b answer-editor call. */
+export function buildAnswerContext(input) {
+    const { contract, graph, judgeReport, seats } = input;
+    const evidenceDates = graph.evidence
+        .filter((evidence) => evidence.source_kind === 'PRIMARY' || evidence.source_kind === 'SECONDARY')
+        .map((evidence) => evidence.accessed_at?.match(/^\d{4}-\d{2}-\d{2}/)?.[0])
+        .filter((date) => Boolean(date))
+        .sort();
+    const asOfDate = evidenceDates.at(-1);
+    const requestedOutputs = contract.requested_outputs ?? ['DECISION'];
+    const adjudicationById = new Map(judgeReport.adjudications.map((item) => [item.id, item]));
+    const outcomes = graph.claims.map((claim) => {
+        const adjudication = adjudicationById.get(claim.id);
+        const outcome = interpretClaimOutcome(graph, claim, adjudication);
+        return {
+            id: claim.id,
+            proposition: claim.proposition,
+            proposition_truth: outcome.propositionTruth,
+            decision_effect: outcome.decisionEffect,
+            ...(adjudication ? { reasoning: adjudication.reasoning } : {}),
+        };
+    });
+    const outcomeById = new Map(outcomes.map((outcome) => [outcome.id, outcome]));
+    const deliverableProposals = seats.flatMap((seat) => {
+        const seatId = seat.sample ?? seat.provider;
+        return (seat.output.deliverable_proposals ?? []).map((proposal) => ({
+            ...proposal,
+            provider: seat.provider,
+            seat_id: seatId,
+            evidence_ids: [...new Set(proposal.evidence_ids.flatMap((localId) => graph.evidence
+                    .filter((evidence) => evidence.provider === seat.provider
+                    && evidence.source_id === seatId
+                    && evidence.id === `${seatId}/${localId}`)
+                    .map((evidence) => evidence.id)))],
+        }));
+    });
+    return {
+        original_request: input.originalRequest,
+        ...(asOfDate ? { as_of_date: asOfDate } : {}),
+        task: contract.task,
+        constraints: contract.constraints,
+        success_criteria: contract.success_criteria,
+        requested_outputs: requestedOutputs,
+        chair: {
+            epistemic_status: 'DECISION_REASONING_NOT_FACT',
+            recommendation: judgeReport.recommendation,
+            decision_reasoning: judgeReport.verdict,
+            rationale: judgeReport.key_points ?? [],
+            decision_conditions: judgeReport.conditions ?? [],
+            decision_snapshot: judgeReport.decision_snapshot,
+            claim_outcomes: outcomes,
+        },
+        upheld_risks: unresolvedRisks(graph, judgeReport),
+        blind_spots: graph.holes.coverage.map((hole) => hole.label),
+        open_questions: mergeOpenQuestions(seats),
+        deliverable_proposals: deliverableProposals,
+        supported_findings: graph.claims
+            .filter((claim) => claim.nature === 'FACTUAL'
+            && claim.evidence_state === 'SUPPORTED'
+            && outcomeById.get(claim.id)?.proposition_truth === 'HOLDS')
+            .map((claim) => ({ id: claim.id, finding: claim.proposition })),
+        material_flags: [...input.flags].filter((flag) => ANSWER_MATERIAL_FLAGS.has(flag)),
+        sources: graph.evidence.map((evidence) => {
+            const url = safePublicUrl(evidence.url) ?? safePublicUrl(evidence.locator);
+            return {
+                id: evidence.id,
+                kind: evidence.source_kind,
+                ...(evidence.title ? { title: evidence.title } : {}),
+                ...(url ? { url } : {}),
+                ...(evidence.accessed_at ? { accessed_at: evidence.accessed_at } : {}),
+                supports: evidence.claim_supported,
+            };
+        }),
+    };
+}
 export function buildActionPlannerPrompt(input, skill) {
     return S9B_PROMPT
         .replace('{{SKILL}}', skill ? `\n\n${skill}` : '')
@@ -110,22 +226,41 @@ export function validAnchor(anchor, anchors) {
     }
     return false;
 }
-export function anchoredActionPlan(plan, anchors, requestedOutputs = []) {
+function normalizeSourceIds(ids, allowed) {
+    const normalized = ids.flatMap((id) => {
+        if (allowed.includes(id))
+            return [id];
+        const matches = allowed.filter((known) => known.endsWith(`/${id}`));
+        return matches.length === 1 ? matches : [];
+    });
+    return [...new Set(normalized)];
+}
+export function anchoredActionPlan(plan, anchors, requestedOutputs = [], requireReaderBrief = false) {
+    if (requestedOutputs.includes('FEATURE_BACKLOG') && !plan.feature_backlog)
+        return null;
+    if (requestedOutputs.includes('IMPLEMENTATION_PLAN') && !plan.implementation_plan)
+        return null;
+    if (requireReaderBrief && !plan.reader_brief)
+        return null;
+    const readerBrief = plan.reader_brief ? {
+        ...plan.reader_brief,
+        source_ids: normalizeSourceIds(plan.reader_brief.source_ids, anchors.sourceIds),
+    } : undefined;
+    if (readerBrief && readerBriefIssues(readerBrief, anchors.knownReaderIds ?? anchors.claimIds).length)
+        return null;
     const actions = plan.actions
         .filter((a) => validAnchor(a.validates, anchors))
         .sort((a, b) => a.order - b.order)
+        .slice(0, requireReaderBrief ? 4 : 7)
         .map((a, i) => ({ ...a, order: i + 1 }));
-    if (actions.length === 0)
-        return null;
-    if (requestedOutputs.includes('FEATURE_BACKLOG') && !plan.feature_backlog)
-        return null;
-    if (requestedOutputs.includes('IMPLEMENTATION_PLAN') && !plan.implementation_plan)
+    if (actions.length === 0 && !requireReaderBrief)
         return null;
     return {
         actions,
         sequencing_note: plan.sequencing_note,
         ...(requestedOutputs.includes('FEATURE_BACKLOG') && plan.feature_backlog ? { feature_backlog: plan.feature_backlog } : {}),
         ...(requestedOutputs.includes('IMPLEMENTATION_PLAN') && plan.implementation_plan ? { implementation_plan: plan.implementation_plan } : {}),
+        ...(readerBrief ? { reader_brief: readerBrief } : {}),
     };
 }
 export function normalizeEffort(raw) {
@@ -140,7 +275,19 @@ export function normalizeEffort(raw) {
     const days = amount * (unit === 'minute' ? 1 / 1440 : unit === 'hour' ? 1 / 24 : unit === 'day' ? 1 : unit === 'week' ? 7 : unit === 'month' ? 30 : 365);
     return days <= 2 ? 'S' : days <= 14 ? 'M' : 'L';
 }
-export function normalizePlannerOutput(plan) {
+const CALENDAR_TIMEBOX = /\b(?:days?|weeks?|months?|years?)\b|\b\d{4}-\d{2}-\d{2}\b|\b(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b/i;
+const EXPLICIT_SCHEDULE = /\b(?:\d{4}-\d{2}-\d{2}|\d+(?:\.\d+)?\s*[-–]?\s*(?:hours?|days?|weeks?|months?|years?)|(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\s+\d{1,2}(?:st|nd|rd|th)?(?:,\s*\d{4})?)\b/i;
+function hasExplicitSchedule(context) {
+    return EXPLICIT_SCHEDULE.test(JSON.stringify({
+        original_request: context.original_request,
+        constraints: context.constraints,
+        success_criteria: context.success_criteria,
+        chair: context.chair,
+        supported_findings: context.supported_findings,
+        sources: context.sources.map((source) => source.supports),
+    }));
+}
+export function normalizePlannerOutput(plan, calendarAllowed = true) {
     return ActionPlan.parse({
         actions: plan.actions.map((action, i) => ({
             ...action,
@@ -149,7 +296,13 @@ export function normalizePlannerOutput(plan) {
         })),
         sequencing_note: plan.sequencing_note,
         ...(plan.feature_backlog ? { feature_backlog: plan.feature_backlog } : {}),
-        ...(plan.implementation_plan ? { implementation_plan: plan.implementation_plan } : {}),
+        ...(plan.implementation_plan ? { implementation_plan: {
+                milestones: plan.implementation_plan.milestones.map((milestone, index) => ({
+                    ...milestone,
+                    timebox: !calendarAllowed && CALENDAR_TIMEBOX.test(milestone.timebox) ? `Phase ${index + 1}` : milestone.timebox,
+                })),
+            } } : {}),
+        ...(plan.reader_brief ? { reader_brief: plan.reader_brief } : {}),
     });
 }
 function unavailablePlan(reason, contract, risks, blindSpots, openQuestions) {
@@ -163,16 +316,20 @@ function unavailablePlan(reason, contract, risks, blindSpots, openQuestions) {
         unresolved_questions: (unresolved.length ? unresolved : [`What evidence would change the verdict for ${clip(contract.task, 100)}?`]).slice(0, 10),
     };
 }
-export async function s9bPlan(ctx, contract, seats, graph, judgeReport) {
-    const openQuestions = mergeOpenQuestions(seats);
-    const requestedOutputs = contract.requested_outputs
-        ?? ['DECISION'];
-    const risks = unresolvedRisks(graph, judgeReport);
-    const blindSpots = graph.holes.coverage.map((hole) => hole.label);
+export async function s9bPlan(ctx, contract, seats, graph, judgeReport, originalRequest = contract.task) {
+    const answerContext = buildAnswerContext({ originalRequest, contract, seats, graph, judgeReport, flags: ctx.flags });
+    const openQuestions = answerContext.open_questions;
+    const requestedOutputs = answerContext.requested_outputs;
+    const risks = answerContext.upheld_risks;
+    const blindSpots = answerContext.blind_spots;
+    const sourceIds = graph.evidence.map((evidence) => evidence.id);
+    const requireReaderBrief = 'success_bar' in contract;
     const anchors = {
         claimIds: risks.map((r) => r.id),
+        knownReaderIds: graph.claims.map((claim) => claim.id),
         blindSpots,
         openQuestions,
+        sourceIds,
     };
     const fallback = async (flag) => {
         ctx.addFlag(flag);
@@ -182,35 +339,28 @@ export async function s9bPlan(ctx, contract, seats, graph, judgeReport) {
     };
     if (ctx.budget.limit - ctx.budget.used < 1)
         return fallback('plan_skipped');
-    const prompt = buildActionPlannerPrompt({
-        task: contract.task,
-        recommendation: judgeReport.recommendation,
-        conditions: judgeReport.conditions,
-        decision_snapshot: judgeReport.decision_snapshot,
-        upheld_risks: risks,
-        blind_spots: blindSpots,
-        open_questions: openQuestions,
-        requested_outputs: requestedOutputs,
-    }, loadSkill('idea-refinement', 'planner'));
+    const prompt = buildActionPlannerPrompt(answerContext, loadSkill('idea-refinement', 'planner'));
+    const calendarAllowed = hasExplicitSchedule(answerContext);
     try {
         const first = normalizePlannerOutput(await jsonCall(ctx, ctx.handle(ctx.roles.judge), 'S9b-plan', prompt, PlannerOutput, {
             repair: ctx.budget.limit - ctx.budget.used >= 2,
-        }));
-        const anchored = anchoredActionPlan(first, anchors, requestedOutputs);
+        }), calendarAllowed);
+        const anchored = anchoredActionPlan(first, anchors, requestedOutputs, requireReaderBrief);
         if (anchored) {
             await ctx.writer.writeJson('action-plan', anchored);
             return anchored;
         }
         if (ctx.budget.limit - ctx.budget.used < 1)
             return fallback('plan_fallback');
-        const repair = `${prompt}\n\n---\nYour previous plan had no actions with valid anchors or omitted a requested deliverable.\n` +
+        const repair = `${prompt}\n\n---\nYour previous response had invalid anchors, omitted a requested deliverable or reader_brief, used internal audit language, or cited an unknown source id.\n` +
             `Valid graph claim ids: ${anchors.claimIds.join(', ') || '(none)'}\n` +
             `Valid blind spots: ${anchors.blindSpots.join(' | ') || '(none)'}\n` +
             `Valid open questions: ${anchors.openQuestions.join(' | ') || '(none)'}\n` +
+            `Valid source ids: ${anchors.sourceIds.join(', ') || '(none)'}\n` +
             `Required outputs: ${requestedOutputs.join(', ')}\n` +
-            `Output ONLY corrected JSON with every action anchored and every requested deliverable present.`;
-        const repaired = normalizePlannerOutput(await jsonCall(ctx, ctx.handle(ctx.roles.judge), 'S9b-anchor-repair', repair, PlannerOutput, { repair: false }));
-        const repairedAnchored = anchoredActionPlan(repaired, anchors, requestedOutputs);
+            `Output ONLY corrected JSON with every action anchored, reader_brief present, and every requested deliverable present.`;
+        const repaired = normalizePlannerOutput(await jsonCall(ctx, ctx.handle(ctx.roles.judge), 'S9b-anchor-repair', repair, PlannerOutput, { repair: false }), calendarAllowed);
+        const repairedAnchored = anchoredActionPlan(repaired, anchors, requestedOutputs, requireReaderBrief);
         if (repairedAnchored) {
             await ctx.writer.writeJson('action-plan', repairedAnchored);
             return repairedAnchored;

package/dist/schemas/index.js

@@ -186,6 +186,7 @@ export const PreflightReading = z.object({
     missing_evidence: z.array(z.string().min(1)).max(8),
     domain_dimensions: z.array(DomainDimension).min(3).max(5),
     questions: z.array(RunBriefQuestion).max(4),
+    requested_outputs: z.array(RequestedOutputSchema).max(4).default([]),
 }).strict().superRefine((reading, ctx) => {
     checkQuestionIds(reading.questions, ctx);
     checkDomainDimensionIds(reading.domain_dimensions, ctx);
@@ -236,6 +237,7 @@ export const ClaimPosition = z
     dimension_id: z.string().min(1),
     stance: z.enum(['SUPPORT', 'OPPOSE', 'MIXED', 'UNKNOWN']),
     basis: z.enum(['EVIDENCE', 'INFERENCE', 'ASSUMPTION']),
+    nature: z.enum(['FACTUAL', 'JUDGMENT']).default('JUDGMENT'),
     load_bearing: z.boolean(),
     if_false: z.enum(['STOP', 'PIVOT', 'CONDITION', 'MINOR']),
     reasoning: z.string().min(1),
@@ -316,6 +318,14 @@ export const DecisionQuestion = z
     claim_ids: z.array(z.string().min(1)),
 })
     .strict();
+export const DeliverableProposal = z.object({
+    output: z.enum(['FEATURE_BACKLOG', 'IMPLEMENTATION_PLAN']),
+    title: z.string().min(1),
+    detail: z.string().min(1),
+    user_value: z.string().min(1),
+    why_distinctive: z.string().min(1),
+    evidence_ids: z.array(z.string().min(1)).max(6),
+}).strict();
 const IdeaRoleOutputBase = z
     .object({
     workflow: z.literal('idea-refinement'),
@@ -326,6 +336,7 @@ const IdeaRoleOutputBase = z
     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),
+    deliverable_proposals: z.array(DeliverableProposal).max(8).default([]),
 })
     .strict();
 function checkSubmissionRefs(submission, ctx) {
@@ -395,6 +406,12 @@ function checkSubmissionRefs(submission, ctx) {
                 ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['decision_questions', index, 'claim_ids'], message: `unknown position id: ${id}` });
         }
     }
+    for (const [index, proposal] of submission.deliverable_proposals.entries()) {
+        for (const id of proposal.evidence_ids) {
+            if (!evidenceIds.has(id))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['deliverable_proposals', index, 'evidence_ids'], message: `unknown evidence 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
@@ -527,6 +544,17 @@ export function salvageIdeaRoleOutputModel(input) {
             && calc.inputs.every((input) => input.evidence_ids.every((id) => keptEvidence.has(id))))
             .slice(0, 8)
         : output.calculations;
+    const deliverableProposals = parseOrDrop(output.deliverable_proposals, (item) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            return DeliverableProposal.safeParse(item);
+        const proposal = item;
+        return DeliverableProposal.strip().safeParse({
+            ...proposal,
+            evidence_ids: Array.isArray(proposal.evidence_ids)
+                ? proposal.evidence_ids.filter((id) => keptEvidence.has(id))
+                : proposal.evidence_ids,
+        });
+    });
     return {
         ...output,
         evidence,
@@ -534,6 +562,7 @@ export function salvageIdeaRoleOutputModel(input) {
         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)),
+        deliverable_proposals: deliverableProposals,
     };
 }
 /** The model-facing S4 shape. Exact known enum aliases are canonicalized, then the strict schema validates
@@ -588,6 +617,7 @@ export const DecisionClaim = z.object({
     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']),
+    nature: z.enum(['FACTUAL', 'JUDGMENT']).default('JUDGMENT'),
     load_bearing: z.boolean(),
     if_false: z.enum(['STOP', 'PIVOT', 'CONDITION', 'MINOR']),
     sensitivity: z.enum(['DECISIVE', 'MATERIAL', 'LOW']),
@@ -899,7 +929,32 @@ export const ImplementationPlan = z.object({
         acceptance_test: z.string().min(1),
     }).strict()).min(1).max(7),
 }).strict();
-export const ActionPlan = z
+const ReaderBriefBase = z.object({
+    headline: z.string().min(1).max(160),
+    bottom_line: z.string().min(1).max(1200),
+    sections: z.array(z.object({
+        heading: z.string().min(1).max(120),
+        summary: z.string().min(1).max(1000),
+        bullets: z.array(z.string().min(1).max(500)).max(6),
+    }).strict()).min(2).max(6),
+    next_step: z.string().min(1).max(600),
+    caveats: z.array(z.string().min(1).max(500)).max(3),
+    source_ids: z.array(z.string().min(1)).max(8),
+}).strict();
+const READER_AUDIT_ENUM = /\b(?:UNVERIFIED|UNVERIFIABLE|PARTIAL|CONFLICTED)\b/;
+const READER_AUDIT_LANGUAGE = /\b(?:structural score|evidence coverage|verification coverage|claim ids?|graph ids?|provider calls?|model calls?|answer editor|reader_brief)\b/i;
+export const ReaderBrief = ReaderBriefBase.superRefine((brief, ctx) => {
+    const text = JSON.stringify(brief);
+    if (READER_AUDIT_ENUM.test(text) || READER_AUDIT_LANGUAGE.test(text)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'reader_brief contains internal audit language' });
+    }
+});
+/** Contextual reader-language check: only reject IDs that actually exist in this run. */
+export function readerBriefIssues(brief, knownIds) {
+    const text = JSON.stringify(brief);
+    return [...knownIds].filter((id) => new RegExp(`\\b${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(text));
+}
+const ActionPlanBase = z
     .object({
     actions: z
         .array(z
@@ -912,13 +967,19 @@ export const ActionPlan = z
         kill_signal: z.string().min(1),
     })
         .strict())
-        .min(1)
         .max(7),
     sequencing_note: z.string().min(1),
     feature_backlog: FeatureBacklog.optional(),
     implementation_plan: ImplementationPlan.optional(),
+    // Optional only so pre-v5 run artifacts remain replayable. New decision contracts require it in S9b.
+    reader_brief: ReaderBrief.optional(),
 })
     .strict();
+export const ActionPlan = ActionPlanBase.superRefine((plan, ctx) => {
+    if (plan.actions.length === 0 && !plan.reader_brief) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['actions'], message: 'an empty action plan requires reader_brief' });
+    }
+});
 export const PlannerUnavailable = z.object({
     kind: z.literal('PlannerUnavailable'),
     reason: z.enum(['budget_exhausted', 'planner_failed']),
@@ -934,7 +995,7 @@ export const QuickDecisionModel = z.object({
     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,
+    action_plan: ActionPlanBase.extend({ reader_brief: ReaderBrief }),
 }).strict().superRefine((decision, ctx) => {
     const hasConditions = decision.conditions.length > 0;
     if (decision.recommendation === 'PROCEED_WITH_CONDITIONS' && !hasConditions) {
@@ -987,11 +1048,14 @@ export const RunMeta = z.object({
     flags: z.array(z.enum([
         'synthesis_suspect',
         'low_diversity',
+        'weak_seat',
         'plan_skipped',
         'plan_fallback',
         'headless_intent',
         'verification_skipped',
         'research_ungrounded',
+        'source_fallback_search',
+        'deliverable_gap',
         'single_model',
     ])).optional(),
 });

package/dist/skills/idea-refinement/analyst.md

@@ -1,11 +1,11 @@
-# Analyst playbook — pressure-test the idea
+# Analyst playbook — strengthen and pressure-test the idea
 
-You are an adversarial analyst on a decision panel. Your job is not to like the idea — it is to find
-where it breaks. Steelman it once, then attack it honestly.
+You are an independent analyst on a decision panel. Build the strongest useful version for your lane,
+then expose where it breaks. Creation and criticism are both required.
 
 ## Strongest version first
 - Before attacking, state the best honest version of the idea: who it is for and why it would win.
-- Attack THAT version, not a weak strawman. If the steelman is thin, that itself is a finding.
+- Test THAT version, not a weak strawman. If the steelman is thin, that itself is a finding.
 
 ## Positions — make the stance explicit
 - State each decision-critical proposition and take an explicit SUPPORT, OPPOSE, MIXED, or UNKNOWN
@@ -45,5 +45,5 @@ ownership; emit one explicit coverage entry for every owned dimension.
 - Phrase each so that a yes/no or a single number would actually flip your assessment.
 
 ## Do not
-- No motivational framing, no pitch language, no summarizing your own output.
+- No unsupported hype or generic feature wishlists. Explain the mechanism and user value.
 - No unanchored position or evidence. No proposition you cannot tie to the decision.

package/dist/skills/idea-refinement/chair.md

@@ -0,0 +1,18 @@
+# Chair playbook — rule on the real disagreement
+
+Add to your base instructions; the schema and caps are unchanged and always win.
+
+## Synthesis discipline
+- Count convergence only when seats reached the same conclusion independently with different evidence.
+  Two seats repeating the same hedge is not agreement.
+- Never smooth over a clash. State both readings, compare their evidence quality, and rule.
+- A strong dissent beats a weak majority. Side with the better-evidenced minority when warranted and
+  explain why in `key_points`.
+- Never answer "it depends". Choose the required verdict enum; put contingencies into concrete,
+  checkable conditions that name their claim.
+- Lead `key_points` with the evidence or result that would change the verdict.
+- Report a blind spot only when verification or rebuttal actually exposed it.
+
+## First action
+- Anchor the first action to the single cheapest check that could kill or confirm the decision.
+- Pick one thing first, not a list disguised as one action.

package/dist/skills/idea-refinement/economics-delivery.md

@@ -3,5 +3,16 @@
 Own unit economics and capital needs, technical and operational feasibility, supply constraints,
 legal and compliance exposure, scalability, failure modes, and the cheapest decisive kill criteria.
 
+Act as the skeptic/executor for requested deliverables. When FEATURE_BACKLOG is requested, produce 2–4
+`deliverable_proposals` that preserve the standout value while remaining credible under the stated deadline.
+When IMPLEMENTATION_PLAN is requested, propose the shortest build sequence with observable outcomes.
+
 Steelman the idea first. Cross into another lane only for a load-bearing issue. For every owned
 dimension, emit a `COVERED` entry anchored to positions or a reasoned `NOT_APPLICABLE` entry.
+
+## Lens discipline (council seat)
+- Contrarian: assume a fatal flaw and hunt it — the number that does not close, the unpriced dependency,
+  or the deadline that does not fit.
+- Executor: every recommendation must survive the question, "What do you do Monday morning?"
+- Stance strength must match evidence strength — a hunch is an UNKNOWN position with a question
+  attached, never a confident claim.

package/dist/skills/idea-refinement/market-adoption.md

@@ -3,5 +3,17 @@
 Own target-user urgency, alternatives and status quo, differentiation, distribution and procurement,
 timing, and the team's ability to execute the required adoption motion.
 
+Act as the visionary product strategist for requested deliverables. When FEATURE_BACKLOG is requested,
+produce 3–6 bold but concrete `deliverable_proposals` that create a memorable user or demo moment; say why
+each is distinctive rather than listing ordinary table-stakes UI.
+
 Steelman the idea first. Cross into another lane only for a load-bearing issue. For every owned
 dimension, emit a `COVERED` entry anchored to positions or a reasoned `NOT_APPLICABLE` entry.
+
+## Lens discipline (council seat)
+- Expansionist: lean fully into this lane instead of hedging toward balance; the other seat and verifier
+  cover the rest. Name the undervalued upside with a number and evidence ID, or mark it UNKNOWN.
+- Outsider: read the pitch with zero context. If its framing would confuse a fresh reader, that is a
+  market finding, not a presentation footnote.
+- Stance strength must match evidence strength — a hunch is an UNKNOWN position with a question
+  attached, never a confident claim.