@sanity/ailf 4.6.0 → 6.0.0

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

@@ -19,7 +19,7 @@
  * 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"];
+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`.
  *

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

@@ -24,6 +24,13 @@ export const CONVENTIONAL_DERIVATIONS = [
     "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

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

@@ -0,0 +1,271 @@
+/**
+ * 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
+ * AI-SPEC §3 and CONTEXT D-05/D-07. The `DiagnosisCard` discriminated
+ * union surface (arms + `cardType` literals) is stable — only the
+ * `body: <BodyInterface>` references resolve to richer shapes.
+ *
+ * @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 { Confidence } from "./confidence.js";
+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.
+ *
+ * Phase 5 adds `docSlug` (the canonical doc page to rewrite) and
+ * `sectionHeading` (null when the suggestion targets the whole page)
+ * per AI-SPEC actionability-specificity rubric + failure-mode #2
+ * mitigation.
+ */
+export interface ActionSuggestion {
+    title: string;
+    body: string;
+    priority: "high" | "medium" | "low";
+    /** Canonical slug of the documentation page this suggestion targets. */
+    docSlug: string;
+    /**
+     * Heading within `docSlug` that should be revised, or `null` when the
+     * suggestion targets the page as a whole.
+     */
+    sectionHeading: string | null;
+}
+/**
+ * Minimal judgment reference per D0052 (taskId × modelId × dimension).
+ * Used by `LowConfidenceAttributionBody.judgmentRefs` to cite the
+ * specific judgments that drove a low-confidence finding.
+ */
+export interface JudgmentRef {
+    taskId: string;
+    modelId: string;
+    dimension: string;
+}
+/**
+ * Phase 5 enriched body shapes. Each keeps `summary: string` (load-bearing
+ * for CLI default render per AI-SPEC §6) and adds fields the corresponding
+ * Zod schema needs (asserting `satisfies z.ZodType<T>` in the card file).
+ */
+/** area-summary: deterministic — keep only summary (no behavioral claims). */
+export interface AreaSummaryBody {
+    summary: string;
+}
+/**
+ * failure-mode-summary: deterministic + D-05 dimension/failureMode gate.
+ * `count` = frequency in the report; `sampleSize` = judgment count for the
+ * dimension (per AI-SPEC failure-mode #3 mitigation).
+ */
+export interface FailureModeSummaryBody {
+    summary: string;
+    /** Rubric dimension this summary targets (e.g. "task-completion"). */
+    dimension: string;
+    /** Canonical failure mode within this dimension. */
+    failureMode: string;
+    /** Number of judgments in this report with this failure mode. */
+    count: number;
+    /** Total judgments for this dimension — calibration denominator. */
+    sampleSize: number;
+}
+/**
+ * no-issues: deterministic + AI-SPEC failure-mode #7 sycophancy guard.
+ * `thresholdScore` surfaces the threshold used to qualify as "no issues"
+ * so readers can see the criterion behind the positive assessment.
+ */
+export interface NoIssuesBody {
+    summary: string;
+    /** Minimum composite score that qualified this area as "no issues". */
+    thresholdScore: number;
+}
+/**
+ * top-recommendations: LLM-driven. `suggestions` reuses the enriched
+ * `ActionSuggestion` shape (docSlug + sectionHeading per AI-SPEC
+ * actionability-specificity rubric + failure-mode #2 mitigation).
+ */
+export interface TopRecommendationsBody {
+    summary: string;
+    suggestions: ActionSuggestion[];
+}
+/**
+ * weakest-area: LLM-driven. Adds area identification, dimension/failureMode
+ * context, and a small-sample calibration guard (AI-SPEC failure-mode #3).
+ */
+export interface WeakestAreaBody {
+    summary: string;
+    /** Documentation area with the lowest composite score. */
+    area: string;
+    /** Primary dimension driving the low score. */
+    dimension: string;
+    /** Dominant failure mode in this area. */
+    failureMode: string;
+    /** Number of judgments sampled for this area — calibration denominator. */
+    sampleSize: number;
+    /** Calibrated confidence per D0049 (ensemble-stdev derivation). */
+    confidence: Confidence;
+}
+/**
+ * regression-vs-baseline: LLM-driven. `deltas` is the per-area diff
+ * (JS-computed pre-call, max 10 entries); `drivers` is LLM prose;
+ * `overallTrend` is a 4-bucket summary per AI-SPEC §3 lines 605-613.
+ */
+export interface RegressionVsBaselineBody {
+    summary: string;
+    /**
+     * Per-area score deltas (max 10). `drivers` carries the LLM's prose
+     * reasoning about what caused the change.
+     */
+    deltas: {
+        area: string;
+        direction: "improved" | "regressed" | "unchanged";
+        pointsDelta: number;
+        drivers: string[];
+    }[];
+    /** 4-bucket aggregate trend across all deltas. */
+    overallTrend: "net-improved" | "net-regressed" | "mixed" | "stable";
+}
+/**
+ * low-confidence-attribution: LLM-driven. `judgmentRefs` cites the
+ * specific judgments (D0052 triple) that drove the low-confidence finding.
+ */
+export interface LowConfidenceAttributionBody {
+    summary: string;
+    /** Judgment references (D0052) driving this low-confidence finding. */
+    judgmentRefs: JudgmentRef[];
+}
+/**
+ * doc-attribution-spotlight: LLM-driven. `docCitations` carries per-doc
+ * attribution roles and confidence calibration (AI-SPEC failure-mode #5).
+ */
+export interface DocAttributionSpotlightBody {
+    summary: string;
+    /**
+     * Per-doc attribution records. `role` classifies how the doc contributed;
+     * `confidence` calibrates the attribution certainty (D0049).
+     */
+    docCitations: {
+        docSlug: string;
+        confidence: Confidence;
+        role: "supports" | "contradicts" | "missing" | "irrelevant";
+    }[];
+}
+/**
+ * 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.
+ *
+ * D-07: only the `body: <BodyInterface>` references resolve to richer
+ * shapes. The union arms, status literals, and cardType literals are
+ * identical to Phase 1.
+ */
+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,19 @@
+/**
+ * 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
+ * AI-SPEC §3 and CONTEXT D-05/D-07. The `DiagnosisCard` discriminated
+ * union surface (arms + `cardType` literals) is stable — only the
+ * `body: <BodyInterface>` references resolve to richer shapes.
+ *
+ * @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.) */