@sanity/ailf 5.0.0 → 6.1.0

package/dist/_vendor/ailf-core/services/diagnosis/cards/__tests__/failure-mode-summary.test.js

@@ -0,0 +1,230 @@
+/**
+ * failure-mode-summary.test.ts — Tests 5-9 for deterministic failure-mode-summary card.
+ *
+ * D0042: vitest only.
+ * D-05: schema must reject cross-dimension (dimension, failureMode) pairs.
+ */
+import { describe, expect, it } from "vitest";
+import { FailureModeSummaryBodySchema, generateFailureModeSummary, } from "../failure-mode-summary.js";
+import { failureModesForDimension } from "../../../../grader/failure-modes/index.js";
+// Compile-time gate
+const _satisfiesCheck = FailureModeSummaryBodySchema;
+const silentLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    step: () => { },
+    section: () => { },
+    table: () => { },
+};
+const noopProgress = {
+    phaseStart: () => { },
+    phaseProgress: () => { },
+    phaseComplete: () => { },
+};
+function makeCtx() {
+    return {
+        llm: undefined,
+        model: "anthropic:claude-sonnet-4-6",
+        logger: silentLogger,
+        progress: noopProgress,
+        versions: {
+            graderJudgmentsVersion: "1.0.0",
+            ensembleVersion: "1.0.0",
+            diagnosisVersion: "0.1.0",
+            cardVersion: "1.0.0",
+        },
+        runId: "run-001",
+        reportId: "report-001",
+    };
+}
+function makeReport(failureModes) {
+    return {
+        id: "report-001",
+        completedAt: "2026-01-01T00:00:00Z",
+        durationMs: 1000,
+        provenance: {
+            runId: "run-001",
+            mode: "standard",
+            areas: [],
+            taskIds: [],
+            models: [],
+            graderModel: "gpt-4o",
+            source: "local",
+            evalFingerprint: "",
+            trigger: "manual",
+            git: undefined,
+        },
+        summary: {
+            belowCritical: [],
+            lowestArea: "groq",
+            lowestScore: 50,
+            overall: {
+                avgCeilingScore: 80,
+                avgScore: 70,
+                avgDocLift: 5,
+                avgDocQualityGap: 20,
+                avgFloorScore: 65,
+                negativeDocLiftCount: 0,
+            },
+            scores: [
+                {
+                    feature: "groq",
+                    ceilingScore: 80,
+                    codeCorrectness: 70,
+                    docCoverage: 65,
+                    docLift: 5,
+                    docQualityGap: 20,
+                    floorScore: 65,
+                    negativeDocLift: false,
+                    taskCompletion: 70,
+                    testCount: 10,
+                    totalCost: 0.05,
+                    totalScore: 70,
+                },
+            ],
+            failureModes,
+        },
+    };
+}
+describe("FailureModeSummaryBodySchema — field structure (Test 5)", () => {
+    it("includes dimension, failureMode, count, sampleSize, summary fields", () => {
+        const canonicalMode = failureModesForDimension("task-completion")[0];
+        const result = FailureModeSummaryBodySchema.safeParse({
+            summary: "test summary",
+            dimension: "task-completion",
+            failureMode: canonicalMode,
+            count: 5,
+            sampleSize: 20,
+        });
+        expect(result.success).toBe(true);
+        // compile-time gate
+        expect(_satisfiesCheck).toBeDefined();
+    });
+});
+describe("FailureModeSummaryBodySchema — D-05 refine rejects cross-dimension (Test 6)", () => {
+    it("rejects mcp-tool-not-found for task-completion dimension", () => {
+        // "mcp-tool-not-found" doesn't exist in the taxonomy but we want to test
+        // cross-dimension hallucination. Use a valid MCP mode in a literacy dimension.
+        const mcpOnlyMode = "spec-mismatch"; // valid for mcp-behavior, not task-completion
+        const result = FailureModeSummaryBodySchema.safeParse({
+            summary: "test",
+            dimension: "task-completion",
+            failureMode: mcpOnlyMode,
+            count: 1,
+            sampleSize: 5,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe("FailureModeSummaryBodySchema — accepts canonical pair (Test 7)", () => {
+    it("accepts a valid (dimension, failureMode) pair from the taxonomy", () => {
+        const canonicalMode = failureModesForDimension("task-completion")[0];
+        const result = FailureModeSummaryBodySchema.safeParse({
+            summary: "test summary about missing docs",
+            dimension: "task-completion",
+            failureMode: canonicalMode,
+            count: 3,
+            sampleSize: 15,
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe("generateFailureModeSummary — happy path (Test 8)", () => {
+    it("returns a ready card with the dominant failure mode for a report with failure modes", async () => {
+        const canonicalMode = failureModesForDimension("task-completion")[0];
+        const report = makeReport({
+            counts: { "task-completion": 7 },
+            topTitles: [
+                {
+                    id: `task-completion::${canonicalMode}`,
+                    category: canonicalMode,
+                    severity: "high",
+                    title: canonicalMode,
+                    count: 7,
+                },
+            ],
+            totalJudgments: 20,
+            classificationRate: 0.35,
+        });
+        const card = await generateFailureModeSummary(report, makeCtx());
+        expect(card.status).toBe("ready");
+        if (card.status === "ready") {
+            expect(card.cardType).toBe("failure-mode-summary");
+            expect(card.meta.cardVersion).toBe("failure-mode-summary@0.1.0");
+            const body = card.body;
+            expect(body.count).toBeGreaterThan(0);
+        }
+    });
+});
+describe("generateFailureModeSummary — empty failure modes (Test 9)", () => {
+    it("returns missing card when report has no failure modes", async () => {
+        const report = makeReport(undefined);
+        const card = await generateFailureModeSummary(report, makeCtx());
+        expect(card.status).toBe("missing");
+        if (card.status === "missing") {
+            expect(card.cardType).toBe("failure-mode-summary");
+            expect(card.reason).toContain("no failure modes");
+        }
+    });
+});
+describe("generateFailureModeSummary — cross-cutting mode resolution", () => {
+    // `missing-docs` appears in both LITERACY_FAILURE_MODES and MCP_FAILURE_MODES.
+    // Before the per-EvalMode preference table, linear scan of CANONICAL_DIMENSIONS
+    // always resolved it to task-completion, mislabelling MCP-only runs.
+    function withMode(report, mode) {
+        return {
+            ...report,
+            provenance: { ...report.provenance, mode },
+        };
+    }
+    it("resolves 'missing-docs' to mcp-behavior on an mcp-server report", async () => {
+        const base = makeReport({
+            counts: { "mcp-behavior": 7 },
+            topTitles: [
+                {
+                    id: "mcp-behavior::missing-docs",
+                    category: "missing-docs",
+                    severity: "high",
+                    title: "missing-docs",
+                    count: 7,
+                },
+            ],
+            totalJudgments: 20,
+            classificationRate: 0.35,
+        });
+        const report = withMode(base, "mcp-server");
+        const card = await generateFailureModeSummary(report, makeCtx());
+        expect(card.status).toBe("ready");
+        if (card.status === "ready") {
+            const body = card.body;
+            expect(body.dimension).toBe("mcp-behavior");
+            expect(body.failureMode).toBe("missing-docs");
+        }
+    });
+    it("resolves 'missing-docs' to task-completion on a literacy report", async () => {
+        const base = makeReport({
+            counts: { "task-completion": 7 },
+            topTitles: [
+                {
+                    id: "task-completion::missing-docs",
+                    category: "missing-docs",
+                    severity: "high",
+                    title: "missing-docs",
+                    count: 7,
+                },
+            ],
+            totalJudgments: 20,
+            classificationRate: 0.35,
+        });
+        const report = withMode(base, "literacy");
+        const card = await generateFailureModeSummary(report, makeCtx());
+        expect(card.status).toBe("ready");
+        if (card.status === "ready") {
+            const body = card.body;
+            expect(body.dimension).toBe("task-completion");
+            expect(body.failureMode).toBe("missing-docs");
+        }
+    });
+});

package/dist/_vendor/ailf-core/services/diagnosis/cards/__tests__/no-issues.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * no-issues.test.ts — Tests 10-12 for the deterministic no-issues card.
+ *
+ * D0042: vitest only.
+ * AI-SPEC §1b failure-mode #7: sycophancy guard — firing rate ≤30%.
+ */
+export {};

package/dist/_vendor/ailf-core/services/diagnosis/cards/__tests__/no-issues.test.js

@@ -0,0 +1,155 @@
+/**
+ * no-issues.test.ts — Tests 10-12 for the deterministic no-issues card.
+ *
+ * D0042: vitest only.
+ * AI-SPEC §1b failure-mode #7: sycophancy guard — firing rate ≤30%.
+ */
+import { describe, expect, it } from "vitest";
+import { NO_ISSUES_THRESHOLD, NoIssuesBodySchema, generateNoIssues, } from "../no-issues.js";
+// Compile-time gate
+const _satisfiesCheck = NoIssuesBodySchema;
+const silentLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    step: () => { },
+    section: () => { },
+    table: () => { },
+};
+const noopProgress = {
+    phaseStart: () => { },
+    phaseProgress: () => { },
+    phaseComplete: () => { },
+};
+function makeCtx() {
+    return {
+        llm: undefined,
+        model: "anthropic:claude-sonnet-4-6",
+        logger: silentLogger,
+        progress: noopProgress,
+        versions: {
+            graderJudgmentsVersion: "1.0.0",
+            ensembleVersion: "1.0.0",
+            diagnosisVersion: "0.1.0",
+            cardVersion: "1.0.0",
+        },
+        runId: "run-001",
+        reportId: "report-001",
+    };
+}
+function makeReportWithScores(scores) {
+    return {
+        id: "report-001",
+        completedAt: "2026-01-01T00:00:00Z",
+        durationMs: 1000,
+        provenance: {
+            runId: "run-001",
+            mode: "standard",
+            areas: [],
+            taskIds: [],
+            models: [],
+            graderModel: "gpt-4o",
+            source: "local",
+            evalFingerprint: "",
+            trigger: "manual",
+            git: undefined,
+        },
+        summary: {
+            belowCritical: [],
+            lowestArea: scores.length ? `area-0` : "",
+            lowestScore: scores.length ? Math.min(...scores) : 0,
+            overall: {
+                avgCeilingScore: 90,
+                avgScore: scores.length
+                    ? scores.reduce((a, b) => a + b, 0) / scores.length
+                    : 0,
+                avgDocLift: 5,
+                avgDocQualityGap: 10,
+                avgFloorScore: 80,
+                negativeDocLiftCount: 0,
+            },
+            scores: scores.map((s, i) => ({
+                feature: `area-${i}`,
+                ceilingScore: 95,
+                codeCorrectness: s,
+                docCoverage: s,
+                docLift: 5,
+                docQualityGap: 5,
+                floorScore: s - 5,
+                negativeDocLift: false,
+                taskCompletion: s,
+                testCount: 10,
+                totalCost: 0.05,
+                totalScore: s,
+            })),
+        },
+    };
+}
+describe("NO_ISSUES_THRESHOLD (Test 10)", () => {
+    it("is exported as a const with a numeric value", () => {
+        expect(typeof NO_ISSUES_THRESHOLD).toBe("number");
+        expect(NO_ISSUES_THRESHOLD).toBeGreaterThan(0);
+        expect(NO_ISSUES_THRESHOLD).toBeLessThanOrEqual(100);
+        // compile-time gate
+        expect(_satisfiesCheck).toBeDefined();
+    });
+});
+describe("generateNoIssues — ready when all areas ≥ threshold (Test 11a)", () => {
+    it("returns ready card with thresholdScore when all areas score ≥ threshold", async () => {
+        const scores = [
+            NO_ISSUES_THRESHOLD,
+            NO_ISSUES_THRESHOLD + 5,
+            NO_ISSUES_THRESHOLD + 10,
+        ];
+        const report = makeReportWithScores(scores);
+        const card = await generateNoIssues(report, makeCtx());
+        expect(card.status).toBe("ready");
+        if (card.status === "ready") {
+            expect(card.cardType).toBe("no-issues");
+            expect(card.meta.cardVersion).toBe("no-issues@0.1.0");
+            const body = card.body;
+            expect(body.thresholdScore).toBe(NO_ISSUES_THRESHOLD);
+            expect(body.summary).toBeTruthy();
+        }
+    });
+});
+describe("generateNoIssues — missing when any area below threshold (Test 11b)", () => {
+    it("returns missing when at least one area scores below the threshold", async () => {
+        const scores = [NO_ISSUES_THRESHOLD - 1, NO_ISSUES_THRESHOLD + 10];
+        const report = makeReportWithScores(scores);
+        const card = await generateNoIssues(report, makeCtx());
+        expect(card.status).toBe("missing");
+        if (card.status === "missing") {
+            expect(card.cardType).toBe("no-issues");
+            expect(card.reason).toContain("below threshold");
+        }
+    });
+});
+describe("generateNoIssues — calibration firing rate ≤30% (Test 12)", () => {
+    it("fires ≤30% on a 10-report fixture set spanning low to high scores", async () => {
+        // 10 reports with scores from 0 to 100 in 10-point increments
+        // Only reports where ALL areas are ≥ NO_ISSUES_THRESHOLD should fire
+        const fixtureSet = [
+            makeReportWithScores([0, 10]), // far below threshold
+            makeReportWithScores([20, 30]), // below threshold
+            makeReportWithScores([40, 50]), // below threshold
+            makeReportWithScores([60, 65]), // likely below threshold (≤85)
+            makeReportWithScores([70, 75]), // below threshold if threshold=85
+            makeReportWithScores([75, 80]), // below threshold if threshold=85
+            makeReportWithScores([80, 82]), // below threshold if threshold=85
+            makeReportWithScores([90, 92]), // above threshold
+            makeReportWithScores([95, 97]), // above threshold
+            makeReportWithScores([98, 99]), // above threshold
+        ];
+        const ctx = makeCtx();
+        let firingCount = 0;
+        for (const report of fixtureSet) {
+            const card = await generateNoIssues(report, ctx);
+            if (card.status === "ready")
+                firingCount++;
+        }
+        const firingRate = firingCount / fixtureSet.length;
+        expect(firingRate).toBeLessThanOrEqual(0.3);
+    });
+});

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

@@ -0,0 +1,17 @@
+/**
+ * area-summary card — deterministic projection over Report.summary.scores.
+ *
+ * Pure computation, no LLM call. Produces a human-readable sentence
+ * summarizing the number of evaluated areas and their mean composite score.
+ *
+ * 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 lines 569-587
+ */
+import { z } from "zod";
+import type { CardGenerator } from "../../diagnosis-runner.js";
+export declare const AreaSummaryBodySchema: z.ZodObject<{
+    summary: z.ZodString;
+}, z.core.$strip>;
+export declare const generateAreaSummary: CardGenerator;

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

@@ -0,0 +1,43 @@
+/**
+ * area-summary card — deterministic projection over Report.summary.scores.
+ *
+ * Pure computation, no LLM call. Produces a human-readable sentence
+ * summarizing the number of evaluated areas and their mean composite score.
+ *
+ * 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 lines 569-587
+ */
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Body schema (D0045 trust boundary — satisfies required)
+// ---------------------------------------------------------------------------
+export const AreaSummaryBodySchema = z.object({
+    summary: z.string().min(1).max(500),
+});
+// ---------------------------------------------------------------------------
+// Generator
+// ---------------------------------------------------------------------------
+export const generateAreaSummary = async (report) => {
+    const scores = report.summary.scores;
+    if (!scores || scores.length === 0) {
+        return {
+            status: "missing",
+            cardType: "area-summary",
+            reason: "report has no areas",
+        };
+    }
+    const meanScore = scores.reduce((sum, s) => sum + s.totalScore, 0) / scores.length;
+    const summary = `Across ${scores.length} areas, mean score ${meanScore.toFixed(1)}.`;
+    const body = AreaSummaryBodySchema.parse({ summary });
+    return {
+        status: "ready",
+        cardType: "area-summary",
+        body,
+        meta: {
+            cardVersion: "area-summary@0.1.0",
+            generatedAt: new Date().toISOString(),
+        },
+    };
+};

package/dist/_vendor/ailf-core/services/diagnosis/cards/doc-attribution-spotlight.d.ts

@@ -0,0 +1,46 @@
+/**
+ * doc-attribution-spotlight card — LLM-driven doc-citation spotlight.
+ *
+ * Model: claude-sonnet-4-6 (routine per AI-SPEC §4 model routing)
+ * Version: doc-attribution-spotlight@0.1.0
+ *
+ * Landmine 11: reads `ctx.judgmentAttributions` (NOT Report.summary).
+ * Returns `status: "missing"` when attributions are undefined or empty.
+ *
+ * Mitigations:
+ * - failure-mode #5: docCitations[].docSlug refined against the manifest
+ *   allow-list so hallucinated slugs fail Zod parse
+ *
+ * Schema is in the D0045 trust-boundary scan root; `satisfies` clause is
+ * mandatory.
+ *
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-RESEARCH.md (Landmine 11)
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ */
+import { z } from "zod";
+import type { CardGenerator } from "../../diagnosis-runner.js";
+/**
+ * Module-level static shape. Per-call adds the allow-list refine on docSlug.
+ */
+export declare const DocAttributionSpotlightBodySchema: z.ZodObject<{
+    summary: z.ZodString;
+    docCitations: z.ZodArray<z.ZodObject<{
+        docSlug: z.ZodString;
+        confidence: z.ZodObject<{
+            level: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+            signalsPresent: z.ZodNumber;
+            derivation: z.ZodString;
+        }, z.core.$strip>;
+        role: z.ZodEnum<{
+            missing: "missing";
+            supports: "supports";
+            contradicts: "contradicts";
+            irrelevant: "irrelevant";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const generateDocAttributionSpotlight: CardGenerator;

package/dist/_vendor/ailf-core/services/diagnosis/cards/doc-attribution-spotlight.js

@@ -0,0 +1,108 @@
+/**
+ * doc-attribution-spotlight card — LLM-driven doc-citation spotlight.
+ *
+ * Model: claude-sonnet-4-6 (routine per AI-SPEC §4 model routing)
+ * Version: doc-attribution-spotlight@0.1.0
+ *
+ * Landmine 11: reads `ctx.judgmentAttributions` (NOT Report.summary).
+ * Returns `status: "missing"` when attributions are undefined or empty.
+ *
+ * Mitigations:
+ * - failure-mode #5: docCitations[].docSlug refined against the manifest
+ *   allow-list so hallucinated slugs fail Zod parse
+ *
+ * Schema is in the D0045 trust-boundary scan root; `satisfies` clause is
+ * mandatory.
+ *
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-RESEARCH.md (Landmine 11)
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ */
+import { z } from "zod";
+import { ConfidenceSchema } from "../../../schemas/confidence-schema.js";
+import { modelId as mkModelId } from "../../../ports/llm-client.js";
+import { buildDocAttributionSpotlightPrompt, buildDocSlugAllowList, } from "../prompt-builders.js";
+// ---------------------------------------------------------------------------
+// Body schema (D0045 trust boundary — satisfies required)
+// ---------------------------------------------------------------------------
+/**
+ * Module-level static shape. Per-call adds the allow-list refine on docSlug.
+ */
+export const DocAttributionSpotlightBodySchema = z.object({
+    summary: z.string().min(1).max(800),
+    docCitations: z
+        .array(z.object({
+        docSlug: z.string().min(1),
+        confidence: ConfidenceSchema,
+        role: z.enum(["supports", "contradicts", "missing", "irrelevant"]),
+    }))
+        .min(1)
+        .max(5),
+});
+// ---------------------------------------------------------------------------
+// Generator
+// ---------------------------------------------------------------------------
+const CARD_MODEL = mkModelId("anthropic:claude-sonnet-4-6");
+export const generateDocAttributionSpotlight = async (report, ctx) => {
+    // C1: no LLM → missing
+    if (!ctx.llm) {
+        return {
+            status: "missing",
+            cardType: "doc-attribution-spotlight",
+            reason: "no LLMClient wired",
+        };
+    }
+    // D1: Landmine 11 — short-circuit BEFORE calling LLM when no attribution data
+    if (!ctx.judgmentAttributions || ctx.judgmentAttributions.length === 0) {
+        return {
+            status: "missing",
+            cardType: "doc-attribution-spotlight",
+            reason: "no attribution data for this run",
+        };
+    }
+    // Build allow-list from the runtime report
+    const allowList = buildDocSlugAllowList(report);
+    // Per-call schema with docSlug allow-list refine (AI-SPEC §3 Pitfall 1)
+    const PerCallSchema = z.object({
+        summary: z.string().min(1).max(800),
+        docCitations: z
+            .array(z.object({
+            docSlug: z
+                .string()
+                .min(1)
+                .refine((slug) => allowList.has(slug), {
+                message: "docCitations[].docSlug is not in the report document manifest allow-list",
+            }),
+            confidence: ConfidenceSchema,
+            role: z.enum(["supports", "contradicts", "missing", "irrelevant"]),
+        }))
+            .min(1)
+            .max(5),
+    });
+    const prompt = buildDocAttributionSpotlightPrompt(report, ctx.judgmentAttributions);
+    // Destructure `cost` and `model` from the LLMClient return —
+    // already provided per llm-client.ts:139-144, previously discarded.
+    const { value, usage, cost, model } = 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: "doc-attribution-spotlight",
+        },
+    });
+    return {
+        status: "ready",
+        cardType: "doc-attribution-spotlight",
+        body: value,
+        meta: {
+            cardVersion: "doc-attribution-spotlight@0.1.0",
+            tokenUsage: { input: usage.promptTokens, output: usage.completionTokens },
+            generatedAt: new Date().toISOString(),
+            cost,
+            model,
+        },
+    };
+};

package/dist/_vendor/ailf-core/services/diagnosis/cards/failure-mode-summary.d.ts

@@ -0,0 +1,28 @@
+/**
+ * failure-mode-summary card — deterministic projection over Report.summary.failureModes.
+ *
+ * Pure computation, no LLM call. Identifies the dominant failure mode
+ * across all dimensions in the report's slim failure-mode summary.
+ *
+ * D-05: `.refine(buildFailureModeRefinement())` rejects cross-dimension
+ * (dimension, failureMode) pairs that the schema otherwise would accept —
+ * turning a "Zod-passes, semantically wrong" LLM output into a
+ * `parseFailed: true` degraded card. For this deterministic card, the
+ * refinement also defends against bad Report data.
+ *
+ * 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-CONTEXT.md (D-05)
+ * @see packages/core/src/services/diagnosis/card-validators.ts
+ */
+import { z } from "zod";
+import type { CardGenerator } from "../../diagnosis-runner.js";
+export declare const FailureModeSummaryBodySchema: z.ZodObject<{
+    summary: z.ZodString;
+    dimension: z.ZodString;
+    failureMode: z.ZodString;
+    count: z.ZodNumber;
+    sampleSize: z.ZodNumber;
+}, z.core.$strip>;
+export declare const generateFailureModeSummary: CardGenerator;