@sanity/ailf 4.6.0 → 6.0.0

package/dist/_vendor/ailf-core/services/diagnosis/card-validators.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared Zod `.refine()` helpers for diagnosis card body schemas (D-05).
+ *
+ * Card body schemas that mention failure modes MUST encode `dimension` AND
+ * call `.refine(buildFailureModeRefinement())` to prevent cross-dimension
+ * hallucinations from passing Zod (CONTEXT D-05). The refinement turns a
+ * "Zod-passes, semantically wrong" LLM output into a `parseFailed: true`
+ * degraded card, which the budget logic then absorbs.
+ *
+ * This file is a sibling of cards/ (NOT inside cards/), so it is NOT inside
+ * the D0045 trust-boundary scan root. It is a pure utility, not a boundary
+ * parser.
+ *
+ * @see packages/core/src/grader/failure-modes/index.ts
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-CONTEXT.md (D-05)
+ */
+/**
+ * Returns `true` when the `failureMode` in `body` is in the canonical
+ * taxonomy for `body.dimension`. Used directly and via `buildFailureModeRefinement`.
+ */
+export declare function isFailureModeInDimensionTaxonomy(body: {
+    dimension: string;
+    failureMode: string;
+}): boolean;
+/**
+ * Returns a Zod `.refine()` predicate that approves canonical
+ * (dimension, failureMode) pairs and rejects cross-dimension pairs.
+ *
+ * Usage:
+ * ```ts
+ * export const FailureModeSummaryBodySchema = z
+ *   .object({ dimension: z.string(), failureMode: z.string(), ... })
+ *   .refine(buildFailureModeRefinement(), {
+ *     message: "failureMode not in canonical taxonomy for this dimension",
+ *   }) satisfies z.ZodType<FailureModeSummaryBody>
+ * ```
+ */
+export declare function buildFailureModeRefinement<TBody extends {
+    dimension: string;
+    failureMode: string;
+}>(): (body: TBody) => boolean;

package/dist/_vendor/ailf-core/services/diagnosis/card-validators.js

