@sanity/ailf 4.5.0 → 5.0.0

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

@@ -0,0 +1,19 @@
+/**
+ * Diagnosis runner — engine entry point (D0048).
+ *
+ * Phase 1 lands the version constant only; the runner factory + cache
+ * lookup land in Phase 5.
+ *
+ * @see docs/decisions/D0048-engine-homes-for-cli-api-parity.md
+ * @see .planning/phases/01-foundation-contracts-cross-cutting-schemas/01-CONTEXT.md (D-02)
+ */
+/**
+ * Bumped when the runner's selection logic, prompt orchestration, or
+ * card-set composition changes in a way that should invalidate cached
+ * Diagnoses (VER-01 / D-02). Co-located here so the cache-invalidation
+ * contract test reads the canonical value.
+ *
+ * `export const` (never `export let`) — module-scope mutables leak
+ * across vitest workers (cross-cutting hazard #2).
+ */
+export declare const diagnosisVersion = "0.1.0";

package/dist/_vendor/ailf-core/services/diagnosis-runner.js

@@ -0,0 +1,19 @@
+/**
+ * Diagnosis runner — engine entry point (D0048).
+ *
+ * Phase 1 lands the version constant only; the runner factory + cache
+ * lookup land in Phase 5.
+ *
+ * @see docs/decisions/D0048-engine-homes-for-cli-api-parity.md
+ * @see .planning/phases/01-foundation-contracts-cross-cutting-schemas/01-CONTEXT.md (D-02)
+ */
+/**
+ * Bumped when the runner's selection logic, prompt orchestration, or
+ * card-set composition changes in a way that should invalidate cached
+ * Diagnoses (VER-01 / D-02). Co-located here so the cache-invalidation
+ * contract test reads the canonical value.
+ *
+ * `export const` (never `export let`) — module-scope mutables leak
+ * across vitest workers (cross-cutting hazard #2).
+ */
+export const diagnosisVersion = "0.1.0";

package/dist/_vendor/ailf-core/services/index.d.ts

