aiki-cli 0.3.1 → 0.3.3

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']),
@@ -635,8 +665,27 @@ export const ClaimVerification = z.object({
     calculation_check: z.enum(['PASS', 'FAIL', 'NOT_APPLICABLE']).optional(),
     missing_evidence: z.array(z.string().min(1)),
 }).strict();
+/** v6 semantic claim join: S8 may group claims that assert the same proposition in different
+ *  words (SAME) or directly contradict each other (OPPOSES). `.catch(undefined)` keeps a
+ *  malformed grouping from ever costing the verification set — groups are a bonus, never a risk. */
+export const ClaimGroup = z.object({
+    ids: z.array(z.string().min(1)).min(2).max(8),
+    relation: z.enum(['SAME', 'OPPOSES']),
+}).strict();
 export const ClaimVerificationSet = z.object({
     verifications: z.array(ClaimVerification),
+    claim_groups: z.array(ClaimGroup).max(12).optional().catch(undefined),
+}).strict();
+// ── v7 Phase D: targeted auto-mode challenge delta ─────────────────────────
+export const ChallengeDelta = z.object({
+    claimId: z.string().min(1),
+    response: z.enum(['CONFIRM', 'COUNTER', 'NARROW', 'REPLACE', 'UNRESOLVED']),
+    reasoning: z.string().min(1),
+    newEvidenceIds: z.array(z.string().min(1)),
+    changedDecisionImpact: z.string().min(1),
+}).strict();
+export const ChallengeDeltaSet = z.object({
+    deltas: z.array(ChallengeDelta).max(3),
 }).strict();
 // ── R5: bounded, append-only rebuttal events ───────────────────────────────
 const RebuttalResponseBase = z.object({
@@ -899,7 +948,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 +986,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 +1014,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) {
@@ -947,6 +1027,16 @@ export const QuickDecisionModel = z.object({
 // ── RunMeta (§15, §16) ──────────────────────────────────────────────────────
 //
 // Written by the artifact writer; assembled by the engine's RunCtx (T5). Internal → not strict.
+/** Per-call token accounting. `estimated:true` = local chars/4 estimate, never blended
+ *  silently with provider-reported numbers. */
+export const NormalizedUsageSchema = z.object({
+    inputTokens: z.number().int().nonnegative().optional(),
+    outputTokens: z.number().int().nonnegative().optional(),
+    cacheReadTokens: z.number().int().nonnegative().optional(),
+    cacheWriteTokens: z.number().int().nonnegative().optional(),
+    estimated: z.boolean(),
+    reportedCostUsd: z.number().nonnegative().optional(),
+});
 /** One provider call's accounting entry (§15 "per-call timings"). */
 export const CallRecord = z.object({
     provider: ProviderIdSchema,
@@ -954,6 +1044,7 @@ export const CallRecord = z.object({
     category: z.enum(['discovery', 'verification', 'repair', 'planning']).optional(),
     durationMs: z.number().nonnegative(),
     error: z.enum(['NOT_FOUND', 'AUTH', 'QUOTA', 'TIMEOUT', 'BAD_OUTPUT', 'CRASH']).optional(),
+    usage: NormalizedUsageSchema.optional(),
 });
 /** How read-only was actually enforced per provider (§15, §19). Mirrors providers ReadOnlyFlag. */
 const ReadOnlyFlagSchema = z.enum(['plan', 'sandbox', 'none']);
@@ -981,17 +1072,35 @@ export const RunMeta = z.object({
         repair: z.number().int().nonnegative(),
         planning: z.number().int().nonnegative(),
     }).optional(),
+    usage_totals: z.object({
+        inputTokens: z.number().int().nonnegative(),
+        outputTokens: z.number().int().nonnegative(),
+        reportedCalls: z.number().int().nonnegative(),
+        estimatedCalls: z.number().int().nonnegative(),
+        reportedCostUsd: z.number().nonnegative().optional(),
+    }).optional(),
+    // v7 Phase B: present only when the user ran `--mode auto`; records the resolved mode + why.
+    auto_decision: z.object({
+        resolved: z.enum(['quick', 'council']),
+        reasons: z.array(z.string()),
+        fast_path: z.boolean().optional(),
+        escalation_reasons: z.array(z.string().min(1)).optional(),
+    }).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',
+        'weak_seat',
         'plan_skipped',
         'plan_fallback',
+        'plan_partial',
         'headless_intent',
         'verification_skipped',
         'research_ungrounded',
+        'source_fallback_search',
+        'deliverable_gap',
         'single_model',
     ])).optional(),
 });