@sanity/ailf 4.6.0 → 6.0.0

package/dist/_vendor/ailf-core/services/diagnosis/cards/regression-vs-baseline.js

@@ -0,0 +1,126 @@
+/**
+ * regression-vs-baseline card — LLM-driven run comparison card.
+ *
+ * Model: claude-opus-4-6 (high-stakes per AI-SPEC §4 model routing)
+ * Version: regression-vs-baseline@0.1.0
+ *
+ * DIAG-05: emits ONLY when `ctx.baseline` is set. When baseline is absent,
+ * returns `status: "missing", reason: "no --compare baseline supplied"`.
+ *
+ * Mitigations:
+ * - failure-mode #1: `buildRegressionVsBaselinePrompt` computes deltas in JS
+ *   BEFORE the LLM call; schema refine asserts sign-consistency (R3)
+ *
+ * Schema is in the D0045 trust-boundary scan root; `satisfies` clause is
+ * mandatory.
+ *
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §3 lines 603-664
+ */
+import { z } from "zod";
+import { modelId as mkModelId } from "../../../ports/llm-client.js";
+import { buildRegressionVsBaselinePrompt } from "../prompt-builders.js";
+// ---------------------------------------------------------------------------
+// Helper: direction sign check
+// ---------------------------------------------------------------------------
+/**
+ * Map direction label to its expected sign. Returns the expected sign:
+ * +1 for improved, -1 for regressed, 0 for unchanged.
+ */
+function directionSign(direction) {
+    if (direction === "improved")
+        return 1;
+    if (direction === "regressed")
+        return -1;
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Body schema (D0045 trust boundary — satisfies required)
+// ---------------------------------------------------------------------------
+/**
+ * Module-level static shape only. Per-call adds:
+ * - sign-consistency refine (R3): Math.sign(pointsDelta) === directionSign(direction)
+ */
+export const RegressionVsBaselineBodySchema = z.object({
+    summary: z.string().min(1).max(800),
+    deltas: z
+        .array(z.object({
+        area: z.string().min(1),
+        direction: z.enum(["improved", "regressed", "unchanged"]),
+        pointsDelta: z.number(),
+        drivers: z.array(z.string()),
+    }))
+        .max(10),
+    overallTrend: z.enum(["net-improved", "net-regressed", "mixed", "stable"]),
+});
+// ---------------------------------------------------------------------------
+// Generator
+// ---------------------------------------------------------------------------
+const CARD_MODEL = mkModelId("anthropic:claude-opus-4-6");
+export const generateRegressionVsBaseline = async (report, ctx) => {
+    // C1: no LLM → missing
+    if (!ctx.llm) {
+        return {
+            status: "missing",
+            cardType: "regression-vs-baseline",
+            reason: "no LLMClient wired",
+        };
+    }
+    // R1: DIAG-05 no-auto-comparison — only emits when baseline is supplied
+    if (!ctx.baseline) {
+        return {
+            status: "missing",
+            cardType: "regression-vs-baseline",
+            reason: "no --compare baseline supplied",
+        };
+    }
+    // Compute deltas in JS BEFORE the LLM call (failure-mode #1 mitigation).
+    // The prompt embeds the precomputed numbers so the LLM cannot fabricate deltas.
+    const { system, user } = buildRegressionVsBaselinePrompt(report, ctx.baseline);
+    // Per-call schema: additive R3 sign-consistency refine
+    // (AI-SPEC §3 Pitfall 1 — schema local to generator, not module scope)
+    const PerCallSchema = z
+        .object({
+        summary: z.string().min(1).max(800),
+        deltas: z
+            .array(z.object({
+            area: z.string().min(1),
+            direction: z.enum(["improved", "regressed", "unchanged"]),
+            pointsDelta: z.number(),
+            drivers: z.array(z.string()),
+        }))
+            .max(10),
+        overallTrend: z.enum([
+            "net-improved",
+            "net-regressed",
+            "mixed",
+            "stable",
+        ]),
+    })
+        // R3: sign-consistency guardrail — LLM must not invert direction vs delta
+        .refine((body) => body.deltas.every((d) => Math.sign(d.pointsDelta) === directionSign(d.direction)), {
+        message: "direction label must match sign of pointsDelta (improved=positive, regressed=negative, unchanged=zero)",
+        path: ["deltas"],
+    });
+    const { value, usage } = await ctx.llm.completeStructured({
+        model: CARD_MODEL,
+        prompt: `${system}\n\n${user}`,
+        schema: PerCallSchema,
+        temperature: 0.1,
+        maxTokens: 2000,
+        context: {
+            feature: "diagnosis",
+            runId: ctx.runId,
+            cardId: "regression-vs-baseline",
+        },
+    });
+    return {
+        status: "ready",
+        cardType: "regression-vs-baseline",
+        body: value,
+        meta: {
+            cardVersion: "regression-vs-baseline@0.1.0",
+            tokenUsage: { input: usage.promptTokens, output: usage.completionTokens },
+            generatedAt: new Date().toISOString(),
+        },
+    };
+};

package/dist/_vendor/ailf-core/services/diagnosis/cards/top-recommendations.d.ts

@@ -0,0 +1,41 @@
+/**
+ * top-recommendations card — LLM-driven actionable suggestion generator.
+ *
+ * Model: claude-opus-4-6 (high-stakes per AI-SPEC §4 model routing)
+ * Version: top-recommendations@0.1.0
+ *
+ * Mitigations:
+ * - failure-mode #2: few-shot examples in system prompt; body ≥40 chars
+ * - failure-mode #5: docSlug refined against report manifest allow-list
+ *
+ * Schema is in the D0045 trust-boundary scan root; `satisfies` clause is
+ * mandatory (cards/ is a SCAN_ROOT in check-trust-boundary-satisfies.ts).
+ *
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §3
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §4
+ */
+import { z } from "zod";
+import type { CardGenerator } from "../../diagnosis-runner.js";
+/**
+ * Module-level schema: static shape check only.
+ * Per-call: an additive `.refine()` over the allow-list (built inside the
+ * generator so it closes over the runtime `report`).
+ *
+ * AI-SPEC §3 Pitfall 1: per-call schemas are LOCAL to the generator,
+ * NOT at module scope.
+ */
+export declare const TopRecommendationsBodySchema: z.ZodObject<{
+    summary: z.ZodString;
+    suggestions: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        priority: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        docSlug: z.ZodString;
+        sectionHeading: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const generateTopRecommendations: CardGenerator;

package/dist/_vendor/ailf-core/services/diagnosis/cards/top-recommendations.js

@@ -0,0 +1,107 @@
+/**
+ * top-recommendations card — LLM-driven actionable suggestion generator.
+ *
+ * Model: claude-opus-4-6 (high-stakes per AI-SPEC §4 model routing)
+ * Version: top-recommendations@0.1.0
+ *
+ * Mitigations:
+ * - failure-mode #2: few-shot examples in system prompt; body ≥40 chars
+ * - failure-mode #5: docSlug refined against report manifest allow-list
+ *
+ * Schema is in the D0045 trust-boundary scan root; `satisfies` clause is
+ * mandatory (cards/ is a SCAN_ROOT in check-trust-boundary-satisfies.ts).
+ *
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §3
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §4
+ */
+import { z } from "zod";
+import { modelId as mkModelId } from "../../../ports/llm-client.js";
+import { buildTopRecommendationsPrompt, buildDocSlugAllowList, } from "../prompt-builders.js";
+// ---------------------------------------------------------------------------
+// Body schema (D0045 trust boundary — satisfies required)
+// ---------------------------------------------------------------------------
+/**
+ * Module-level schema: static shape check only.
+ * Per-call: an additive `.refine()` over the allow-list (built inside the
+ * generator so it closes over the runtime `report`).
+ *
+ * AI-SPEC §3 Pitfall 1: per-call schemas are LOCAL to the generator,
+ * NOT at module scope.
+ */
+export const TopRecommendationsBodySchema = z.object({
+    summary: z.string().min(1).max(500),
+    suggestions: z
+        .array(z.object({
+        title: z.string().min(1).max(200),
+        body: z
+            .string()
+            .min(40, "suggestion.body must be ≥40 characters")
+            .refine((b) => /`[^`]+`/.test(b), "suggestion.body must contain at least one backtick-delimited artifact"),
+        priority: z.enum(["high", "medium", "low"]),
+        docSlug: z.string().min(1),
+        sectionHeading: z.string().nullable(),
+    }))
+        .min(1)
+        .max(5),
+});
+// ---------------------------------------------------------------------------
+// Generator
+// ---------------------------------------------------------------------------
+const CARD_MODEL = mkModelId("anthropic:claude-opus-4-6");
+export const generateTopRecommendations = async (report, ctx) => {
+    // C1: no LLM → missing
+    if (!ctx.llm) {
+        return {
+            status: "missing",
+            cardType: "top-recommendations",
+            reason: "no LLMClient wired",
+        };
+    }
+    // Build allow-list from the runtime report
+    const allowList = buildDocSlugAllowList(report);
+    // Per-call schema: additive docSlug allow-list refine (AI-SPEC §3 Pitfall 1)
+    const PerCallSchema = z.object({
+        summary: z.string().min(1).max(500),
+        suggestions: z
+            .array(z.object({
+            title: z.string().min(1).max(200),
+            body: z
+                .string()
+                .min(40, "suggestion.body must be ≥40 characters")
+                .refine((b) => /`[^`]+`/.test(b), "suggestion.body must contain at least one backtick-delimited artifact"),
+            priority: z.enum(["high", "medium", "low"]),
+            docSlug: z
+                .string()
+                .min(1)
+                .refine((slug) => allowList.has(slug), {
+                message: "suggestion.docSlug is not in the report document manifest allow-list",
+            }),
+            sectionHeading: z.string().nullable(),
+        }))
+            .min(1)
+            .max(5),
+    });
+    const prompt = buildTopRecommendationsPrompt(report, allowList);
+    const { value, usage } = await ctx.llm.completeStructured({
+        model: CARD_MODEL,
+        prompt: `${prompt.system}\n\n${prompt.user}`,
+        schema: PerCallSchema,
+        temperature: 0.1,
+        maxTokens: 2000,
+        context: {
+            feature: "diagnosis",
+            runId: ctx.runId,
+            cardId: "top-recommendations",
+        },
+    });
+    return {
+        status: "ready",
+        cardType: "top-recommendations",
+        body: value,
+        meta: {
+            cardVersion: "top-recommendations@0.1.0",
+            tokenUsage: { input: usage.promptTokens, output: usage.completionTokens },
+            generatedAt: new Date().toISOString(),
+        },
+    };
+};

package/dist/_vendor/ailf-core/services/diagnosis/cards/weakest-area.d.ts

@@ -0,0 +1,43 @@
+/**
+ * weakest-area card — LLM-driven weakest area identification.
+ *
+ * Model: claude-sonnet-4-6 (routine per AI-SPEC §4 model routing)
+ * Version: weakest-area@0.1.0
+ *
+ * Mitigations:
+ * - failure-mode #3: sampleSize = report.areas[area].judgmentCount (per-call refine W2)
+ * - failure-mode #3: sampleSize < 10 → confidence.level must be "low" (per-call refine W3)
+ * - failure-mode #4: taxonomy drift → buildFailureModeRefinement() Zod predicate
+ *
+ * Per-call schemas live INSIDE the generator (AI-SPEC §3 Pitfall 1 — no
+ * module-scope mutables that change across calls).
+ *
+ * Schema is in the D0045 trust-boundary scan root; `satisfies` clause is
+ * mandatory (cards/ is a SCAN_ROOT in check-trust-boundary-satisfies.ts).
+ *
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §3
+ */
+import { z } from "zod";
+import type { CardGenerator } from "../../diagnosis-runner.js";
+/**
+ * Module-level schema asserts the static shape + taxonomy constraint (D-05).
+ * Per-call schemas add the sampleSize (W2) and small-sample confidence (W3)
+ * refinements inside the generator, since they need runtime `report` data.
+ */
+export declare const WeakestAreaBodySchema: z.ZodObject<{
+    summary: z.ZodString;
+    area: z.ZodString;
+    dimension: z.ZodString;
+    failureMode: z.ZodString;
+    sampleSize: z.ZodNumber;
+    confidence: z.ZodObject<{
+        level: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        signalsPresent: z.ZodNumber;
+        derivation: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const generateWeakestArea: CardGenerator;

package/dist/_vendor/ailf-core/services/diagnosis/cards/weakest-area.js

@@ -0,0 +1,114 @@
+/**
+ * weakest-area card — LLM-driven weakest area identification.
+ *
+ * Model: claude-sonnet-4-6 (routine per AI-SPEC §4 model routing)
+ * Version: weakest-area@0.1.0
+ *
+ * Mitigations:
+ * - failure-mode #3: sampleSize = report.areas[area].judgmentCount (per-call refine W2)
+ * - failure-mode #3: sampleSize < 10 → confidence.level must be "low" (per-call refine W3)
+ * - failure-mode #4: taxonomy drift → buildFailureModeRefinement() Zod predicate
+ *
+ * Per-call schemas live INSIDE the generator (AI-SPEC §3 Pitfall 1 — no
+ * module-scope mutables that change across calls).
+ *
+ * Schema is in the D0045 trust-boundary scan root; `satisfies` clause is
+ * mandatory (cards/ is a SCAN_ROOT in check-trust-boundary-satisfies.ts).
+ *
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §3
+ */
+import { z } from "zod";
+import { ConfidenceSchema } from "../../../schemas/confidence-schema.js";
+import { modelId as mkModelId } from "../../../ports/llm-client.js";
+import { buildFailureModeRefinement } from "../card-validators.js";
+import { buildWeakestAreaPrompt } from "../prompt-builders.js";
+// ---------------------------------------------------------------------------
+// Module-level schema: static shape + D-05 taxonomy refine
+// ---------------------------------------------------------------------------
+/**
+ * Module-level schema asserts the static shape + taxonomy constraint (D-05).
+ * Per-call schemas add the sampleSize (W2) and small-sample confidence (W3)
+ * refinements inside the generator, since they need runtime `report` data.
+ */
+export const WeakestAreaBodySchema = z
+    .object({
+    summary: z.string().min(1).max(800),
+    area: z.string().min(1),
+    dimension: z.string().min(1),
+    failureMode: z.string().min(1),
+    sampleSize: z.number().int().nonnegative(),
+    confidence: ConfidenceSchema,
+})
+    .refine(buildFailureModeRefinement(), {
+    message: "failureMode is not in the canonical taxonomy for this dimension",
+    path: ["failureMode"],
+});
+// ---------------------------------------------------------------------------
+// Generator
+// ---------------------------------------------------------------------------
+const CARD_MODEL = mkModelId("anthropic:claude-sonnet-4-6");
+export const generateWeakestArea = async (report, ctx) => {
+    // C1: no LLM → missing
+    if (!ctx.llm) {
+        return {
+            status: "missing",
+            cardType: "weakest-area",
+            reason: "no LLMClient wired",
+        };
+    }
+    const scores = report.summary.scores ?? [];
+    if (scores.length === 0) {
+        return {
+            status: "missing",
+            cardType: "weakest-area",
+            reason: "report has no areas",
+        };
+    }
+    // Per-call schema: close over report to get sampleSize + confidence constraints
+    // (AI-SPEC §3 Pitfall 1 — never hoist to module scope)
+    const PerCallSchema = z
+        .object({
+        summary: z.string().min(1).max(800),
+        area: z.string().min(1),
+        dimension: z.string().min(1),
+        failureMode: z.string().min(1),
+        sampleSize: z.number().int().nonnegative(),
+        confidence: ConfidenceSchema,
+    })
+        .refine(buildFailureModeRefinement(), {
+        message: "failureMode is not in the canonical taxonomy for this dimension",
+        path: ["failureMode"],
+    })
+        // W3: small-sample forces confidence.level = "low"
+        .refine((body) => {
+        if (body.sampleSize < 10)
+            return body.confidence.level === "low";
+        return true;
+    }, {
+        message: 'When sampleSize < 10, confidence.level must be "low"',
+        path: ["confidence", "level"],
+    });
+    const prompt = buildWeakestAreaPrompt(report);
+    const { value, usage } = await ctx.llm.completeStructured({
+        model: CARD_MODEL,
+        prompt: `${prompt.system}\n\n${prompt.user}`,
+        schema: PerCallSchema,
+        temperature: 0.1,
+        maxTokens: 2000,
+        context: {
+            feature: "diagnosis",
+            runId: ctx.runId,
+            cardId: "weakest-area",
+        },
+    });
+    return {
+        status: "ready",
+        cardType: "weakest-area",
+        body: value,
+        meta: {
+            cardVersion: "weakest-area@0.1.0",
+            tokenUsage: { input: usage.promptTokens, output: usage.completionTokens },
+            generatedAt: new Date().toISOString(),
+        },
+    };
+};

package/dist/_vendor/ailf-core/services/diagnosis/prompt-builders.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Deterministic prompt-builder helpers for the 5 LLM diagnosis cards.
+ *
+ * Each function takes typed inputs and returns `{ system, user }` strings
+ * (+ a `deltas` side-channel for regression-vs-baseline). The same inputs
+ * always produce the same output — no randomness, no side effects.
+ *
+ * Per AI-SPEC §4: input tokens are bounded by truncation; the user message
+ * projects only the fields each card needs.
+ *
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §4
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §3 lines 603-664
+ */
+import type { JudgmentAttribution } from "../../types/attribution.js";
+import type { Report } from "../../types/index.js";
+/**
+ * Build the allow-list of doc slugs for a report. This is the union of:
+ * - report.summary.documentManifest[].slug
+ * - per-score documents[].slug
+ *
+ * Only slugs (not documentIds) appear in the allow-list because the cards
+ * reference human-readable slugs. DocumentId-only entries are skipped.
+ */
+export declare function buildDocSlugAllowList(report: Report): Set<string>;
+/**
+ * Projects the 3 weakest areas + top failure modes + doc-slug allow-list
+ * into the user message (~2500 input tokens).
+ */
+export declare function buildTopRecommendationsPrompt(report: Report, allowList: Set<string>): {
+    system: string;
+    user: string;
+};
+/**
+ * Projects the single weakest area + full failure-mode breakdown.
+ */
+export declare function buildWeakestAreaPrompt(report: Report): {
+    system: string;
+    user: string;
+};
+/**
+ * Filters to low-confidence entries (or top-N if none low), produces a table
+ * for the LLM (~2000 input tokens).
+ *
+ * Caller short-circuits on empty `judgmentAttributions` BEFORE calling this.
+ */
+export declare function buildLowConfidenceAttributionPrompt(report: Report, judgmentAttributions: JudgmentAttribution[]): {
+    system: string;
+    user: string;
+};
+/**
+ * Aggregates attributions by documentId, picks top-5 by aggregate score,
+ * emits a table for the LLM.
+ *
+ * Caller short-circuits on empty `judgmentAttributions` BEFORE calling this.
+ */
+export declare function buildDocAttributionSpotlightPrompt(report: Report, judgmentAttributions: JudgmentAttribution[]): {
+    system: string;
+    user: string;
+};
+/**
+ * Computes per-area deltas in JS (failure-mode #1 mitigation), then builds
+ * the user message. Returns `deltas` as a side-channel for the per-call
+ * schema `.refine()`.
+ */
+export declare function buildRegressionVsBaselinePrompt(report: Report, baseline: Report): {
+    system: string;
+    user: string;
+    deltas: {
+        area: string;
+        pointsDelta: number;
+    }[];
+};