@sanity/ailf 4.6.0 → 6.0.0

package/dist/adapters/attribution/per-entry-attribution-writer.js

@@ -0,0 +1,49 @@
+/**
+ * per-entry-attribution-writer.ts — Zod schema for the per-judgment
+ * attribution artifact (ATTR-01) emitted by Phase 4's
+ * `ComputeAttributionStep` and read back by Phase 5's diagnosis runner.
+ *
+ * The schema asserts `satisfies z.ZodType<JudgmentAttribution>` against
+ * the canonical domain type in `packages/core/src/types/attribution.ts`
+ * (D0045 / W0187) — drift between schema and type is a build error.
+ *
+ * Phase 1 lands the SHAPE only — no compute, no file I/O. Phase 4 wires
+ * the writer; Phase 5 wires the reader. Both `satisfies` against this
+ * single source-of-truth schema.
+ *
+ * `hallucinationCheckedAgainst` is REQUIRED (Pitfall #11): consumers
+ * must be able to audit citation grounding without re-deriving the
+ * resolvable-set. The canonical task field is `contextDocs`; do NOT
+ * invent `expectedDocs` / `usedDocs` synonyms.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @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 { z } from "zod";
+import { ConfidenceSchema } from "../../_vendor/ailf-core/schemas/index.js";
+const DocAttributionSchema = z.object({
+    documentId: z.string().min(1),
+    slug: z.string().optional(),
+    score: z.number().min(0).max(1),
+    signals: z.object({
+        citation: z.number().min(0).max(1).optional(),
+        canonical: z.number().min(0).max(1).optional(),
+        retrieved: z.number().min(0).max(1).optional(),
+    }),
+    confidence: ConfidenceSchema,
+});
+/**
+ * Canonical schema for {@link JudgmentAttribution}. Persisted at
+ * `runs/{runId}/attribution/{entryKey}.json` (Phase 4) and parsed by
+ * the diagnosis runner on read (Phase 5).
+ */
+export const JudgmentAttributionSchema = z.object({
+    judgmentRef: z.string().min(1),
+    taskId: z.string().min(1),
+    modelId: z.string().min(1),
+    dimension: z.string().min(1),
+    attributions: z.array(DocAttributionSchema),
+    hallucinationCheckedAgainst: z.array(z.string()),
+});

package/dist/adapters/config-sources/file-config-adapter.js

@@ -125,6 +125,7 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
         noCache: config.noCache ?? false,
         noRemoteCache: config.noRemoteCache ?? false,
         graderReplications: config.execution?.graderReplications,
+        borderlineReplications: config.execution?.borderlineReplications,
         graderContext: config.grader?.context,
         urls: config.urls,
         headers: config.agentic?.headers,

package/dist/adapters/grader-outputs/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * grader-outputs adapter barrel — named re-exports only (W0124 / D0045).
+ *
+ * The grader-output schema lives here so it enters the D0045
+ * `pnpm check-trust-boundary-satisfies` SCAN_ROOTS gate.
+ */
+export { GraderJudgmentSchema, graderJudgmentsVersion, } from "./promptfoo-grader-output.js";
+export type { GraderJudgment } from "../../_vendor/ailf-core/index.d.ts";
+export { LegacyGraderJudgmentSchema } from "./legacy/index.js";
+export type { LegacyGraderJudgment } from "../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/grader-outputs/index.js

@@ -0,0 +1,8 @@
+/**
+ * grader-outputs adapter barrel — named re-exports only (W0124 / D0045).
+ *
+ * The grader-output schema lives here so it enters the D0045
+ * `pnpm check-trust-boundary-satisfies` SCAN_ROOTS gate.
+ */
+export { GraderJudgmentSchema, graderJudgmentsVersion, } from "./promptfoo-grader-output.js";
+export { LegacyGraderJudgmentSchema } from "./legacy/index.js";

package/dist/adapters/grader-outputs/legacy/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * legacy grader-outputs adapter sub-barrel — named re-exports only
+ * (W0124 / D0045).
+ *
+ * Read-only schema for the Phase 1 free-prose grader-output shape,
+ * invoked only by historical-report rendering paths through Phase 7
+ * (GRAD-06 cutover). The schema lives here so it enters the D0045
+ * `pnpm check-trust-boundary-satisfies` SCAN_ROOTS gate.
+ */
+export { LegacyGraderJudgmentSchema } from "./promptfoo-grader-output-legacy.js";
+export type { LegacyGraderJudgment } from "../../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/grader-outputs/legacy/index.js

