@sanity/ailf 0.1.0

package/dist/_vendor/ailf-core/ports/task-source.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Port: Where task definitions come from.
+ *
+ * Adapters:
+ * - YamlTaskSource (current) — reads tasks/*.yaml files
+ * - ContentLakeTaskSource (tasks-as-content Phase 2) — GROQ query
+ * - RepoTaskSource (tasks-as-content Phase 4) — reads .ailf/tasks/
+ *
+ * The key invariant: the pipeline orchestrator and all downstream steps
+ * work with TaskDefinition[] regardless of where they came from.
+ */
+import type { FilterOptions } from "../types/index.js";
+/** A templated assertion referencing a rubric template from config/rubrics.yaml */
+export interface TemplatedAssertion {
+    type: "llm-rubric";
+    template: string;
+    criteria: string[];
+    weight?: number;
+}
+/** A value-based assertion (contains, javascript, etc.) */
+export interface ValueAssertion {
+    type: string;
+    value?: unknown;
+    weight?: number;
+    [key: string]: unknown;
+}
+/** Any assertion definition — either templated or value-based */
+export type AssertionDefinition = TemplatedAssertion | ValueAssertion;
+/** Baseline variant configuration */
+export interface BaselineConfig {
+    /** Whether to generate a baseline variant. Default: true */
+    enabled?: boolean;
+    /** Rubric mode for baseline. Default: "abbreviated" */
+    rubric?: "abbreviated" | "full" | "none";
+}
+/**
+ * A canonical documentation reference. Each entry resolves docs through
+ * one of four strategies, discriminated by key presence (no explicit
+ * `type` field). All strategies carry an optional `reason` for context.
+ *
+ * Strategies:
+ * - `slug`        — one article by slug field (legacy, may not be unique)
+ * - `path`        — one article by URL path (unique across sections)
+ * - `id`          — one document by Sanity `_id` (drafts, imports)
+ * - `perspective` — all articles in a content release (one-to-many)
+ *
+ * @see docs/design-docs/canonical-doc-resolution.md
+ */
+export type CanonicalDocRef = SlugDocRef | PathDocRef | IdDocRef | PerspectiveDocRef;
+/** Resolve by article slug field. Legacy — prefer `path` for uniqueness. */
+export interface SlugDocRef {
+    slug: string;
+    reason?: string;
+}
+/** Resolve by URL path (after /docs/). Unique across sections. */
+export interface PathDocRef {
+    path: string;
+    reason?: string;
+}
+/** Resolve by Sanity document `_id`. The primary resolution strategy.
+ *
+ * Optional `slug` and `path` provide human-readable context — they are
+ * NOT used for resolution (the `_id` is authoritative) but help YAML
+ * authors understand which document is being referenced. The Content Lake
+ * adapter populates them from the dereferenced article.
+ */
+export interface IdDocRef {
+    id: string;
+    reason?: string;
+    /** Human-readable slug (informational only — not used for resolution) */
+    slug?: string;
+    /** Human-readable path (informational only — not used for resolution) */
+    path?: string;
+}
+/** Resolve all articles in a content release. One-to-many. */
+export interface PerspectiveDocRef {
+    perspective: string;
+    reason?: string;
+}
+/**
+ * A loaded, validated task definition ready for expansion.
+ *
+ * This is the canonical intermediate representation — adapters produce
+ * this from YAML, Content Lake, or .ailf/ files. Downstream consumers
+ * (expansion, doc fetching, validation) work exclusively with this type.
+ *
+ * Design notes:
+ * - `taskPrompt` is extracted from `vars.task` in YAML format
+ * - `docsPath` is NOT included — it's an infrastructure detail derived
+ *   from convention (`file://contexts/canonical/${id}.md`)
+ * - `featureArea` is derived by the adapter (filename stem, document
+ *   field, directory structure — depends on the source)
+ */
+export interface TaskDefinition {
+    /** Unique task identifier */
+    id: string;
+    /** Human-readable description */
+    description: string;
+    /** Feature area this task belongs to */
+    featureArea: string;
+    /** The implementation task prompt (the user-facing request) */
+    taskPrompt: string;
+    /** Canonical doc references with reasons */
+    canonicalDocs: CanonicalDocRef[];
+    /** Path to the reference solution (relative to eval package root) */
+    referenceSolution: string;
+    /** Whether doc coverage rubric should be auto-generated */
+    docCoverage: boolean;
+    /** Assertion definitions (rubric templates + value assertions) */
+    assertions: AssertionDefinition[];
+    /** Baseline variant configuration */
+    baseline?: BaselineConfig;
+    /** Additional template variables beyond task (e.g., custom vars) */
+    extraVars?: Record<string, unknown>;
+}
+/** Check if a canonical doc ref resolves by slug.
+ *
+ * Excludes IdDocRef (which may carry an optional `slug` for display).
+ * When both `id` and `slug` are present, it's an IdDocRef, not a SlugDocRef.
+ */
+export declare function isSlugRef(ref: CanonicalDocRef): ref is SlugDocRef;
+/** Check if a canonical doc ref resolves by path.
+ *
+ * Excludes IdDocRef (which may carry an optional `path` for display).
+ * When both `id` and `path` are present, it's an IdDocRef, not a PathDocRef.
+ */
+export declare function isPathRef(ref: CanonicalDocRef): ref is PathDocRef;
+/** Check if a canonical doc ref resolves by document ID.
+ *
+ * Uses `"id" in ref` as the primary discriminator. IdDocRef may also carry
+ * optional `slug` and `path` for display purposes, so we cannot exclude
+ * on those keys. When both `id` and `slug` are present, `id` wins.
+ */
+export declare function isIdRef(ref: CanonicalDocRef): ref is IdDocRef;
+/** Check if a canonical doc ref resolves by content release perspective */
+export declare function isPerspectiveRef(ref: CanonicalDocRef): ref is PerspectiveDocRef;
+/**
+ * Extract a display identifier from any canonical doc ref.
+ * Useful for logging, error messages, and retrieval metrics.
+ */
+export declare function canonicalDocRefLabel(ref: CanonicalDocRef): string;
+/** Check if an assertion uses the templated format (template + criteria) */
+export declare function isTemplatedAssertion(entry: AssertionDefinition): entry is TemplatedAssertion;
+/**
+ * Port: Where task definitions come from.
+ *
+ * The pipeline never knows HOW tasks are loaded — it only sees
+ * TaskDefinition[]. The adapter handles YAML parsing, GROQ queries,
+ * filesystem scanning, etc.
+ */
+export interface TaskSource {
+    /**
+     * Load task definitions, optionally filtered by area/task.
+     *
+     * @param filter — Area, task ID, or changed-doc filters
+     * @returns Validated task definitions ready for expansion
+     */
+    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+}

