aiki-cli 0.3.0 → 0.3.2

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

@@ -1,10 +1,11 @@
 // S9 — chair adjudication over graph-selected escalations. Consensus and shared concerns are
 // read-only context; anonymous position text and the verifier record cross the boundary unchanged.
-import { selectEscalations } from '../decision-graph.js';
 import { IdeaChairReportModel } from '../../schemas/index.js';
 import { isFatal, StageError } from '../context.js';
 import { jsonCall } from '../jsonStage.js';
-import { claimVerificationRefIssues } from './s8-verify.js';
+import { claimShortLabel } from '../decision-dossier.js';
+import { loadSkill } from '../skills.js';
+import { claimVerificationRefIssues, selectVerificationEscalations } from './s8-verify.js';
 const EMPTY_REBUTTALS = {
     round: 1,
     selected_claim_ids: [],
@@ -39,7 +40,7 @@ Output ONLY JSON matching the judge schema:
 - key_points: 4-8 standalone decision-relevant bullets.
 - dissent: a JSON array of strings (an array even when there is only one) — the strongest arguments
   against your verdict.
-- confidence_notes: explain calibrated confidence.
+- confidence_notes: explain calibrated confidence.{{SKILL}}
 ESCALATED CLAIMS + VERIFICATION: {{ESCALATIONS_JSON}}
 APPEND-ONLY REBUTTAL EVENTS: {{REBUTTALS_JSON}}
 SETTLED/UNRESOLVED CONTEXT: {{CONTEXT_JSON}}`;
@@ -173,19 +174,40 @@ export function adjudicableClaimIds(graph, ids, judgeProvider) {
     return [...ids].filter((id) => !claimById.get(id)?.position_ids
         .some((positionId) => positionById.get(positionId)?.provider === judgeProvider));
 }
+/** One condition per distinct claim behind an evidence hole, claim-labeled instead of a generic
+ *  placeholder reason. Deduped by claim_id and capped at 4 so the fallback conditions list doesn't
+ *  drown in near-identical entries. */
+export function evidenceHoleConditions(graph) {
+    const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
+    const seen = new Set();
+    const out = [];
+    for (const hole of graph.holes.evidence) {
+        if (seen.has(hole.claim_id))
+            continue;
+        seen.add(hole.claim_id);
+        const claim = claimById.get(hole.claim_id);
+        out.push(`Obtain independent evidence for: "${claimShortLabel(claim?.proposition ?? 'a load-bearing claim')}".`);
+        if (out.length === 4)
+            break;
+    }
+    return out;
+}
 function fallbackConditions(graph, adjudications) {
     const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
     const upheld = adjudications
         .filter((item) => item.ruling === 'UPHOLD')
         .map((item) => `Proceed only if you can resolve: ${claimById.get(item.id)?.proposition ?? item.id}.`);
     const holes = graph.holes.coverage.map((hole) => `Proceed only after examining the ${hole.label} gap.`);
-    const evidenceHoles = graph.holes.evidence.map((hole) => `Proceed only after resolving evidence gap ${hole.claim_id}: ${hole.reason}.`);
+    const evidenceHoles = evidenceHoleConditions(graph);
     return [...upheld, ...holes, ...evidenceHoles, 'Proceed only after one cheap test confirms the core user need.'].slice(0, 6);
 }
-export function buildJudgePrompt(contract, graph, verifications, rubric, rebuttals = EMPTY_REBUTTALS, judgeProvider) {
-    return judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProvider).prompt;
+export function buildJudgePrompt(contract, graph, verifications, rubric, rebuttals = EMPTY_REBUTTALS, judgeProvider, skill = '') {
+    return judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProvider, skill).prompt;
+}
+export function buildChairRepairPrompt(basePrompt, corrections) {
+    return `${basePrompt}\n\n---\nCorrect these problems:\n${corrections}Output ONLY corrected JSON.`;
 }
-function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProvider) {
+function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProvider, skill = '') {
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
     const verificationById = new Map(verifications.verifications.map((item) => [item.claim_id, item]));
     const citedEvidence = [...new Set([
@@ -194,7 +216,7 @@ function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProv
         ])];
     const evidenceRefs = new Map(citedEvidence.map((id, index) => [`E${index + 1}`, id]));
     const aliasByEvidence = new Map([...evidenceRefs].map(([alias, id]) => [id, alias]));
-    const selectedIds = selectEscalations(graph, { max: 8 }).map((item) => item.claim_id);
+    const selectedIds = selectVerificationEscalations(graph).map((item) => item.claim_id);
     const eligibleIds = judgeProvider ? adjudicableClaimIds(graph, selectedIds, judgeProvider) : selectedIds;
     const escalationIds = new Set(eligibleIds);
     const escalations = graph.claims.filter((claim) => escalationIds.has(claim.id)).map((claim) => {
@@ -234,6 +256,7 @@ function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProv
         ...(event.narrowed_proposition ? { narrowed_proposition: event.narrowed_proposition } : {}),
     }));
     const prompt = S9_PROMPT
+        .replace('{{SKILL}}', skill ? `\n\n${skill}` : '')
         .replace('{{RUBRIC_JSON}}', JSON.stringify(rubric.map((item) => item.label)))
         .replace('{{ESCALATIONS_JSON}}', JSON.stringify(escalations, null, 2))
         .replace('{{REBUTTALS_JSON}}', JSON.stringify(rebuttalContext, null, 2))
@@ -242,13 +265,13 @@ function judgeInput(contract, graph, verifications, rubric, rebuttals, judgeProv
     return { prompt, evidenceRefs };
 }
 export async function s9Judge(ctx, contract, graph, verifications, rubric, rebuttals = EMPTY_REBUTTALS) {
-    const selectedIds = selectEscalations(graph, { max: 8 }).map((item) => item.claim_id);
+    const selectedIds = selectVerificationEscalations(graph).map((item) => item.claim_id);
     const verificationIssues = claimVerificationRefIssues(graph, verifications, selectedIds);
     if (verificationIssues.length)
         throw new StageError('S9', 'BAD_OUTPUT', `invalid verification references: ${verificationIssues.join('; ')}`);
     const ids = adjudicableClaimIds(graph, selectedIds, ctx.roles.judge);
     const selfAuthored = new Set(selectedIds.filter((id) => !ids.includes(id)));
-    const input = judgeInput(contract, graph, verifications, rubric, rebuttals, ctx.roles.judge);
+    const input = judgeInput(contract, graph, verifications, rubric, rebuttals, ctx.roles.judge, loadSkill('idea-refinement', 'chair'));
     const basePrompt = input.prompt;
     const judge = ctx.handle(ctx.roles.judge);
     const positionById = new Map(graph.positions.map((position) => [position.id, position]));
@@ -291,13 +314,13 @@ export async function s9Judge(ctx, contract, graph, verifications, rubric, rebut
     ];
     if ((violations.length || evidenceViolations.length || report.dissent.length === 0 || recIssues.length || chairIssues.length)
         && ctx.budget.limit - ctx.budget.used > 1) {
-        const repair = `${basePrompt}\n\n---\nCorrect these problems:\n`
+        const corrections = ''
             + (violations.length ? `- adjudications may reference only [${ids.join(', ')}], not ${violations.join(', ')}\n` : '')
             + (evidenceViolations.length ? `- evidence reference errors: ${evidenceViolations.join('; ')}\n` : '')
             + (report.dissent.length === 0 ? '- dissent must contain at least one item\n' : '')
             + (recIssues.length ? `- ${recIssues.join('; ')}\n` : '')
-            + (chairIssues.length ? `- chair contract errors: ${chairIssues.join('; ')}\n` : '')
-            + 'Output ONLY corrected JSON.';
+            + (chairIssues.length ? `- chair contract errors: ${chairIssues.join('; ')}\n` : '');
+        const repair = buildChairRepairPrompt(basePrompt, corrections);
         try {
             report = translateChairReport(await jsonCall(ctx, judge, 'S9-repair', repair, IdeaChairReportModel, {
                 repair: ctx.budget.limit - ctx.budget.used > 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 } 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,24 +16,55 @@ 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),
-}).strict();
-const S9B_PROMPT = `ROLE: Validation planner. You write the next actions for a decision-maker after an
-idea council has already debated and judged the idea. Do not write a build roadmap. Write only validation
-actions that test unsettled risks, blind spots, or open questions. Cheapest decisive test first.{{SKILL}}
+    feature_backlog: FeatureBacklog.optional(),
+    implementation_plan: ImplementationPlan.optional(),
+    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}.
+  Prioritize the smallest judge-impressing golden path; MUST is required, not a wishlist.
+- 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) {
@@ -45,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);
@@ -77,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}` : '')
@@ -102,14 +226,42 @@ export function validAnchor(anchor, anchors) {
     }
     return false;
 }
-export function anchoredActionPlan(plan, anchors) {
+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)
+    if (actions.length === 0 && !requireReaderBrief)
         return null;
-    return { actions, sequencing_note: plan.sequencing_note };
+    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) {
     const value = raw?.trim().toLowerCase();
@@ -123,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,
@@ -131,6 +295,14 @@ export function normalizePlannerOutput(plan) {
             effort: normalizeEffort(action.effort),
         })),
         sequencing_note: plan.sequencing_note,
+        ...(plan.feature_backlog ? { feature_backlog: plan.feature_backlog } : {}),
+        ...(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) {
@@ -144,14 +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 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);
@@ -161,33 +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,
-    }, 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);
+        }), 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.\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` +
-            `Output ONLY corrected JSON with every action anchored to one of those values.`;
-        const repaired = normalizePlannerOutput(await jsonCall(ctx, ctx.handle(ctx.roles.judge), 'S9b-anchor-repair', repair, PlannerOutput, { repair: false }));
-        const repairedAnchored = anchoredActionPlan(repaired, anchors);
+            `Valid source ids: ${anchors.sourceIds.join(', ') || '(none)'}\n` +
+            `Required outputs: ${requestedOutputs.join(', ')}\n` +
+            `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;