@@ -0,0 +1,10 @@
+/**
+ * legacy grader-outputs adapter sub-barrel — named re-exports only
+ * (W0124 / D0045).
+ *
+ * Read-only schema for the Phase 1 free-prose grader-output shape,
+ * invoked only by historical-report rendering paths through Phase 7
+ * (GRAD-06 cutover). The schema lives here so it enters the D0045
+ * `pnpm check-trust-boundary-satisfies` SCAN_ROOTS gate.
+ */
+export { LegacyGraderJudgmentSchema } from "./promptfoo-grader-output-legacy.js";

package/dist/adapters/grader-outputs/legacy/promptfoo-grader-output-legacy.d.ts

@@ -0,0 +1,49 @@
+/**
+ * promptfoo-grader-output-legacy.ts — Zod schema for the Phase 1
+ * free-prose grader-output shape, used by historical-report rendering
+ * paths.
+ *
+ * READ-ONLY: invoked only by historical-report rendering paths through
+ * Phase 7 (GRAD-06 cutover). Reports are immutable events — once a
+ * Report is written to Content Lake, the structured grader-judgment
+ * shape it captures cannot be back-filled. The legacy schema exists so
+ * pre-Phase-3 reports continue to deserialize cleanly.
+ *
+ * Live grader output that fails the strict {@link GraderJudgmentSchema}
+ * parse must NOT fall back to this schema. Drop to
+ * `failureMode: "unclassified"` instead. Strict and legacy schemas are
+ * deliberate siblings, not a legacy/canonical pair to consolidate.
+ *
+ * The schema asserts `satisfies z.ZodType<LegacyGraderJudgment>` against
+ * the canonical domain type in
+ * `packages/core/src/types/legacy-grader-judgment.ts` (D0045 / W0187) —
+ * drift between schema and type is a build error. The domain type is
+ * authored independently in `@sanity/ailf-core`; this file authors ONLY
+ * the schema and never derives the domain type from the schema itself
+ * (no schema-derived self-reference allowed by D0045).
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see ../promptfoo-grader-output.ts — the strict (live-path) sibling
+ * @see docs/design-docs/actionability-ladder/03-structured-grader-judgments.md
+ *      §"Backwards compatibility"
+ */
+import { z } from "zod";
+/**
+ * Canonical schema for {@link LegacyGraderJudgment}. Mirrors the Phase 1
+ * superset core (`taskId`, `modelId`, `dimension`, `reason`, `score`,
+ * optional `outputFailure`). NO GRAD-02 additive fields — those are by
+ * construction absent on pre-Phase-3 output.
+ *
+ * Intentionally NOT `.strict()` — pre-Phase-3 reports may carry stray
+ * keys; the legacy parser tolerates them so historical-report rendering
+ * keeps working through the GRAD-06 cutover.
+ */
+export declare const LegacyGraderJudgmentSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    modelId: z.ZodString;
+    dimension: z.ZodString;
+    reason: z.ZodString;
+    score: z.ZodNumber;
+    outputFailure: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type { LegacyGraderJudgment } from "../../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/grader-outputs/legacy/promptfoo-grader-output-legacy.js