@@ -0,0 +1,40 @@
+/**
+ * Shared Zod `.refine()` helpers for diagnosis card body schemas (D-05).
+ *
+ * Card body schemas that mention failure modes MUST encode `dimension` AND
+ * call `.refine(buildFailureModeRefinement())` to prevent cross-dimension
+ * hallucinations from passing Zod (CONTEXT D-05). The refinement turns a
+ * "Zod-passes, semantically wrong" LLM output into a `parseFailed: true`
+ * degraded card, which the budget logic then absorbs.
+ *
+ * This file is a sibling of cards/ (NOT inside cards/), so it is NOT inside
+ * the D0045 trust-boundary scan root. It is a pure utility, not a boundary
+ * parser.
+ *
+ * @see packages/core/src/grader/failure-modes/index.ts
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-CONTEXT.md (D-05)
+ */
+import { failureModesForDimension } from "../../grader/failure-modes/index.js";
+/**
+ * Returns `true` when the `failureMode` in `body` is in the canonical
+ * taxonomy for `body.dimension`. Used directly and via `buildFailureModeRefinement`.
+ */
+export function isFailureModeInDimensionTaxonomy(body) {
+    return failureModesForDimension(body.dimension).includes(body.failureMode);
+}
+/**
+ * Returns a Zod `.refine()` predicate that approves canonical
+ * (dimension, failureMode) pairs and rejects cross-dimension pairs.
+ *
+ * Usage:
+ * ```ts
+ * export const FailureModeSummaryBodySchema = z
+ *   .object({ dimension: z.string(), failureMode: z.string(), ... })
+ *   .refine(buildFailureModeRefinement(), {
+ *     message: "failureMode not in canonical taxonomy for this dimension",
+ *   }) satisfies z.ZodType<FailureModeSummaryBody>
+ * ```
+ */
+export function buildFailureModeRefinement() {
+    return (body) => isFailureModeInDimensionTaxonomy(body);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * area-summary.test.ts — Tests 1-4 for the deterministic area-summary card.
+ *
+ * D0042: vitest only, no node:test.
+ * D0045: AreaSummaryBodySchema satisfies z.ZodType<AreaSummaryBody> compile-time gate.
+ */
+export {};

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

@@ -0,0 +1,131 @@
+/**
+ * area-summary.test.ts — Tests 1-4 for the deterministic area-summary card.
+ *
+ * D0042: vitest only, no node:test.
+ * D0045: AreaSummaryBodySchema satisfies z.ZodType<AreaSummaryBody> compile-time gate.
+ */
+import { describe, expect, it } from "vitest";
+import { AreaSummaryBodySchema, generateAreaSummary } from "../area-summary.js";
+// Test 1: schema satisfies compile-time gate
+const _satisfiesCheck = AreaSummaryBodySchema;
+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: "groq",
+            lowestScore: Math.min(...(scores.length ? scores : [0])),
+            overall: {
+                avgCeilingScore: 80,
+                avgScore: 75,
+                avgDocLift: 5,
+                avgDocQualityGap: 20,
+                avgFloorScore: 70,
+                negativeDocLiftCount: 0,
+            },
+            scores: scores.map((s, i) => ({
+                feature: `area-${i + 1}`,
+                ceilingScore: 80,
+                codeCorrectness: s,
+                docCoverage: s,
+                docLift: 5,
+                docQualityGap: 20,
+                floorScore: s - 5,
+                negativeDocLift: false,
+                taskCompletion: s,
+                testCount: 10,
+                totalCost: 0.05,
+                totalScore: s,
+            })),
+        },
+    };
+}
+describe("AreaSummaryBodySchema (Test 1)", () => {
+    it("satisfies z.ZodType<AreaSummaryBody> (compile-time check assigned above)", () => {
+        // Runtime check: valid payload parses successfully
+        const result = AreaSummaryBodySchema.safeParse({ summary: "test summary" });
+        expect(result.success).toBe(true);
+        // The _satisfiesCheck assignment above is the actual compile-time gate
+        expect(_satisfiesCheck).toBeDefined();
+    });
+});
+describe("generateAreaSummary (Test 2)", () => {
+    it("returns a ready card with summary including area count and mean score for 3 areas at [80, 60, 70]", async () => {
+        const report = makeReportWithScores([80, 60, 70]);
+        const card = await generateAreaSummary(report, makeCtx());
+        expect(card.status).toBe("ready");
+        if (card.status === "ready") {
+            expect(card.cardType).toBe("area-summary");
+            expect(card.meta.cardVersion).toBe("area-summary@0.1.0");
+            expect(card.meta.generatedAt).toBeTruthy();
+        }
+    });
+});
+describe("generateAreaSummary — summary content (Test 3)", () => {
+    it("summary includes BOTH the area count AND mean score to one decimal", async () => {
+        const report = makeReportWithScores([80, 60, 70]);
+        const card = await generateAreaSummary(report, makeCtx());
+        expect(card.status).toBe("ready");
+        if (card.status === "ready") {
+            const body = card.body;
+            // Mean of [80, 60, 70] = 70.0
+            expect(body.summary).toContain("3");
+            expect(body.summary).toContain("70.0");
+        }
+    });
+});
+describe("generateAreaSummary — zero areas guard (Test 4)", () => {
+    it("returns missing card with 'report has no areas' reason for zero-area report", async () => {
+        const report = makeReportWithScores([]);
+        const card = await generateAreaSummary(report, makeCtx());
+        expect(card.status).toBe("missing");
+        if (card.status === "missing") {
+            expect(card.cardType).toBe("area-summary");
+            expect(card.reason).toContain("no areas");
+        }
+    });
+});

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

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export {};

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

@@ -0,0 +1,171 @@
+/**
+ * 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");
+        }
+    });
+});

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;