@sanity/ailf 4.5.0 → 5.0.0

package/dist/_vendor/ailf-core/ports/llm-client.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Port: LLM access for non-grader features.
+ *
+ * Adapters wrap a vendor REST API and centralize retry, rate-limit handling,
+ * cost calculation, and observability. Features call this port instead of
+ * importing the grader's internals or a vendor SDK directly.
+ *
+ * The grader path (`packages/eval/src/pipeline/grader-api.ts`) is intentionally
+ * NOT migrated here — D0051 defers grader migration as a follow-up.
+ *
+ * @see docs/decisions/D0051-llm-client-port.md
+ */
+import type { ZodType } from "zod";
+import { type Brand, type IdValidationError, type Result } from "../types/branded-ids.js";
+/**
+ * A canonical LLM model identifier.
+ *
+ * Grammar: `<provider>:<segment>...:<modelName>` (e.g.
+ * `"openai:chat:gpt-5.2"`, `"anthropic:messages:claude-opus-4-6"`,
+ * `"anthropic:claude-sonnet-4-6"`). Branded so adapters can trust the
+ * grammar and consumers can't accidentally pass an arbitrary string.
+ */
+export type ModelId = Brand<string, "ModelId">;
+/** The supported provider prefixes for `ModelId`. */
+export type ModelProvider = "anthropic" | "openai";
+/** Result of parsing a `ModelId` — provider plus the bare model name. */
+export interface ParsedModelId {
+    readonly id: ModelId;
+    readonly provider: ModelProvider;
+    /** Bare vendor model name with provider segments stripped. */
+    readonly modelName: string;
+}
+/**
+ * Parse a raw string into a `ParsedModelId`. Returns `Result` — never throws.
+ *
+ * Recognized prefixes:
+ * - `openai:<modelName>` or `openai:<sub>:<modelName>` (e.g. `"openai:chat:gpt-5"`)
+ * - `anthropic:<modelName>` or `anthropic:messages:<modelName>`
+ */
+export declare function parseModelId(raw: string): Result<ParsedModelId, IdValidationError>;
+/**
+ * Throwing constructor — convenient for known-good inputs (config files,
+ * tests). Throws if the id is malformed; use `parseModelId` for untrusted
+ * input.
+ */
+export declare function modelId(raw: string): ModelId;
+/**
+ * Extract `provider` + `modelName` from an already-branded `ModelId`. Assumes
+ * the id was produced by `parseModelId` / `modelId` and is therefore valid;
+ * if it isn't, the caller's bug surfaces as a thrown `Error`.
+ */
+export declare function splitModelId(id: ModelId): ParsedModelId;
+/**
+ * Per-call telemetry tag. Carried through usage / cost records so billing can
+ * roll up by feature, run, or card.
+ */
+export interface LLMCallContext {
+    /** Logical feature name (e.g. "diagnosis", "meta-eval"). */
+    feature: string;
+    /** Optional pipeline run id when the call happens inside a run. */
+    runId?: string;
+    /** Optional originating card id (for diagnosis-style features). */
+    cardId?: string;
+}
+/** Token usage reported by the vendor for a single call. */
+export interface LLMUsage {
+    promptTokens: number;
+    completionTokens: number;
+}
+/** Result of a free-text completion. */
+export interface LLMCompletion {
+    text: string;
+    usage: LLMUsage;
+    /** End-to-end USD cost for the call. */
+    cost: number;
+    /** Echo of the canonical model id used. */
+    model: ModelId;
+}
+/** Result of a structured-output completion. `value` is parsed via the supplied schema. */
+export interface LLMStructuredCompletion<T> {
+    value: T;
+    usage: LLMUsage;
+    cost: number;
+    model: ModelId;
+}
+export interface LLMCompleteArgs {
+    /** Canonical model id — produced by `modelId` / `parseModelId`. */
+    model: ModelId;
+    /** Raw prompt text — adapters wrap it in the vendor message envelope. */
+    prompt: string;
+    temperature?: number;
+    maxTokens?: number;
+    stop?: string[];
+    context?: LLMCallContext;
+}
+export interface LLMCompleteStructuredArgs<T> {
+    model: ModelId;
+    prompt: string;
+    /** Runtime contract — the adapter parses the model's response through this. */
+    schema: ZodType<T>;
+    temperature?: number;
+    maxTokens?: number;
+    context?: LLMCallContext;
+}
+/**
+ * Synthesis-side LLM port. v0 is single-call only — streaming and batching are
+ * deferred per D0051 until a consumer needs them.
+ */
+export interface LLMClient {
+    complete(args: LLMCompleteArgs): Promise<LLMCompletion>;
+    completeStructured<T>(args: LLMCompleteStructuredArgs<T>): Promise<LLMStructuredCompletion<T>>;
+}