@@ -0,0 +1,48 @@
+/**
+ * promptfoo-grader-output-legacy.ts — Zod schema for the Phase 1
+ * free-prose grader-output shape, used by historical-report rendering
+ * paths.
+ *
+ * READ-ONLY: invoked only by historical-report rendering paths through
+ * Phase 7 (GRAD-06 cutover). Reports are immutable events — once a
+ * Report is written to Content Lake, the structured grader-judgment
+ * shape it captures cannot be back-filled. The legacy schema exists so
+ * pre-Phase-3 reports continue to deserialize cleanly.
+ *
+ * Live grader output that fails the strict {@link GraderJudgmentSchema}
+ * parse must NOT fall back to this schema. Drop to
+ * `failureMode: "unclassified"` instead. Strict and legacy schemas are
+ * deliberate siblings, not a legacy/canonical pair to consolidate.
+ *
+ * The schema asserts `satisfies z.ZodType<LegacyGraderJudgment>` against
+ * the canonical domain type in
+ * `packages/core/src/types/legacy-grader-judgment.ts` (D0045 / W0187) —
+ * drift between schema and type is a build error. The domain type is
+ * authored independently in `@sanity/ailf-core`; this file authors ONLY
+ * the schema and never derives the domain type from the schema itself
+ * (no schema-derived self-reference allowed by D0045).
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see ../promptfoo-grader-output.ts — the strict (live-path) sibling
+ * @see docs/design-docs/actionability-ladder/03-structured-grader-judgments.md
+ *      §"Backwards compatibility"
+ */
+import { z } from "zod";
+/**
+ * Canonical schema for {@link LegacyGraderJudgment}. Mirrors the Phase 1
+ * superset core (`taskId`, `modelId`, `dimension`, `reason`, `score`,
+ * optional `outputFailure`). NO GRAD-02 additive fields — those are by
+ * construction absent on pre-Phase-3 output.
+ *
+ * Intentionally NOT `.strict()` — pre-Phase-3 reports may carry stray
+ * keys; the legacy parser tolerates them so historical-report rendering
+ * keeps working through the GRAD-06 cutover.
+ */
+export const LegacyGraderJudgmentSchema = z.object({
+    taskId: z.string().min(1),
+    modelId: z.string().min(1),
+    dimension: z.string().min(1),
+    reason: z.string(),
+    score: z.number(),
+    outputFailure: z.boolean().optional(),
+});

package/dist/adapters/grader-outputs/promptfoo-grader-output.d.ts