package/dist/_vendor/ailf-core/ports/task-source.js

@@ -0,0 +1,72 @@
+/**
+ * Port: Where task definitions come from.
+ *
+ * Adapters:
+ * - YamlTaskSource (current) — reads tasks/*.yaml files
+ * - ContentLakeTaskSource (tasks-as-content Phase 2) — GROQ query
+ * - RepoTaskSource (tasks-as-content Phase 4) — reads .ailf/tasks/
+ *
+ * The key invariant: the pipeline orchestrator and all downstream steps
+ * work with TaskDefinition[] regardless of where they came from.
+ */
+// ---------------------------------------------------------------------------
+// Type guards — canonical doc refs
+// ---------------------------------------------------------------------------
+/** Check if a canonical doc ref resolves by slug.
+ *
+ * Excludes IdDocRef (which may carry an optional `slug` for display).
+ * When both `id` and `slug` are present, it's an IdDocRef, not a SlugDocRef.
+ */
+export function isSlugRef(ref) {
+    return "slug" in ref && !("id" in ref);
+}
+/** Check if a canonical doc ref resolves by path.
+ *
+ * Excludes IdDocRef (which may carry an optional `path` for display).
+ * When both `id` and `path` are present, it's an IdDocRef, not a PathDocRef.
+ */
+export function isPathRef(ref) {
+    return "path" in ref && !("id" in ref);
+}
+/** Check if a canonical doc ref resolves by document ID.
+ *
+ * Uses `"id" in ref` as the primary discriminator. IdDocRef may also carry
+ * optional `slug` and `path` for display purposes, so we cannot exclude
+ * on those keys. When both `id` and `slug` are present, `id` wins.
+ */
+export function isIdRef(ref) {
+    return "id" in ref;
+}
+/** Check if a canonical doc ref resolves by content release perspective */
+export function isPerspectiveRef(ref) {
+    return "perspective" in ref;
+}
+/**
+ * Extract a display identifier from any canonical doc ref.
+ * Useful for logging, error messages, and retrieval metrics.
+ */
+export function canonicalDocRefLabel(ref) {
+    if ("id" in ref) {
+        // Show slug/path annotation if available for readability
+        const hint = "slug" in ref ? ` (${ref.slug})` : "path" in ref ? ` (${ref.path})` : "";
+        return `id:${ref.id}${hint}`;
+    }
+    if ("slug" in ref)
+        return `slug:${ref.slug}`;
+    if ("path" in ref)
+        return `path:${ref.path}`;
+    if ("perspective" in ref)
+        return `perspective:${ref.perspective}`;
+    return "unknown";
+}
+// ---------------------------------------------------------------------------
+// Type guards — assertions
+// ---------------------------------------------------------------------------
+/** Check if an assertion uses the templated format (template + criteria) */
+export function isTemplatedAssertion(entry) {
+    return (entry.type === "llm-rubric" &&
+        "template" in entry &&
+        typeof entry.template === "string" &&
+        "criteria" in entry &&
+        Array.isArray(entry.criteria));
+}