package/dist/_vendor/ailf-core/ports/llm-client.js

@@ -0,0 +1,68 @@
+/**
+ * Port: LLM access for non-grader features.
+ *
+ * Adapters wrap a vendor REST API and centralize retry, rate-limit handling,
+ * cost calculation, and observability. Features call this port instead of
+ * importing the grader's internals or a vendor SDK directly.
+ *
+ * The grader path (`packages/eval/src/pipeline/grader-api.ts`) is intentionally
+ * NOT migrated here — D0051 defers grader migration as a follow-up.
+ *
+ * @see docs/decisions/D0051-llm-client-port.md
+ */
+import { err, ok, } from "../types/branded-ids.js";
+/**
+ * Parse a raw string into a `ParsedModelId`. Returns `Result` — never throws.
+ *
+ * Recognized prefixes:
+ * - `openai:<modelName>` or `openai:<sub>:<modelName>` (e.g. `"openai:chat:gpt-5"`)
+ * - `anthropic:<modelName>` or `anthropic:messages:<modelName>`
+ */
+export function parseModelId(raw) {
+    const parts = raw.split(":");
+    if (parts.length < 2 || parts[0] === "" || parts.some((p) => p === "")) {
+        return err({
+            code: "INVALID_MODEL_ID",
+            raw,
+            message: `Invalid ModelId "${raw}": expected "<provider>:<modelName>" with non-empty segments`,
+        });
+    }
+    const provider = parts[0];
+    if (provider === "openai") {
+        const modelName = parts.length >= 3 ? parts.slice(2).join(":") : parts.slice(1).join(":");
+        return ok({ id: raw, provider, modelName });
+    }
+    if (provider === "anthropic") {
+        const modelName = parts.length >= 3 && parts[1] === "messages"
+            ? parts.slice(2).join(":")
+            : parts.slice(1).join(":");
+        return ok({ id: raw, provider, modelName });
+    }
+    return err({
+        code: "INVALID_MODEL_ID",
+        raw,
+        message: `Invalid ModelId "${raw}": unknown provider "${provider}". Supported: openai, anthropic.`,
+    });
+}
+/**
+ * Throwing constructor — convenient for known-good inputs (config files,
+ * tests). Throws if the id is malformed; use `parseModelId` for untrusted
+ * input.
+ */
+export function modelId(raw) {
+    const result = parseModelId(raw);
+    if (!result.ok)
+        throw new Error(result.error.message);
+    return result.value.id;
+}
+/**
+ * Extract `provider` + `modelName` from an already-branded `ModelId`. Assumes
+ * the id was produced by `parseModelId` / `modelId` and is therefore valid;
+ * if it isn't, the caller's bug surfaces as a thrown `Error`.
+ */
+export function splitModelId(id) {
+    const result = parseModelId(id);
+    if (!result.ok)
+        throw new Error(result.error.message);
+    return result.value;
+}

package/dist/_vendor/ailf-core/ports/mode-handler.d.ts

@@ -81,7 +81,22 @@ export interface ModeRubricConfig {
         header: string;
         scale: string[];
         criteria_label?: string;
+        /**
+         * Plan 03-02 — per-dimension legal failure-mode list. The runtime
+         * rubric assembler announces these modes to the grader before the
+         * structured-shape footer when the list is non-empty. Stamped at
+         * config-load time by `failureModesForDimension(dimension)` in
+         * `packages/eval/src/grader/index.ts`.
+         */
+        failureModes?: readonly string[];
     }>;