@@ -0,0 +1,102 @@
+/**
+ * promptfoo-grader-output.ts — Zod schema for the structured grader output
+ * (GRAD-02) emitted by the promptfoo grader process and consumed by the
+ * eval pipeline.
+ *
+ * The schema asserts `satisfies z.ZodType<GraderJudgment>` against the
+ * canonical domain type in `packages/core/src/types/grader-judgment.ts`
+ * (D0045 / W0187) — drift between schema and type is a build error.
+ * The domain type was authored independently in Plan 01-01; this file
+ * authors ONLY the schema and never derives the domain type from the
+ * schema itself (no schema-derived self-reference allowed by D0045).
+ *
+ * `graderJudgmentsVersion` is co-located with the schema (VER-01 D-02 —
+ * source-of-truth file owns its version constant). Bumped by hand when
+ * the grader rubric, prompt template, or judgment shape changes.
+ *
+ * Phase 3 will replace the inline `JSON.parse` at
+ * `pipeline/calculate-scores.ts:380-392` (Pitfall #4) so all grader
+ * output flows through this schema.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/design-docs/actionability-ladder/03-structured-grader-judgments.md
+ */
+import { z } from "zod";
+/**
+ * VER-01 D-02 — co-located version constant. Bumped by hand when the
+ * grader rubric, prompt template, or judgment shape changes in a way
+ * that should invalidate cached Diagnoses.
+ *
+ * Phase 3 GRAD-05 bumped this from `"0.1.0"` to `"1.0.0"` (semver
+ * major) — the additive GRAD-02 surface is now required + the schema
+ * is `.strict()`. AILF has no installed external base; the legacy
+ * parser at `./legacy/promptfoo-grader-output-legacy.ts` is the named
+ * consumer for already-stored historical reports.
+ */
+export declare const graderJudgmentsVersion = "1.0.0";
+/**
+ * Canonical schema for {@link GraderJudgment}. Required fields mirror
+ * the existing pipeline core (Doc 03 §"existing, unchanged"):
+ * `taskId`, `modelId`, `dimension`, `reason`, `score`. Phase 3 GRAD-05
+ * has tightened the additive surface to required and added `.strict()`
+ * — the schema rejects unknown fields (defense-in-depth against future
+ * prompt-injection attempts that try to smuggle keys through the
+ * grader emission).
+ *
+ * Branded `JudgmentId` is represented at runtime by a non-empty string;
+ * the schema routes the brand through `brandedString<"JudgmentId">()`
+ * — the project's single audited cast site for branded-string
+ * schemas (project typescript rule: no `as` on `unknown`).
+ */
+export declare const GraderJudgmentSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    modelId: z.ZodString;
+    dimension: z.ZodString;
+    reason: z.ZodString;
+    score: z.ZodNumber;
+    outputFailure: z.ZodOptional<z.ZodBoolean>;
+    judgmentId: z.ZodType<import("@sanity/ailf-core").Brand<string, "JudgmentId">, unknown, z.core.$ZodTypeInternals<import("@sanity/ailf-core").Brand<string, "JudgmentId">, unknown>>;
+    subJudgments: z.ZodArray<z.ZodObject<{
+        criterionId: z.ZodString;
+        met: z.ZodBoolean;
+        evidence: z.ZodString;
+        confidence: z.ZodObject<{
+            level: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+            signalsPresent: z.ZodNumber;
+            derivation: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    docCitations: z.ZodArray<z.ZodObject<{
+        documentId: z.ZodString;
+        slug: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            supports: "supports";
+            contradicts: "contradicts";
+            missing: "missing";
+            irrelevant: "irrelevant";
+        }>;
+        hallucinated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    failureMode: z.ZodString;
+    confidence: z.ZodObject<{
+        level: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        signalsPresent: z.ZodNumber;
+        derivation: z.ZodString;
+    }, z.core.$strip>;
+    hallucinationCheckedAgainst: z.ZodArray<z.ZodString>;
+    metadata: z.ZodObject<{
+        graderModel: z.ZodString;
+        graderJudgmentsVersion: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type { GraderJudgment } from "../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/grader-outputs/promptfoo-grader-output.js

@@ -0,0 +1,93 @@
+/**
+ * promptfoo-grader-output.ts — Zod schema for the structured grader output
+ * (GRAD-02) emitted by the promptfoo grader process and consumed by the
+ * eval pipeline.
+ *
+ * The schema asserts `satisfies z.ZodType<GraderJudgment>` against the
+ * canonical domain type in `packages/core/src/types/grader-judgment.ts`
+ * (D0045 / W0187) — drift between schema and type is a build error.
+ * The domain type was authored independently in Plan 01-01; this file
+ * authors ONLY the schema and never derives the domain type from the
+ * schema itself (no schema-derived self-reference allowed by D0045).
+ *
+ * `graderJudgmentsVersion` is co-located with the schema (VER-01 D-02 —
+ * source-of-truth file owns its version constant). Bumped by hand when
+ * the grader rubric, prompt template, or judgment shape changes.
+ *
+ * Phase 3 will replace the inline `JSON.parse` at
+ * `pipeline/calculate-scores.ts:380-392` (Pitfall #4) so all grader
+ * output flows through this schema.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/design-docs/actionability-ladder/03-structured-grader-judgments.md
+ */
+import { z } from "zod";
+import { brandedString, ConfidenceSchema } from "../../_vendor/ailf-core/schemas/index.js";
+/**
+ * VER-01 D-02 — co-located version constant. Bumped by hand when the
+ * grader rubric, prompt template, or judgment shape changes in a way
+ * that should invalidate cached Diagnoses.
+ *
+ * Phase 3 GRAD-05 bumped this from `"0.1.0"` to `"1.0.0"` (semver
+ * major) — the additive GRAD-02 surface is now required + the schema
+ * is `.strict()`. AILF has no installed external base; the legacy
+ * parser at `./legacy/promptfoo-grader-output-legacy.ts` is the named
+ * consumer for already-stored historical reports.
+ */
+export const graderJudgmentsVersion = "1.0.0";
+const DocCitationRoleSchema = z.enum([
+    "supports",
+    "contradicts",
+    "missing",
+    "irrelevant",
+]);
+const DocCitationSchema = z.object({
+    documentId: z.string().min(1),
+    slug: z.string().optional(),
+    role: DocCitationRoleSchema,
+    hallucinated: z.boolean().optional(),
+});
+const CriterionSubJudgmentSchema = z.object({
+    criterionId: z.string().min(1),
+    met: z.boolean(),
+    evidence: z.string().max(280),
+    confidence: ConfidenceSchema,
+});
+/**
+ * Canonical schema for {@link GraderJudgment}. Required fields mirror
+ * the existing pipeline core (Doc 03 §"existing, unchanged"):
+ * `taskId`, `modelId`, `dimension`, `reason`, `score`. Phase 3 GRAD-05
+ * has tightened the additive surface to required and added `.strict()`
+ * — the schema rejects unknown fields (defense-in-depth against future
+ * prompt-injection attempts that try to smuggle keys through the
+ * grader emission).
+ *
+ * Branded `JudgmentId` is represented at runtime by a non-empty string;
+ * the schema routes the brand through `brandedString<"JudgmentId">()`
+ * — the project's single audited cast site for branded-string
+ * schemas (project typescript rule: no `as` on `unknown`).
+ */
+export const GraderJudgmentSchema = z
+    .object({
+    // ── Existing pipeline core (required — Doc 03 §"existing, unchanged") ─
+    taskId: z.string().min(1),
+    modelId: z.string().min(1),
+    dimension: z.string().min(1),
+    reason: z.string(),
+    score: z.number(),
+    outputFailure: z.boolean().optional(),
+    // ── GRAD-02 additive — required from Phase 3 GRAD-05 ───────────────
+    judgmentId: brandedString(),
+    subJudgments: z.array(CriterionSubJudgmentSchema),
+    docCitations: z.array(DocCitationSchema),
+    failureMode: z.string(),
+    confidence: ConfidenceSchema,
+    hallucinationCheckedAgainst: z.array(z.string()),
+    metadata: z.object({
+        graderModel: z.string().min(1),
+        graderJudgmentsVersion: z.string().min(1),
+    }),
+})
+    .strict();

package/dist/adapters/index.d.ts

@@ -10,3 +10,6 @@ export { PromptfooEvalAdapter } from "./eval-runners/index.js";
 export { ConsoleLogger, type ConsoleLoggerOptions, JsonLogger, QuietLogger, } from "./loggers/index.js";
 export { CliConfigAdapter, FileConfigAdapter } from "./config-sources/index.js";
 export { DtsPackageSurface, InMemoryPackageSurface, type DtsPackageSurfaceOptions, type PackageRootResolver, parseDtsExports, type ParsedDtsExports, } from "./package-surface/index.js";
+export { GraderJudgmentSchema, graderJudgmentsVersion, } from "./grader-outputs/index.js";
+export { AttributionMetaSchema, JudgmentAttributionSchema, } from "./attribution/index.js";
+export type { AttributionMeta, DocAttribution, GraderJudgment, JudgmentAttribution, } from "../_vendor/ailf-core/index.d.ts";

package/dist/adapters/index.js

@@ -10,3 +10,7 @@ export { PromptfooEvalAdapter } from "./eval-runners/index.js";
 export { ConsoleLogger, JsonLogger, QuietLogger, } from "./loggers/index.js";
 export { CliConfigAdapter, FileConfigAdapter } from "./config-sources/index.js";
 export { DtsPackageSurface, InMemoryPackageSurface, parseDtsExports, } from "./package-surface/index.js";
+// Phase 1 Plan 02 — actionability-ladder adapter schemas (GRAD-02, ATTR-01).
+// Named re-exports only (W0124 / D0045).
+export { GraderJudgmentSchema, graderJudgmentsVersion, } from "./grader-outputs/index.js";
+export { AttributionMetaSchema, JudgmentAttributionSchema, } from "./attribution/index.js";

package/dist/adapters/llm/fake-llm-client.d.ts

@@ -40,9 +40,29 @@ export declare class FakeLLMClient implements LLMClient {
     readonly calls: FakeCallRecord[];
     private readonly completeQueue;
     private readonly structuredQueue;
+    /**
+     * Per-cardId keyed responses. A single-value entry is returned on every
+     * call for that cardId (repeated calls always get the same response). An
+     * array-value entry is consumed in order; once exhausted, calls for that
+     * cardId fall back to the FIFO structuredQueue.
+     *
+     * This is the substrate Plan 07's 17-fixture eval matrix uses to wire
+     * deterministic responses to specific LLM cards.
+     */
+    private readonly keyedResponses;
     constructor(args?: {
         completeResponses?: FakeCompletionResponse[];
         structuredResponses?: FakeStructuredResponse[];
+        /**
+         * Optional keyed-response map. Keys are `cardId` values from
+         * `args.context.cardId`. When a call matches a key the keyed entry is
+         * used instead of the FIFO queue.
+         *
+         * - Single-value entry: same response on every call for this cardId.
+         * - Array-value entry: entries consumed in insertion order; falls back
+         *   to FIFO (or throws) when the array is exhausted.
+         */
+        keyedResponses?: Record<string, FakeStructuredResponse | FakeStructuredResponse[]>;
     });
     complete(args: LLMCompleteArgs): Promise<LLMCompletion>;
     completeStructured<T>(args: LLMCompleteStructuredArgs<T>): Promise<LLMStructuredCompletion<T>>;

package/dist/adapters/llm/fake-llm-client.js

@@ -11,9 +11,25 @@ export class FakeLLMClient {
     calls = [];
     completeQueue;
     structuredQueue;
+    /**
+     * Per-cardId keyed responses. A single-value entry is returned on every
+     * call for that cardId (repeated calls always get the same response). An
+     * array-value entry is consumed in order; once exhausted, calls for that
+     * cardId fall back to the FIFO structuredQueue.
+     *
+     * This is the substrate Plan 07's 17-fixture eval matrix uses to wire
+     * deterministic responses to specific LLM cards.
+     */
+    keyedResponses;
     constructor(args = {}) {
         this.completeQueue = [...(args.completeResponses ?? [])];
         this.structuredQueue = [...(args.structuredResponses ?? [])];
+        // Deep-copy arrays so the caller's fixture data is not mutated.
+        const keyed = {};
+        for (const [key, val] of Object.entries(args.keyedResponses ?? {})) {
+            keyed[key] = Array.isArray(val) ? [...val] : val;
+        }
+        this.keyedResponses = keyed;
     }
     async complete(args) {
         this.calls.push({
@@ -37,13 +53,34 @@ export class FakeLLMClient {
         };
     }
     async completeStructured(args) {
+        // Record every call first so test assertions on this.calls are never
+        // affected by which branch (keyed vs FIFO) handles the response.
         this.calls.push({
             kind: "completeStructured",
             model: args.model,
             prompt: args.prompt,
             ...(args.context ? { context: args.context } : {}),
         });
-        const next = this.structuredQueue.shift();
+        let next;
+        const cardId = args.context?.cardId;
+        if (cardId !== undefined && cardId in this.keyedResponses) {
+            const entry = this.keyedResponses[cardId];
+            if (Array.isArray(entry)) {
+                // Array-value: consume one entry per call. When exhausted, fall
+                // through to the FIFO queue below.
+                if (entry.length > 0) {
+                    next = entry.shift();
+                }
+            }
+            else {
+                // Single-value: return the same response on every call.
+                next = entry;
+            }
+        }
+        if (next === undefined) {
+            // FIFO fallback (existing behavior)
+            next = this.structuredQueue.shift();
+        }
         if (!next) {
             throw new Error("FakeLLMClient: no more queued structured responses (call exceeded queue)");
         }

package/dist/adapters/llm/openai-llm-client.js

@@ -10,6 +10,7 @@
  * the adapter never reads `process.env`. The composition root maps env vars
  * to typed constructor args.
  */
+import { z } from "zod";
 import { OpenAIChatResponseSchema, splitModelId, } from "../../_vendor/ailf-core/index.js";
 import { DEFAULT_RETRY_POLICY, parseRetryAfterSeconds, runWithRetry, } from "./retry.js";
 const DEFAULT_BASE_URL = "https://api.openai.com/v1/chat/completions";
@@ -67,10 +68,25 @@ export class OpenAILLMClient {
     }
     async completeStructured(args) {
         const { modelName } = splitModelId(args.model);
+        // Derive the JSON Schema from the caller's Zod schema. Zod v4 natively
+        // emits `additionalProperties: false` on every nested z.object node —
+        // this is required for OpenAI strict-mode.
+        const jsonSchema = z.toJSONSchema(args.schema, { target: "draft-2020-12" });
+        // OpenAI strict-mode requires the root to be a plain object schema (no
+        // anyOf/oneOf/allOf at the top level). Discriminated unions produce
+        // anyOf at the root — callers must wrap them in a discriminator object.
+        assertSchemaIsObjectRoot(jsonSchema, args.model);
         const body = buildBody(modelName, args.prompt, {
-            temperature: args.temperature,
-            maxTokens: args.maxTokens,
-            responseFormat: { type: "json_object" },
+            temperature: args.temperature ?? 0.1,
+            maxTokens: args.maxTokens ?? 2000,
+            responseFormat: {
+                type: "json_schema",
+                json_schema: {
+                    name: args.context?.cardId ?? "structured_output",
+                    schema: jsonSchema,
+                    strict: true,
+                },
+            },
         });
         const data = await this.callApi(body);
         const raw = data.choices?.[0]?.message?.content;
@@ -84,6 +100,9 @@ export class OpenAILLMClient {
         catch (err) {
             throw new Error(`OpenAI structured completion returned invalid JSON for model ${args.model}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
         }
+        // strict:true guarantees a valid-against-the-schema JSON document, but
+        // the Zod parse is still load-bearing — it brands the result as T and is
+        // the only contract the engine trusts (D0045 parse-don't-validate).
         const value = args.schema.parse(parsed);
         const usage = extractUsage(data.usage);
         const cost = this.computeCost(modelName, usage);
@@ -145,6 +164,36 @@ export class OpenAILLMClient {
             `cost_usd=${cost.toFixed(6)}`);
     }
 }
+/**
+ * Assert that the JSON Schema root is a plain object type.
+ *
+ * OpenAI strict-mode requires the root schema to be `{ type: "object" }`.
+ * A discriminated union (`z.union([...])`) produces `{ anyOf: [...] }` at
+ * the root — callers must wrap the union in a discriminator object before
+ * passing it to `completeStructured`.
+ *
+ * Per AI-SPEC §3 Pitfall 6 + T-05-03-01: caught at request-build time to
+ * avoid wasting API budget on a guaranteed 400.
+ */
+function assertSchemaIsObjectRoot(schema, modelId) {
+    if (typeof schema !== "object" || schema === null) {
+        throw new Error(`OpenAILLMClient: OpenAI strict-mode requires a single z.object at the ` +
+            `schema root for model ${modelId}; got non-object JSON Schema root.`);
+    }
+    const node = schema;
+    if (node.type !== "object") {
+        // Identify the kind so the error message is actionable.
+        const kind = "anyOf" in node
+            ? "z.union"
+            : "oneOf" in node
+                ? "z.discriminatedUnion"
+                : "allOf" in node
+                    ? "z.intersection"
+                    : String(node.type ?? "unknown");
+        throw new Error(`OpenAILLMClient: OpenAI strict-mode requires a single z.object at the ` +
+            `schema root; got ${kind}. Wrap the union in a discriminator object.`);
+    }
+}
 function buildBody(modelName, prompt, opts) {
     const body = {
         model: modelName,

package/dist/adapters/task-sources/content-lake-task-source.d.ts

@@ -55,9 +55,13 @@ interface ContentLakeCanonicalDoc {
     sectionSlug?: string;
     slug?: string;
 }
+interface ContentLakeCriterion {
+    id?: string;
+    text?: string;
+}
 /** Assertion shape from the Content Lake (mirrors the Studio schema). */
 interface ContentLakeAssertion {
-    criteria?: string[];
+    criteria?: ContentLakeCriterion[];
     template?: string;
     threshold?: number;
     type?: string;

package/dist/adapters/task-sources/content-lake-task-source.js

@@ -73,7 +73,13 @@ const TASKS_QUERY = /* groq */ `
     perspective,
     reason
   },
-  "assertions": coalesce(assertions, assert),
+  "assertions": coalesce(assertions, assert)[] {
+    type, template, weight, value, threshold,
+    "criteria": criteria[] {
+      "id": coalesce(id.current, _key),
+      "text": coalesce(text, @)
+    }
+  },
   rawAssert,
   baseline,
   tags,
@@ -256,8 +262,28 @@ function mapAssertions(raw) {
         .filter((a) => !!a.type)
         .map((a) => {
         if (a.type === "llm-rubric" && a.template && a.criteria) {
+            // Tighten the runtime contract: the GROQ projection's
+            // `coalesce(text, @)` falls through to the entire criterion
+            // element when `text` is missing, so a partial legacy criterion
+            // like `{_key: "abc"}` arrives here as `{ id: "abc", text: {...} }`
+            // — `text` set to the whole `@` object. Explicit type checks
+            // drop those with a diagnostic, instead of letting the non-string
+            // `text` propagate until the outer ContentLakeAuthorableTaskSchema
+            // parse fails deep inside the assertions array (noisy diagnostic).
             return {
-                criteria: a.criteria,
+                criteria: a.criteria
+                    .filter((c) => {
+                    if (!c)
+                        return false;
+                    const idOk = typeof c.id === "string" && c.id.length > 0;
+                    const textOk = typeof c.text === "string" && c.text.length > 0;
+                    if (!idOk || !textOk) {
+                        console.warn(`[ContentLakeTaskSource] dropping malformed criterion: ${JSON.stringify(c).slice(0, 100)}`);
+                        return false;
+                    }
+                    return true;
+                })
+                    .map((c) => ({ id: c.id, text: c.text })),
                 template: a.template,
                 type: "llm-rubric",
                 ...(a.weight !== undefined ? { weight: a.weight } : {}),