package/dist/_vendor/ailf-core/schemas/callback-payload.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @sanity/ailf-core — Callback Payload schema
+ *
+ * Defines the formal contract for the payload POSTed to callback URLs
+ * after an API-triggered pipeline evaluation completes. This schema is
+ * the single source of truth — the CallbackStep produces it, and
+ * external consumers (SDK, webhooks) validate against it.
+ *
+ * The payload is HMAC-SHA256 signed via the X-AILF-Signature header.
+ * See packages/eval/src/pipeline/callback-delivery.ts for signature
+ * computation.
+ *
+ * @see packages/eval/src/orchestration/steps/callback-step.ts
+ * @see docs/design-docs/api-service-gateway.md
+ */
+import { z } from "zod";
+export declare const CallbackPayloadSchema: z.ZodObject<{
+    deliveredAt: z.ZodString;
+    jobId: z.ZodOptional<z.ZodString>;
+    reportId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodUnknown;
+}, z.core.$strip>;
+/** Inferred TypeScript type for a callback payload. */
+export type CallbackPayload = z.infer<typeof CallbackPayloadSchema>;

package/dist/_vendor/ailf-core/schemas/callback-payload.js

@@ -0,0 +1,29 @@
+/**
+ * @sanity/ailf-core — Callback Payload schema
+ *
+ * Defines the formal contract for the payload POSTed to callback URLs
+ * after an API-triggered pipeline evaluation completes. This schema is
+ * the single source of truth — the CallbackStep produces it, and
+ * external consumers (SDK, webhooks) validate against it.
+ *
+ * The payload is HMAC-SHA256 signed via the X-AILF-Signature header.
+ * See packages/eval/src/pipeline/callback-delivery.ts for signature
+ * computation.
+ *
+ * @see packages/eval/src/orchestration/steps/callback-step.ts
+ * @see docs/design-docs/api-service-gateway.md
+ */
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Callback Payload — the delivery contract
+// ---------------------------------------------------------------------------
+export const CallbackPayloadSchema = z.object({
+    /** ISO timestamp of when the callback was delivered */
+    deliveredAt: z.string().datetime(),
+    /** Job ID for tracking (present for API-triggered evaluations) */
+    jobId: z.string().optional(),
+    /** Report ID in the Content Lake (present when publish is enabled) */
+    reportId: z.string().optional(),
+    /** The full score summary from the evaluation */
+    summary: z.unknown(),
+});

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