+    /**
+     * Plan 03-01 — formerly hard-coded literal in
+     * `pipeline/compiler/rubric-resolution.ts`; now sourced from
+     * RubricConfig.footer and threaded through to the runtime prompt
+     * assembler so the grader is told exactly what wire format to emit.
+     */
+    footer: string;
 }
 /** A provider entry in the compile result */
 export interface CompileResultProvider {

package/dist/_vendor/ailf-core/schemas/branded-string.d.ts

@@ -0,0 +1,40 @@
+/**
+ * branded-string.ts — single, audited cast site for Zod schemas that
+ * parse a non-empty string into a {@link Brand}-tagged domain type.
+ *
+ * Project rule (`.claude/rules/typescript.md`): "Parse, don't validate
+ * — use schema libs at boundaries; no `as` on `unknown`." The
+ * `Brand<string, "Tag">` utility in `branded-ids.ts` uses a `unique
+ * symbol` (`__brand`) that is not structurally identical to Zod 4's
+ * `BRAND` symbol, so a direct `.brand<"Tag">()` swap does not produce
+ * a compatible type. Wrapping the unavoidable cast in a single typed
+ * helper centralizes the rule violation to one auditable place
+ * instead of duplicating `as unknown as z.ZodType<Brand<…, …>>` at
+ * every adapter branded-field declaration.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { brandedString } from "../schemas/index.d.ts"
+ *
+ * judgmentId: brandedString<"JudgmentId">().optional(),
+ * ```
+ *
+ * This is the **only** allowed place to elide the no-`as`-on-`unknown`
+ * rule for branded-string schemas. Phase 7 will reconsider the
+ * `Brand<>` shape against Zod 4's `BRAND` so the cast can be retired.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see packages/core/src/types/branded-ids.ts
+ */
+import { z } from "zod";
+import type { Brand } from "../types/branded-ids.js";
+/**
+ * Schema for a non-empty string typed as `Brand<string, TBrand>`.
+ *
+ * The single `as unknown as` cast inside this helper is the audited
+ * exit from the project's no-`as`-on-`unknown` rule. Adapters MUST
+ * NOT replicate the cast at their own call sites — call this helper
+ * instead so the rule violation stays centralized.
+ */
+export declare function brandedString<TBrand extends string>(): z.ZodType<Brand<string, TBrand>>;

package/dist/_vendor/ailf-core/schemas/branded-string.js

@@ -0,0 +1,45 @@
+/**
+ * branded-string.ts — single, audited cast site for Zod schemas that
+ * parse a non-empty string into a {@link Brand}-tagged domain type.
+ *
+ * Project rule (`.claude/rules/typescript.md`): "Parse, don't validate
+ * — use schema libs at boundaries; no `as` on `unknown`." The
+ * `Brand<string, "Tag">` utility in `branded-ids.ts` uses a `unique
+ * symbol` (`__brand`) that is not structurally identical to Zod 4's
+ * `BRAND` symbol, so a direct `.brand<"Tag">()` swap does not produce
+ * a compatible type. Wrapping the unavoidable cast in a single typed
+ * helper centralizes the rule violation to one auditable place
+ * instead of duplicating `as unknown as z.ZodType<Brand<…, …>>` at
+ * every adapter branded-field declaration.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { brandedString } from "../schemas/index.js"
+ *
+ * judgmentId: brandedString<"JudgmentId">().optional(),
+ * ```
+ *
+ * This is the **only** allowed place to elide the no-`as`-on-`unknown`
+ * rule for branded-string schemas. Phase 7 will reconsider the
+ * `Brand<>` shape against Zod 4's `BRAND` so the cast can be retired.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see packages/core/src/types/branded-ids.ts
+ */
+import { z } from "zod";
+/**
+ * Schema for a non-empty string typed as `Brand<string, TBrand>`.
+ *
+ * The single `as unknown as` cast inside this helper is the audited
+ * exit from the project's no-`as`-on-`unknown` rule. Adapters MUST
+ * NOT replicate the cast at their own call sites — call this helper
+ * instead so the rule violation stays centralized.
+ */
+export function brandedString() {
+    // The runtime is a plain non-empty string; the brand is a
+    // compile-time-only nominal tag (see `Brand<>` in branded-ids.ts).
+    // Zod 4's `.brand()` uses a different symbol shape, so a direct
+    // composition does not yield the project's `Brand<…>` type.
+    return z.string().min(1);
+}

package/dist/_vendor/ailf-core/schemas/confidence-schema.d.ts

@@ -0,0 +1,36 @@
+/**
+ * confidence-schema.ts — shared Zod schema for the D0049 `Confidence` triple.
+ *
+ * Authored ONCE here so adapter schemas under
+ * `packages/eval/src/adapters/grader-outputs/` and
+ * `packages/eval/src/adapters/attribution/` import a single shared schema
+ * fragment instead of redeclaring the shape inline. The schema asserts
+ * `satisfies z.ZodType<Confidence>` against the domain type in
+ * `packages/core/src/types/confidence.ts` so drift is a build error.
+ *
+ * NON-BOUNDARY HELPER: this file lives outside the D0045 SCAN_ROOTS gate
+ * by intent — it is a reusable schema fragment, not a trust boundary.
+ * Consumers import via the pinned subpath export
+ * `@sanity/ailf-core/schemas` (declared in `packages/core/package.json`),
+ * NOT through the top-level barrel — that pin is the
+ * single legal access path so all adapter sites use the same specifier.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ */
+import { z } from "zod";
+/**
+ * Shared schema for {@link Confidence}. The `derivation` field is the
+ * open `ConfidenceDerivation` tag; we accept any non-empty string so
+ * future emitters can mint their own identifiers without editing this
+ * package (matches `isConfidence`'s runtime guard).
+ */
+export declare const ConfidenceSchema: z.ZodObject<{
+    level: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    signalsPresent: z.ZodNumber;
+    derivation: z.ZodString;
+}, z.core.$strip>;

package/dist/_vendor/ailf-core/schemas/confidence-schema.js

@@ -0,0 +1,32 @@
+/**
+ * confidence-schema.ts — shared Zod schema for the D0049 `Confidence` triple.
+ *
+ * Authored ONCE here so adapter schemas under
+ * `packages/eval/src/adapters/grader-outputs/` and
+ * `packages/eval/src/adapters/attribution/` import a single shared schema
+ * fragment instead of redeclaring the shape inline. The schema asserts
+ * `satisfies z.ZodType<Confidence>` against the domain type in
+ * `packages/core/src/types/confidence.ts` so drift is a build error.
+ *
+ * NON-BOUNDARY HELPER: this file lives outside the D0045 SCAN_ROOTS gate
+ * by intent — it is a reusable schema fragment, not a trust boundary.
+ * Consumers import via the pinned subpath export
+ * `@sanity/ailf-core/schemas` (declared in `packages/core/package.json`),
+ * NOT through the top-level barrel — that pin is the
+ * single legal access path so all adapter sites use the same specifier.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ */
+import { z } from "zod";
+/**
+ * Shared schema for {@link Confidence}. The `derivation` field is the
+ * open `ConfidenceDerivation` tag; we accept any non-empty string so
+ * future emitters can mint their own identifiers without editing this
+ * package (matches `isConfidence`'s runtime guard).
+ */
+export const ConfidenceSchema = z.object({
+    level: z.enum(["high", "medium", "low"]),
+    signalsPresent: z.number().int().nonnegative(),
+    derivation: z.string().min(1),
+});

package/dist/_vendor/ailf-core/schemas/eval-config.d.ts

@@ -41,6 +41,7 @@ export declare const EvalConfigSchema: z.ZodObject<{
     execution: z.ZodOptional<z.ZodObject<{
         concurrency: z.ZodOptional<z.ZodNumber>;
         graderReplications: z.ZodOptional<z.ZodNumber>;
+        borderlineReplications: z.ZodOptional<z.ZodNumber>;
         gapAnalysis: z.ZodOptional<z.ZodBoolean>;
         apiUrl: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;

package/dist/_vendor/ailf-core/schemas/eval-config.js

@@ -85,15 +85,19 @@ export const EvalConfigSchema = z
      * `concurrency`, `gapAnalysis`, and `graderReplications` fields and adds
      * `apiUrl` to the same group.
      *
-     * - `concurrency`         — max parallel API calls
-     * - `graderReplications`  — grader consistency replications
-     * - `gapAnalysis`         — enable failure-mode + impact analysis (default true)
-     * - `apiUrl`              — AILF API base URL (default https://ailf-api.sanity.build)
+     * - `concurrency`             — max parallel API calls
+     * - `graderReplications`      — grader consistency replications
+     * - `borderlineReplications`  — replications per borderline judgment
+     *                               for the GRAD-04 intra-grader consensus
+     *                               pass (default 3 in composition-root)
+     * - `gapAnalysis`             — enable failure-mode + impact analysis (default true)
+     * - `apiUrl`                  — AILF API base URL (default https://ailf-api.sanity.build)
      */
     execution: z
         .object({
         concurrency: z.number().int().positive().optional(),
         graderReplications: z.number().int().positive().optional(),
+        borderlineReplications: z.number().int().positive().optional(),
         gapAnalysis: z.boolean().optional(),
         apiUrl: z.string().url().optional(),
     })

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

@@ -19,3 +19,5 @@ export * from "./schedules.js";
 export * from "./sinks.js";
 export * from "./symbol-preflight-report.js";
 export * from "./test-budgets.js";
+export { ConfidenceSchema } from "./confidence-schema.js";
+export { brandedString } from "./branded-string.js";

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

@@ -19,3 +19,12 @@ export * from "./schedules.js";
 export * from "./sinks.js";
 export * from "./symbol-preflight-report.js";
 export * from "./test-budgets.js";
+// Phase 1 Plan 02 — shared schema fragment for D0049 Confidence.
+// Named re-export only (W0124 / D0045) and pinned-subpath access path
+// `@sanity/ailf-core/schemas` for adapter consumers.
+export { ConfidenceSchema } from "./confidence-schema.js";
+// Phase 1 Plan 03 — single audited cast site for `Brand<string, T>`
+// schemas. Adapters MUST route branded-field declarations through this
+// helper instead of replicating `as unknown as z.ZodType<…>` at each
+// schema author site (project rule: no `as` on `unknown`).
+export { brandedString } from "./branded-string.js";

package/dist/_vendor/ailf-core/schemas/pipeline-request.d.ts

@@ -48,6 +48,7 @@ export declare const PipelineRequestSchema: z.ZodObject<{
         "with-docs": "with-docs";
     }>>;
     graderReplications: z.ZodOptional<z.ZodNumber>;
+    borderlineReplications: z.ZodOptional<z.ZodNumber>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     inlineTasks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     jobId: z.ZodOptional<z.ZodString>;

package/dist/_vendor/ailf-core/schemas/pipeline-request.js

@@ -114,6 +114,7 @@ export const PipelineRequestSchema = z.object({
      */
     graderContext: z.enum(["rubric-only", "with-docs"]).optional(),
     graderReplications: z.number().int().positive().optional(),
+    borderlineReplications: z.number().int().positive().optional(),
     headers: z.record(z.string(), z.string()).optional(),
     inlineTasks: z.array(z.record(z.string(), z.unknown())).optional(),
     jobId: z.string().optional(),

package/dist/_vendor/ailf-core/schemas/pipeline.d.ts

@@ -20,6 +20,7 @@ import { z } from "zod";
 export declare const RubricTemplateSchema: z.ZodObject<{
     criteria_label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     dimension: z.ZodOptional<z.ZodString>;
+    failureModes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     header: z.ZodString;
     scale: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
@@ -52,6 +53,7 @@ export declare const RubricConfigSchema: z.ZodObject<{
     templates: z.ZodRecord<z.ZodString, z.ZodObject<{
         criteria_label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         dimension: z.ZodOptional<z.ZodString>;
+        failureModes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         header: z.ZodString;
         scale: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
@@ -112,7 +114,10 @@ export type FeatureRegistry = z.infer<typeof FeatureRegistrySchema>;
  * and provides task-specific criteria.
  */
 declare const TemplatedLlmRubricAssertSchema: z.ZodObject<{
-    criteria: z.ZodArray<z.ZodString>;
+    criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
     template: z.ZodString;
     type: z.ZodLiteral<"llm-rubric">;
     weight: z.ZodOptional<z.ZodNumber>;
@@ -129,7 +134,10 @@ export type TemplatedLlmRubricAssert = z.infer<typeof TemplatedLlmRubricAssertSc
  * is gone, but union is more flexible for future additions).
  */
 export declare const AssertionSchema: z.ZodUnion<readonly [z.ZodObject<{
-    criteria: z.ZodArray<z.ZodString>;
+    criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
     template: z.ZodString;
     type: z.ZodLiteral<"llm-rubric">;
     weight: z.ZodOptional<z.ZodNumber>;
@@ -174,7 +182,10 @@ export type CanonicalDoc = z.infer<typeof CanonicalDocSchema>;
  */
 export declare const SingleTaskSchema: z.ZodObject<{
     assert: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        criteria: z.ZodArray<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
         template: z.ZodString;
         type: z.ZodLiteral<"llm-rubric">;
         weight: z.ZodOptional<z.ZodNumber>;
@@ -233,7 +244,10 @@ export type SingleTask = z.infer<typeof SingleTaskSchema>;
  */
 export declare const LegacyTaskSchema: z.ZodObject<{
     assert: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        criteria: z.ZodArray<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
         template: z.ZodString;
         type: z.ZodLiteral<"llm-rubric">;
         weight: z.ZodOptional<z.ZodNumber>;
@@ -269,7 +283,10 @@ export type LegacyTask = z.infer<typeof LegacyTaskSchema>;
  */
 export declare const TaskEntrySchema: z.ZodUnion<readonly [z.ZodObject<{
     assert: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        criteria: z.ZodArray<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
         template: z.ZodString;
         type: z.ZodLiteral<"llm-rubric">;
         weight: z.ZodOptional<z.ZodNumber>;
@@ -321,7 +338,10 @@ export declare const TaskEntrySchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$loose>;
 }, z.core.$strip>, z.ZodObject<{
     assert: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        criteria: z.ZodArray<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
         template: z.ZodString;
         type: z.ZodLiteral<"llm-rubric">;
         weight: z.ZodOptional<z.ZodNumber>;
@@ -355,7 +375,10 @@ export type TaskEntryParsed = z.infer<typeof TaskEntrySchema>;
  */
 export declare const TaskFileSchema: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
     assert: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        criteria: z.ZodArray<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
         template: z.ZodString;
         type: z.ZodLiteral<"llm-rubric">;
         weight: z.ZodOptional<z.ZodNumber>;
@@ -407,7 +430,10 @@ export declare const TaskFileSchema: z.ZodArray<z.ZodUnion<readonly [z.ZodObject
     }, z.core.$loose>;
 }, z.core.$strip>, z.ZodObject<{
     assert: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        criteria: z.ZodArray<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
         template: z.ZodString;
         type: z.ZodLiteral<"llm-rubric">;
         weight: z.ZodOptional<z.ZodNumber>;

package/dist/_vendor/ailf-core/schemas/pipeline.js

@@ -26,6 +26,14 @@ export const RubricTemplateSchema = z.object({
         .min(1, "criteria_label must be a non-empty string")
         .nullish(),
     dimension: z.string().min(1).optional(),
+    /**
+     * Plan 03-02 — per-dimension legal failure-mode list. When present and
+     * non-empty, the runtime rubric assembler announces the legal modes to
+     * the grader before the structured-shape footer (Plan 03-01).
+     * Stamped at config-load time by `failureModesForDimension(dimension)`
+     * from `packages/eval/src/grader/index.ts`.
+     */
+    failureModes: z.array(z.string().min(1)).optional(),
     header: z.string().min(1, "header must be a non-empty string"),
     scale: z
         .array(z.string().min(1))
@@ -118,13 +126,27 @@ export const FeatureRegistrySchema = z.object({
 // ---------------------------------------------------------------------------
 // Assertion schemas — one per Promptfoo assertion type
 // ---------------------------------------------------------------------------
+// TODO(GRAD-01 follow-up): This schema duplicates
+// packages/eval/src/adapters/task-sources/repo-schemas.ts:TemplatedAssertionSchema.
+// Retiring requires reverse-extracting the canonical schema into
+// packages/core/src/schemas/ (D0048 prevents importing from packages/eval).
+// Out of Phase 2 scope; tracked separately.
+//
+// The `satisfies z.ZodType<CriterionRef>` clause asserts this duplicate
+// stays shape-compatible with the canonical domain type in
+// `@sanity/ailf-core` (D0045). If a future edit adds a third field to one
+// schema and not the other, this build error catches the drift.
+const CriterionRefShape = z.object({
+    id: z.string().min(1, "id must be a non-empty slug"),
+    text: z.string().min(1, "text must be a non-empty string"),
+});
 /**
  * Templated llm-rubric assertion — references a rubric template by key
  * and provides task-specific criteria.
  */
 const TemplatedLlmRubricAssertSchema = z.object({
     criteria: z
-        .array(z.string().min(1))
+        .array(CriterionRefShape)
         .min(1, "criteria must have at least one entry"),
     template: z.string().min(1, "template must be a non-empty string"),
     type: z.literal("llm-rubric"),

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

@@ -0,0 +1,40 @@
+/**
+ * Diagnosis card registry — placeholder home for Phase 5 cards.
+ *
+ * Phase 5 cards declare:
+ *
+ *   export const card = {
+ *     type, version, schema, generate
+ *   } satisfies CardDefinition
+ *
+ * The compound `cardVersion` (VER-01 / D-02) is built from per-card
+ * `version` by sorting `${type}@${version}` ascending and joining with
+ * `,`. Phase 1 lands the empty registry; Phase 5 registers cards via
+ * the composition root, not by mutating this binding.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @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, D-08)
+ */
+import type { z } from "zod";
+import type { CardType, DiagnosisCard } from "../../types/diagnosis.js";
+/**
+ * Per-card definition. `schema` is the per-card body parser; `generate`
+ * is the runner-invoked builder. Phase 5 fills in the
+ * `report+attribution+llm` parameter list when card files land — Phase 1
+ * keeps the signature minimal so the registry compiles before any cards
+ * exist.
+ */
+export interface CardDefinition<TBody = unknown> {
+    readonly type: CardType;
+    readonly version: string;
+    readonly schema: z.ZodType<TBody>;
+    readonly generate: () => Promise<DiagnosisCard>;
+}
+/**
+ * Phase 1: empty entrypoint. Phase 5 cards register here through the
+ * composition root. The exported binding is a `ReadonlyMap` so
+ * downstream consumers cannot mutate it (would re-introduce the vitest
+ * worker-leak hazard).
+ */
+export declare const cardRegistry: ReadonlyMap<CardType, CardDefinition>;

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

@@ -0,0 +1,25 @@
+/**
+ * Diagnosis card registry — placeholder home for Phase 5 cards.
+ *
+ * Phase 5 cards declare:
+ *
+ *   export const card = {
+ *     type, version, schema, generate
+ *   } satisfies CardDefinition
+ *
+ * The compound `cardVersion` (VER-01 / D-02) is built from per-card
+ * `version` by sorting `${type}@${version}` ascending and joining with
+ * `,`. Phase 1 lands the empty registry; Phase 5 registers cards via
+ * the composition root, not by mutating this binding.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @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, D-08)
+ */
+/**
+ * Phase 1: empty entrypoint. Phase 5 cards register here through the
+ * composition root. The exported binding is a `ReadonlyMap` so
+ * downstream consumers cannot mutate it (would re-introduce the vitest
+ * worker-leak hazard).
+ */
+export const cardRegistry = new Map();