@@ -13,3 +13,5 @@ export { aggregateAreas, aggregateDimensions, computeEnsembleScore, computeTaskS
 export { extractModelName, extractProvider, mergeConfig, modelMatchesMode, resolveModelVariants, } from "./config-helpers.js";
 export { buildSlimReportSummary } from "./slim-report-summary.js";
 export { reportToMarkdown, type RenderableReport, } from "./report-to-markdown.js";
+export { diagnosisVersion } from "./diagnosis-runner.js";
+export { cardRegistry, type CardDefinition } from "./diagnosis/registry.js";

package/dist/_vendor/ailf-core/services/index.js

@@ -13,3 +13,8 @@ export { aggregateAreas, aggregateDimensions, computeEnsembleScore, computeTaskS
 export { extractModelName, extractProvider, mergeConfig, modelMatchesMode, resolveModelVariants, } from "./config-helpers.js";
 export { buildSlimReportSummary } from "./slim-report-summary.js";
 export { reportToMarkdown, } from "./report-to-markdown.js";
+// ---------------------------------------------------------------------------
+// Actionability ladder Phase 1 — diagnosis runner + card registry
+// ---------------------------------------------------------------------------
+export { diagnosisVersion } from "./diagnosis-runner.js";
+export { cardRegistry } from "./diagnosis/registry.js";

package/dist/_vendor/ailf-core/services/report-to-markdown.js

@@ -493,8 +493,9 @@ function renderLowScoringJudgments(md, judgments) {
                     .join("\n");
                 md.line(reasonLines);
                 md.blank();
-                if (j.canonicalDocs && j.canonicalDocs.length > 0) {
-                    const docList = j.canonicalDocs.map((d) => `\`${d.slug}\``).join(", ");
+                const jDocs = j.contextDocs ?? j.canonicalDocs;
+                if (jDocs && jDocs.length > 0) {
+                    const docList = jDocs.map((d) => `\`${d.slug}\``).join(", ");
                     md.line(`*Expected docs: ${docList}*`);
                     md.blank();
                 }

package/dist/_vendor/ailf-core/types/attribution.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Attribution core domain types — canonical shapes for the per-document
+ * attribution ensemble (Doc 04).
+ *
+ * Phase 1 lands the type carriers; Phase 4 lands the compute step. The
+ * Zod schemas in `packages/eval/src/adapters/attribution/` assert
+ * `satisfies z.ZodType<...>` against these types.
+ *
+ * Doc identity is referenced by `documentId` (D0052), not by `slug` —
+ * `slug` is retained as a human-readable annotation only. The
+ * resolvable-set check is carried as a separate
+ * `hallucinationCheckedAgainst: string[]` field (Pitfall #11).
+ *
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/design-docs/actionability-ladder/04-per-document-attribution-ensemble.md
+ */
+import type { Confidence } from "./confidence.js";
+/**
+ * Per-document attribution score for one judgment. The `signals` sub-record
+ * carries each ensemble member's contribution; the top-level `score` is
+ * the post-weighting composite.
+ *
+ * `documentId` is the canonical D0052 reference; `slug` is a
+ * human-readable annotation only and must not be relied on for identity.
+ */
+export interface DocAttribution {
+    /** Canonical D0052 document ref (id, not slug). */
+    documentId: string;
+    /** Optional human-readable annotation. Never the identity. */
+    slug?: string;
+    /** Composite attribution score in [0, 1]. */
+    score: number;
+    /** Per-ensemble-member contributions before weighting. */
+    signals: {
+        citation?: number;
+        canonical?: number;
+        retrieved?: number;
+    };
+    /** Shared D0049 confidence triple. */
+    confidence: Confidence;
+}
+/**
+ * Per-judgment attribution carrier. Emitted by Phase 4's
+ * `ComputeAttributionStep`; persisted at
+ * `runs/{runId}/attribution/{entryKey}.json`.
+ *
+ * `hallucinationCheckedAgainst` is the resolvable-set used at compute
+ * time — required (not optional) so consumers can audit citation
+ * grounding without re-deriving the set. Per Pitfall #11 the canonical
+ * task field is `contextDocs`; do not invent `expectedDocs` /
+ * `usedDocs` synonyms.
+ */
+export interface JudgmentAttribution {
+    /** D0052 granular ref to the underlying grader judgment. */
+    judgmentRef: string;
+    taskId: string;
+    modelId: string;
+    dimension: string;
+    attributions: DocAttribution[];
+    /** Resolvable-set used at compute time (Pitfall #11). */
+    hallucinationCheckedAgainst: string[];
+}
+/**
+ * Run-scoped attribution metadata. Persisted alongside the per-entry
+ * attribution objects so consumers can interpret signal-weighting and
+ * embedding choices without re-loading the calibration set.
+ *
+ * `embeddingModel` is REQUIRED (Pitfall #6) — silently downgrading to a
+ * default has caused regressions in adjacent codebases.
+ */
+export interface AttributionMeta {
+    ensembleVersion: string;
+    /** Embedding model identifier — REQUIRED (Pitfall #6). */
+    embeddingModel: string;
+    calibrationSetVersion?: string;
+    weights: {
+        citation: number;
+        canonical: number;
+        retrieved: number;
+    };
+}

package/dist/_vendor/ailf-core/types/attribution.js

@@ -0,0 +1,18 @@
+/**
+ * Attribution core domain types — canonical shapes for the per-document
+ * attribution ensemble (Doc 04).
+ *
+ * Phase 1 lands the type carriers; Phase 4 lands the compute step. The
+ * Zod schemas in `packages/eval/src/adapters/attribution/` assert
+ * `satisfies z.ZodType<...>` against these types.
+ *
+ * Doc identity is referenced by `documentId` (D0052), not by `slug` —
+ * `slug` is retained as a human-readable annotation only. The
+ * resolvable-set check is carried as a separate
+ * `hallucinationCheckedAgainst: string[]` field (Pitfall #11).
+ *
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/design-docs/actionability-ladder/04-per-document-attribution-ensemble.md
+ */
+export {};

package/dist/_vendor/ailf-core/types/branded-ids.d.ts

@@ -29,6 +29,8 @@ declare const __brand: unique symbol;
 export type Brand<T, B extends string> = T & {
     readonly [__brand]: B;
 };
+/** Unique identifier for a grader judgment (D0052 granular). */
+export type JudgmentId = Brand<string, "JudgmentId">;
 /** Unique identifier for an evaluation task */
 export type TaskId = Brand<string, "TaskId">;
 /** URL-safe slug for a task (derived from title) */
@@ -74,7 +76,7 @@ export type ArtifactId = Brand<string, "ArtifactId">;
  * per-mode (e.g. `failureModes`, one entry per classified failure category —
  * D0033 M7, W0051 Slice 2).
  */
-export type AssociationAxis = "run" | "mode" | "task" | "model" | "grader" | "trial" | "category";
+export type AssociationAxis = "run" | "mode" | "task" | "model" | "grader" | "trial" | "category" | "report";
 /**
  * The sanitized, filename-safe identifier for a single per-entry artifact
  * object. Produced by `ArtifactDescriptor.formatEntryKey` and parsed by
@@ -178,4 +180,27 @@ export declare function providerId(raw: string): Result<ProviderId, IdValidation
  * Valid format: alphanumeric + hyphens, 1–128 characters.
  */
 export declare function fixtureId(raw: string): Result<FixtureId, IdValidationError>;
+/**
+ * Parse a raw string into a `JudgmentId`.
+ *
+ * See `JUDGMENT_ID_RE` for the accepted formats.
+ */
+export declare function judgmentId(raw: string): Result<JudgmentId, IdValidationError>;
+/**
+ * Generate a deterministic `JudgmentId` for a synthesized fall-back
+ * judgment. Salting with `runId` (when supplied) makes the id unique
+ * per-run so consumers' `(taskId, modelId, dimension)` dedup key
+ * doesn't collide across re-runs of the same task — every run writes
+ * fresh ids that still encode the natural composite key.
+ *
+ * When `runId` is absent the salt collapses to `nosalt`, preserving the
+ * legacy "deterministic across runs" shape for callers that explicitly
+ * want it (e.g. unit tests that assert the exact id string).
+ */
+export declare function generateJudgmentId(input: {
+    taskId: string;
+    modelId: string;
+    dimension: string;
+    runId?: RunId | string;
+}): JudgmentId;
 export {};

package/dist/_vendor/ailf-core/types/branded-ids.js

@@ -84,11 +84,24 @@ export function generateRunId() {
         .toISOString()
         .replace(/[-:]/g, "")
         .replace(/\.\d{3}Z$/, "Z");
-    const bytes = crypto.getRandomValues(new Uint8Array(8));
-    let suffix = "";
-    for (const b of bytes) {
-        suffix += (b % 36).toString(36);
+    // Rejection-sample bytes against the largest multiple of 36 ≤ 256
+    // (252) before applying `% 36`. Naive `b % 36` over [0, 255] biases
+    // digits 0..3 (probability 8/256) over 4..35 (probability 7/256) by
+    // ~14% per character. Drawing fresh bytes whenever the buffer runs
+    // dry keeps the loop terminating with overwhelming probability
+    // (each byte is kept with probability 252/256 ≈ 98.4%).
+    const suffixChars = [];
+    while (suffixChars.length < 8) {
+        const buf = crypto.getRandomValues(new Uint8Array(8));
+        for (const b of buf) {
+            if (b >= 252)
+                continue; // reject biased range
+            suffixChars.push((b % 36).toString(36));
+            if (suffixChars.length === 8)
+                break;
+        }
     }
+    const suffix = suffixChars.join("");
     return `run_${ts}_${suffix}`;
 }
 /**
@@ -166,3 +179,66 @@ export function fixtureId(raw) {
     }
     return ok(raw);
 }
+/**
+ * Canonical shape for a `JudgmentId`.
+ *
+ * Two accepted forms:
+ *  - `judgment_<runId-suffix>_<sanitized-task>__<sanitized-model>__<dimension>`
+ *    — minted by `generateJudgmentId` for synthesized fall-back judgments
+ *    so dedup is per-run (a re-run of the same task produces a distinct id).
+ *  - `j_<alphanumeric>` — short form used by test fixtures and any caller
+ *    that wants a stable, opaque id without the structured composite.
+ *
+ * Inner segments may carry alphanumerics, hyphens, dots, and colons (the
+ * provider id surface is colon-separated). The full string is bounded to
+ * 256 characters to keep the id index-friendly downstream.
+ */
+const JUDGMENT_ID_RE = /^(?:judgment_[0-9a-z]{1,16}_[a-z0-9][a-z0-9.:_-]*__[a-z0-9][a-z0-9.:_-]*__[a-z0-9][a-z0-9-]*|j_[A-Za-z0-9_-]{4,})$/;
+/**
+ * Parse a raw string into a `JudgmentId`.
+ *
+ * See `JUDGMENT_ID_RE` for the accepted formats.
+ */
+export function judgmentId(raw) {
+    if (raw.length === 0 || raw.length > 256 || !JUDGMENT_ID_RE.test(raw)) {
+        return err({
+            code: "INVALID_JUDGMENT_ID",
+            raw,
+            message: `Invalid JudgmentId "${raw}": must match judgment_<runSalt>_<task>__<model>__<dimension> or j_<alnum>`,
+        });
+    }
+    return ok(raw);
+}
+/** Strip a value down to the alphanumeric+hyphen alphabet the id format allows. */
+function sanitizeJudgmentSegment(value) {
+    // Lowercase + replace runs of non-alphanumerics with a single hyphen,
+    // trim leading/trailing hyphens. Keeps dots and colons in `modelId`-like
+    // values (`openai:gpt-5.2`) since the regex permits them.
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9.:_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Generate a deterministic `JudgmentId` for a synthesized fall-back
+ * judgment. Salting with `runId` (when supplied) makes the id unique
+ * per-run so consumers' `(taskId, modelId, dimension)` dedup key
+ * doesn't collide across re-runs of the same task — every run writes
+ * fresh ids that still encode the natural composite key.
+ *
+ * When `runId` is absent the salt collapses to `nosalt`, preserving the
+ * legacy "deterministic across runs" shape for callers that explicitly
+ * want it (e.g. unit tests that assert the exact id string).
+ */
+export function generateJudgmentId(input) {
+    // Take the trailing 8 chars of the runId (the random base36 suffix on
+    // the canonical shape) so the salt stays compact while still cycling
+    // every run. Falls back to a constant marker when runId isn't passed.
+    const runSalt = input.runId
+        ? sanitizeJudgmentSegment(String(input.runId).slice(-8)) || "nosalt"
+        : "nosalt";
+    const task = sanitizeJudgmentSegment(input.taskId);
+    const model = sanitizeJudgmentSegment(input.modelId);
+    const dimension = sanitizeJudgmentSegment(input.dimension);
+    return `judgment_${runSalt}_${task}__${model}__${dimension}`;
+}

package/dist/_vendor/ailf-core/types/confidence.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared confidence contract for actionability-ladder emitters (D0049).
+ *
+ * Every confidence-emitting site in the actionability-ladder design set
+ * (per-document attribution ensemble, structured grader judgments,
+ * diagnosis cards, regression detection) emits the same abstract triple
+ * so consumers can reason about confidence uniformly across emitters.
+ *
+ * Bucket thresholds and the formula behind `level` are emitter-specific;
+ * the externally comparable behavior is the `level` enum. Consumers that
+ * need the underlying mechanic read `derivation` and can branch.
+ */
+/**
+ * Conventional `derivation` identifiers for the seed set of emitters
+ * named in D0049. Re-exported as a typed tuple so consumers and tests can
+ * reference one source of truth instead of redeclaring the literals.
+ *
+ * Adding a new emitter does not require editing this list — `derivation`
+ * is an open tag (see `ConfidenceDerivation`). The list is the
+ * recommended starting set, not the universe.
+ */
+export declare const CONVENTIONAL_DERIVATIONS: readonly ["ensemble-stdev", "ceiling-cross-check", "regression-gate", "card-type-specific", "synthesized-pre-cross-check"];
+/**
+ * Tag identifying the formula used to derive `Confidence.level`.
+ *
+ * Members of `CONVENTIONAL_DERIVATIONS` are surfaced as literal variants
+ * so IDEs autocomplete the recommended set, while the trailing
+ * `(string & {})` keeps the type open — emitters that need a new
+ * identifier (per-card-type tags, future mechanics) can mint their own
+ * without editing `@sanity/ailf-core`. D0049 picked the open shape so
+ * feature work isn't coupled to core's release cycle.
+ */
+export type ConfidenceDerivation = (typeof CONVENTIONAL_DERIVATIONS)[number] | (string & {});
+/**
+ * The shared confidence triple. Every emitter populates all three fields.
+ *
+ * - `level` is bucketed (not numeric) — chosen over a 0..1 score so every
+ *   consumer doesn't have to pick its own UI buckets. Emitters may keep a
+ *   numeric internal representation and bucket at the edge.
+ * - `signalsPresent` lets consumers distinguish "1 of 1 signal said high"
+ *   from "5 of 6 signals said high" without re-deriving the underlying
+ *   mechanic.
+ * - `derivation` is a short identifier for the formula used to derive
+ *   `level`, so consumers can interpret the mechanic without
+ *   re-implementing it. Conventional values: `"ensemble-stdev"`,
+ *   `"ceiling-cross-check"`, `"regression-gate"`, `"card-type-specific"`.
+ *   Emitters may emit any non-empty string; new conventional identifiers
+ *   land as new emitters arrive.
+ */
+export type Confidence = {
+    /** Bucketed level. Comparable across emitters at this granularity. */
+    level: "high" | "medium" | "low";
+    /** Number of signals contributing to the score. Lets consumers
+     *  distinguish "1 of 1 signal said high" from "5 of 6 signals said high." */
+    signalsPresent: number;
+    /** Short identifier for the formula used to derive `level`. Lets
+     *  consumers interpret the mechanic without re-implementing it.
+     *  Conventional values: "ensemble-stdev", "ceiling-cross-check",
+     *  "regression-gate", "card-type-specific". */
+    derivation: ConfidenceDerivation;
+};
+/**
+ * Structural type guard for `Confidence`. Verifies the runtime shape
+ * matches the contract — useful at trust boundaries that can't depend on
+ * a Zod schema (the schema lives at the consuming site since each emitter
+ * picks its own `level` thresholds, but the shape is shared).
+ */
+export declare function isConfidence(value: unknown): value is Confidence;

package/dist/_vendor/ailf-core/types/confidence.js

@@ -0,0 +1,56 @@
+/**
+ * Shared confidence contract for actionability-ladder emitters (D0049).
+ *
+ * Every confidence-emitting site in the actionability-ladder design set
+ * (per-document attribution ensemble, structured grader judgments,
+ * diagnosis cards, regression detection) emits the same abstract triple
+ * so consumers can reason about confidence uniformly across emitters.
+ *
+ * Bucket thresholds and the formula behind `level` are emitter-specific;
+ * the externally comparable behavior is the `level` enum. Consumers that
+ * need the underlying mechanic read `derivation` and can branch.
+ */
+/**
+ * Conventional `derivation` identifiers for the seed set of emitters
+ * named in D0049. Re-exported as a typed tuple so consumers and tests can
+ * reference one source of truth instead of redeclaring the literals.
+ *
+ * Adding a new emitter does not require editing this list — `derivation`
+ * is an open tag (see `ConfidenceDerivation`). The list is the
+ * recommended starting set, not the universe.
+ */
+export const CONVENTIONAL_DERIVATIONS = [
+    "ensemble-stdev",
+    "ceiling-cross-check",
+    "regression-gate",
+    "card-type-specific",
+    // Sentinel placeholder used by the eval pipeline's
+    // `synthesizeUnparsedJudgment` fall-back. The validator
+    // (`validateGraderJudgmentsCalibration`) overwrites it with
+    // "ceiling-cross-check" before judgments leave the live pipeline,
+    // so it should not appear on stored reports — the literal is in
+    // this list so a leaked sentinel is greppable.
+    "synthesized-pre-cross-check",
+];
+/**
+ * Structural type guard for `Confidence`. Verifies the runtime shape
+ * matches the contract — useful at trust boundaries that can't depend on
+ * a Zod schema (the schema lives at the consuming site since each emitter
+ * picks its own `level` thresholds, but the shape is shared).
+ */
+export function isConfidence(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    if (v.level !== "high" && v.level !== "medium" && v.level !== "low") {
+        return false;
+    }
+    if (typeof v.signalsPresent !== "number" ||
+        !Number.isFinite(v.signalsPresent)) {
+        return false;
+    }
+    if (typeof v.derivation !== "string" || v.derivation.length === 0) {
+        return false;
+    }
+    return true;
+}

package/dist/_vendor/ailf-core/types/diagnosis.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Diagnosis core domain types — canonical shapes for the post-run
+ * synthesis layer (Doc 05).
+ *
+ * `Diagnosis.inputs` is the four-version cache envelope (VER-01); any
+ * segment bump invalidates a cached Diagnosis. `DiagnosisCard` is an
+ * outer-`status` discriminated union with a nested `cardType`
+ * discriminator inside the `ready` variant.
+ *
+ * Phase 1 lands placeholder body shapes; Phase 5 enriches each per
+ * Doc 05 specs.
+ *
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/decisions/D0050-artifact-registry-post-hoc-versioned-extension.md
+ */
+import type { RunId } from "./branded-ids.js";
+import type { ReportId } from "./index.js";
+/**
+ * The four-version cache envelope. Every cached `Diagnosis` carries the
+ * versions of the inputs that produced it; any bump in any segment
+ * invalidates the cache (cross-package contract test asserts this).
+ *
+ * Strings everywhere; semver convention by humans where authored
+ * manually. No branding, no tuples, no content-hash typing — keeps the
+ * envelope trivially serializable + greppable.
+ */
+export interface VersionedInputs {
+    graderJudgmentsVersion: string;
+    ensembleVersion: string;
+    diagnosisVersion: string;
+    cardVersion: string;
+}
+/**
+ * The 8 ready-card archetypes. Phase 5 cards register against these
+ * literals; the slim-shape boundary in Phase 7 reads them to render the
+ * Studio diagnosis renderer.
+ */
+export type CardType = "area-summary" | "failure-mode-summary" | "no-issues" | "top-recommendations" | "weakest-area" | "low-confidence-attribution" | "doc-attribution-spotlight" | "regression-vs-baseline";
+/**
+ * Per-card telemetry envelope. `cardVersion` here is the per-card
+ * version (e.g. `"area-summary@0.1.0"`), not the compound. Drives
+ * DIAG-06 cost telemetry in Phase 6.
+ */
+export interface CardMeta {
+    cardVersion: string;
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+    latencyMs?: number;
+    /** ISO 8601 UTC timestamp. */
+    generatedAt: string;
+}
+/**
+ * A single actionable suggestion surfaced by a recommendations card.
+ * The full Phase 5 shape may add fields (per Doc 05 specs); Phase 1
+ * locks the minimum required surface.
+ */
+export interface ActionSuggestion {
+    title: string;
+    body: string;
+    priority: "high" | "medium" | "low";
+}
+/**
+ * Phase 1 body placeholders. Each shape is intentionally minimal; Phase 5
+ * card files enrich them per Doc 05 specs and assert
+ * `satisfies z.ZodType<Extract<DiagnosisCard, { status: "ready"; cardType: "X" }>["body"]>`
+ * against these declarations.
+ */
+export interface AreaSummaryBody {
+    summary: string;
+}
+export interface FailureModeSummaryBody {
+    summary: string;
+}
+export interface NoIssuesBody {
+    summary: string;
+}
+export interface TopRecommendationsBody {
+    summary: string;
+    suggestions: ActionSuggestion[];
+}
+export interface WeakestAreaBody {
+    summary: string;
+}
+export interface LowConfidenceAttributionBody {
+    summary: string;
+}
+export interface DocAttributionSpotlightBody {
+    summary: string;
+}
+export interface RegressionVsBaselineBody {
+    summary: string;
+}
+/**
+ * Outer-`status` discriminated union: 8 ready variants (one per
+ * `cardType`, each carrying its per-cardType body), plus a `degraded`
+ * variant (parse failed or downgraded by the runner) and a `missing`
+ * variant (card not produced for this run).
+ *
+ * No `not-yet-generated` variant — old-report fallback is a Phase 7
+ * concern at the slim-shape boundary, handled at fetch-time, not in
+ * `DiagnosisCard` itself.
+ */
+export type DiagnosisCard = {
+    status: "ready";
+    cardType: "area-summary";
+    body: AreaSummaryBody;
+    meta: CardMeta;
+} | {
+    status: "ready";
+    cardType: "failure-mode-summary";
+    body: FailureModeSummaryBody;
+    meta: CardMeta;
+} | {
+    status: "ready";
+    cardType: "no-issues";
+    body: NoIssuesBody;
+    meta: CardMeta;
+} | {
+    status: "ready";
+    cardType: "top-recommendations";
+    body: TopRecommendationsBody;
+    meta: CardMeta;
+} | {
+    status: "ready";
+    cardType: "weakest-area";
+    body: WeakestAreaBody;
+    meta: CardMeta;
+} | {
+    status: "ready";
+    cardType: "low-confidence-attribution";
+    body: LowConfidenceAttributionBody;
+    meta: CardMeta;
+} | {
+    status: "ready";
+    cardType: "doc-attribution-spotlight";
+    body: DocAttributionSpotlightBody;
+    meta: CardMeta;
+} | {
+    status: "ready";
+    cardType: "regression-vs-baseline";
+    body: RegressionVsBaselineBody;
+    meta: CardMeta;
+} | {
+    status: "degraded";
+    cardType: CardType;
+    reason: string;
+    parseFailed: boolean;
+    meta: CardMeta;
+} | {
+    status: "missing";
+    cardType: CardType;
+    reason: string;
+};
+/**
+ * The post-run synthesis aggregate. Consumed by Phase 5 (runner +
+ * cards), Phase 6 (CLI) and Phase 7 (Studio). Phase 1 lands the
+ * declarative shape; runtime construction lands in Phase 5.
+ */
+export interface Diagnosis {
+    runId: RunId;
+    reportId: ReportId;
+    inputs: VersionedInputs;
+    cards: DiagnosisCard[];
+    /** ISO 8601 UTC timestamp. */
+    generatedAt: string;
+}

package/dist/_vendor/ailf-core/types/diagnosis.js

@@ -0,0 +1,17 @@
+/**
+ * Diagnosis core domain types — canonical shapes for the post-run
+ * synthesis layer (Doc 05).
+ *
+ * `Diagnosis.inputs` is the four-version cache envelope (VER-01); any
+ * segment bump invalidates a cached Diagnosis. `DiagnosisCard` is an
+ * outer-`status` discriminated union with a nested `cardType`
+ * discriminator inside the `ready` variant.
+ *
+ * Phase 1 lands placeholder body shapes; Phase 5 enriches each per
+ * Doc 05 specs.
+ *
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/decisions/D0050-artifact-registry-post-hoc-versioned-extension.md
+ */
+export {};

package/dist/_vendor/ailf-core/types/generalized-task.d.ts

@@ -53,11 +53,26 @@ export interface PerspectiveDocRef {
     perspective: string;
     reason?: string;
 }
+/**
+ * A single criterion within a templated llm-rubric assertion.
+ *
+ * The `id` is a stable, slug-formatted identifier — auto-derived from
+ * `text` in Studio (via slug `options.source: "text"`), or backfilled
+ * from Sanity's `_key` for pre-migration documents. Survives criterion
+ * text edits; downstream judgments and diagnosis cards reference by
+ * `id` per D0052 (judgment-ref granularity).
+ */
+export interface CriterionRef {
+    /** Stable per-criterion identifier — slug-format (`[a-z0-9][a-z0-9-]*`). */
+    id: string;
+    /** Author-facing criterion text (the original bullet). */
+    text: string;
+}
 /** A templated assertion referencing a rubric template */
 export interface GeneralizedTemplatedAssertion {
     type: "llm-rubric";
     template: string;
-    criteria: string[];
+    criteria: CriterionRef[];
     weight?: number;
 }
 /** A value-based assertion (contains, javascript, cost, latency, etc.) */