@@ -0,0 +1,55 @@
+/**
+ * EvalConfigSchema — Zod schema for JSON/YAML evaluation config files.
+ *
+ * This defines the shape of config files loaded via `--config <path>`.
+ * It's a user-facing subset of ResolvedConfig — fields that make sense
+ * to persist in a file. Runtime-computed fields (rootDir, promptfooUrl)
+ * are not included.
+ *
+ * The same schema will be used by the future ContentLakeConfigAdapter
+ * (studio-eval-config) so Content Lake documents validate identically.
+ */
+import { z } from "zod";
+export declare const EvalConfigSchema: z.ZodObject<{
+    allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    changedDocs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    compare: z.ZodOptional<z.ZodBoolean>;
+    compareBaseline: z.ZodOptional<z.ZodString>;
+    compareThreshold: z.ZodOptional<z.ZodNumber>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    debug: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        firstN: z.ZodOptional<z.ZodNumber>;
+        pattern: z.ZodOptional<z.ZodString>;
+        sample: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    discoveryReport: z.ZodOptional<z.ZodBoolean>;
+    gapAnalysis: z.ZodOptional<z.ZodBoolean>;
+    graderReplications: z.ZodOptional<z.ZodNumber>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        agentic: "agentic";
+        baseline: "baseline";
+        full: "full";
+        observed: "observed";
+    }>>;
+    noCache: z.ZodOptional<z.ZodBoolean>;
+    noRemoteCache: z.ZodOptional<z.ZodBoolean>;
+    publish: z.ZodOptional<z.ZodBoolean>;
+    publishTag: z.ZodOptional<z.ZodString>;
+    readiness: z.ZodOptional<z.ZodBoolean>;
+    reportDataset: z.ZodOptional<z.ZodString>;
+    reportProjectId: z.ZodOptional<z.ZodString>;
+    searchMode: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        open: "open";
+        "origin-only": "origin-only";
+    }>>;
+    skipEval: z.ZodOptional<z.ZodBoolean>;
+    skipFetch: z.ZodOptional<z.ZodBoolean>;
+    source: z.ZodOptional<z.ZodString>;
+    tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type EvalConfig = z.infer<typeof EvalConfigSchema>;

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

@@ -0,0 +1,78 @@
+/**
+ * EvalConfigSchema — Zod schema for JSON/YAML evaluation config files.
+ *
+ * This defines the shape of config files loaded via `--config <path>`.
+ * It's a user-facing subset of ResolvedConfig — fields that make sense
+ * to persist in a file. Runtime-computed fields (rootDir, promptfooUrl)
+ * are not included.
+ *
+ * The same schema will be used by the future ContentLakeConfigAdapter
+ * (studio-eval-config) so Content Lake documents validate identically.
+ */
+import { z } from "zod";
+export const EvalConfigSchema = z
+    .object({
+    /** Allowed origins for agentic mode */
+    allowedOrigins: z.array(z.string()).optional(),
+    /** Feature area filter (comma-separated or array) */
+    areas: z.array(z.string()).optional(),
+    /** Changed doc slugs for impact scoping */
+    changedDocs: z.array(z.string()).optional(),
+    /** Enable comparison against baseline */
+    compare: z.boolean().optional(),
+    /** Specific baseline file to compare against */
+    compareBaseline: z.string().optional(),
+    /** Comparison noise threshold */
+    compareThreshold: z.number().min(0).optional(),
+    /** Max parallel API calls */
+    concurrency: z.number().int().positive().optional(),
+    /** Debug mode */
+    debug: z
+        .union([
+        z.boolean(),
+        z.object({
+            enabled: z.boolean().optional(),
+            firstN: z.number().int().positive().optional(),
+            pattern: z.string().optional(),
+            sample: z.number().int().positive().optional(),
+        }),
+    ])
+        .optional(),
+    /** Enable discovery report */
+    discoveryReport: z.boolean().optional(),
+    /** Enable gap analysis */
+    gapAnalysis: z.boolean().optional(),
+    /** Grader consistency replications */
+    graderReplications: z.number().int().positive().optional(),
+    /** Custom headers for doc fetching */
+    headers: z.record(z.string(), z.string()).optional(),
+    /** Evaluation mode */
+    mode: z.enum(["baseline", "agentic", "observed", "full"]).optional(),
+    /** Disable local cache */
+    noCache: z.boolean().optional(),
+    /** Disable remote cache */
+    noRemoteCache: z.boolean().optional(),
+    /** Enable publishing */
+    publish: z.boolean().optional(),
+    /** Publish tag */
+    publishTag: z.string().optional(),
+    /** Enable readiness report */
+    readiness: z.boolean().optional(),
+    /** Report store dataset override */
+    reportDataset: z.string().optional(),
+    /** Report store project ID override */
+    reportProjectId: z.string().optional(),
+    /** Search mode for agentic mode */
+    searchMode: z.enum(["off", "open", "origin-only"]).optional(),
+    /** Skip eval step */
+    skipEval: z.boolean().optional(),
+    /** Skip fetch-docs step */
+    skipFetch: z.boolean().optional(),
+    /** Documentation source name */
+    source: z.string().optional(),
+    /** Task ID filter */
+    tasks: z.array(z.string()).optional(),
+    /** Doc source URL overrides */
+    urls: z.array(z.string().url()).optional(),
+})
+    .strict();

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

@@ -0,0 +1,16 @@
+/**
+ * @sanity/ailf-core — Zod validation schemas
+ *
+ * Runtime validation schemas for task definitions, rubrics, features,
+ * thresholds, sinks, and schedules. These are the parse layer that
+ * enforces domain invariants at system boundaries.
+ *
+ * Extracted from packages/eval during the Ports & Adapters migration
+ * (Phase 0d). Original files are now re-export barrels.
+ */
+export * from "./callback-payload.js";
+export * from "./eval-config.js";
+export * from "./pipeline-request.js";
+export * from "./pipeline.js";
+export * from "./schedules.js";
+export * from "./sinks.js";

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

@@ -0,0 +1,16 @@
+/**
+ * @sanity/ailf-core — Zod validation schemas
+ *
+ * Runtime validation schemas for task definitions, rubrics, features,
+ * thresholds, sinks, and schedules. These are the parse layer that
+ * enforces domain invariants at system boundaries.
+ *
+ * Extracted from packages/eval during the Ports & Adapters migration
+ * (Phase 0d). Original files are now re-export barrels.
+ */
+export * from "./callback-payload.js";
+export * from "./eval-config.js";
+export * from "./pipeline-request.js";
+export * from "./pipeline.js";
+export * from "./schedules.js";
+export * from "./sinks.js";

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

@@ -0,0 +1,125 @@
+/**
+ * @sanity/ailf-core — Pipeline Request schema
+ *
+ * The universal pipeline invocation contract. A single Zod schema shared
+ * between the API gateway (POST /v1/pipeline), the CLI (--config flag),
+ * and GitHub Actions workflows (repository_dispatch payload).
+ *
+ * This eliminates the ~100-line bash flag-building in the workflow YAML
+ * by flowing the entire payload through the system untouched. Each layer
+ * validates it against this schema but doesn't restructure it.
+ *
+ * @see docs/design-docs/api-service-gateway.md — Section 7.2
+ * @see packages/eval/src/pipeline/map-request-to-config.ts — maps to ResolvedConfig
+ */
+import { z } from "zod";
+export declare const PipelineRequestSchema: z.ZodObject<{
+    allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backend: z.ZodOptional<z.ZodEnum<{
+        "github-actions": "github-actions";
+        "cloud-run": "cloud-run";
+    }>>;
+    areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    callback: z.ZodOptional<z.ZodObject<{
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    changedDocs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    compare: z.ZodOptional<z.ZodBoolean>;
+    compareBaseline: z.ZodOptional<z.ZodString>;
+    compareThreshold: z.ZodOptional<z.ZodNumber>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    dataset: z.ZodOptional<z.ZodString>;
+    debug: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        firstN: z.ZodOptional<z.ZodNumber>;
+        pattern: z.ZodOptional<z.ZodString>;
+        sample: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    discoveryReport: z.ZodOptional<z.ZodBoolean>;
+    gapAnalysis: z.ZodOptional<z.ZodBoolean>;
+    graderReplications: z.ZodOptional<z.ZodNumber>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    inlineTasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        assert: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            criteria: z.ZodArray<z.ZodString>;
+            template: z.ZodString;
+            type: z.ZodLiteral<"llm-rubric">;
+            weight: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"contains">;
+            value: z.ZodString;
+            weight: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"contains-any">;
+            value: z.ZodArray<z.ZodString>;
+            weight: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"not-contains">;
+            value: z.ZodString;
+            weight: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"javascript">;
+            value: z.ZodString;
+            weight: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>]>>;
+        baseline: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            rubric: z.ZodOptional<z.ZodEnum<{
+                full: "full";
+                abbreviated: "abbreviated";
+                none: "none";
+            }>>;
+        }, z.core.$strip>>;
+        canonical_docs: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            slug: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            perspective: z.ZodString;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>]>>;
+        description: z.ZodString;
+        doc_coverage: z.ZodOptional<z.ZodBoolean>;
+        id: z.ZodString;
+        reference_solution: z.ZodString;
+        vars: z.ZodObject<{
+            docs: z.ZodString;
+            task: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$strip>>>;
+    jobId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        agentic: "agentic";
+        baseline: "baseline";
+        full: "full";
+        observed: "observed";
+    }>>;
+    noCache: z.ZodOptional<z.ZodBoolean>;
+    noRemoteCache: z.ZodOptional<z.ZodBoolean>;
+    perspective: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    publish: z.ZodOptional<z.ZodBoolean>;
+    publishTag: z.ZodOptional<z.ZodString>;
+    readiness: z.ZodOptional<z.ZodBoolean>;
+    searchMode: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        open: "open";
+        "origin-only": "origin-only";
+    }>>;
+    source: z.ZodOptional<z.ZodString>;
+    taskMode: z.ZodOptional<z.ZodEnum<{
+        "content-lake": "content-lake";
+        yaml: "yaml";
+        inline: "inline";
+    }>>;
+    tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** Inferred TypeScript type for a pipeline request payload. */
+export type PipelineRequest = z.infer<typeof PipelineRequestSchema>;

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

@@ -0,0 +1,67 @@
+/**
+ * @sanity/ailf-core — Pipeline Request schema
+ *
+ * The universal pipeline invocation contract. A single Zod schema shared
+ * between the API gateway (POST /v1/pipeline), the CLI (--config flag),
+ * and GitHub Actions workflows (repository_dispatch payload).
+ *
+ * This eliminates the ~100-line bash flag-building in the workflow YAML
+ * by flowing the entire payload through the system untouched. Each layer
+ * validates it against this schema but doesn't restructure it.
+ *
+ * @see docs/design-docs/api-service-gateway.md — Section 7.2
+ * @see packages/eval/src/pipeline/map-request-to-config.ts — maps to ResolvedConfig
+ */
+import { z } from "zod";
+import { SingleTaskSchema } from "./pipeline.js";
+// ---------------------------------------------------------------------------
+// Debug options — boolean shorthand or structured object
+// ---------------------------------------------------------------------------
+const DebugOptionsSchema = z.object({
+    enabled: z.boolean().optional(),
+    firstN: z.number().int().positive().optional(),
+    pattern: z.string().optional(),
+    sample: z.number().int().positive().optional(),
+});
+// ---------------------------------------------------------------------------
+// Callback delivery — for API-triggered evaluations
+// ---------------------------------------------------------------------------
+const CallbackSchema = z.object({
+    headers: z.record(z.string(), z.string()).optional(),
+    url: z.string().url(),
+});
+// ---------------------------------------------------------------------------
+// Pipeline Request — the universal invocation contract
+// ---------------------------------------------------------------------------
+export const PipelineRequestSchema = z.object({
+    allowedOrigins: z.array(z.string()).optional(),
+    backend: z.enum(["github-actions", "cloud-run"]).optional(),
+    areas: z.array(z.string()).optional(),
+    callback: CallbackSchema.optional(),
+    changedDocs: z.array(z.string()).optional(),
+    compare: z.boolean().optional(),
+    compareBaseline: z.string().optional(),
+    compareThreshold: z.number().min(0).optional(),
+    concurrency: z.number().int().positive().optional(),
+    dataset: z.string().optional(),
+    debug: z.union([z.boolean(), DebugOptionsSchema]).optional(),
+    discoveryReport: z.boolean().optional(),
+    gapAnalysis: z.boolean().optional(),
+    graderReplications: z.number().int().positive().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    inlineTasks: z.array(SingleTaskSchema).optional(),
+    jobId: z.string().optional(),
+    mode: z.enum(["baseline", "agentic", "observed", "full"]).optional(),
+    noCache: z.boolean().optional(),
+    noRemoteCache: z.boolean().optional(),
+    perspective: z.string().optional(),
+    projectId: z.string().optional(),
+    publish: z.boolean().optional(),
+    publishTag: z.string().optional(),
+    readiness: z.boolean().optional(),
+    searchMode: z.enum(["off", "open", "origin-only"]).optional(),
+    source: z.string().optional(),
+    taskMode: z.enum(["content-lake", "yaml", "inline"]).optional(),
+    tasks: z.array(z.string()).optional(),
+    urls: z.array(z.string().url()).optional(),
+});