@sanity/ailf 2.0.0 → 2.0.2

package/dist/_vendor/ailf-core/types/plugin-registry.d.ts

@@ -14,6 +14,25 @@ import type { PromptTemplate } from "../ports/mode-handler.js";
 import type { DocFetcher } from "../ports/doc-fetcher.js";
 import type { SourceEntry } from "../config-helpers.js";
 import type { FeatureRegistry } from "../schemas/pipeline.js";
+/**
+ * A named variant within an evaluation mode.
+ *
+ * Modes can declare variants to represent different evaluation strategies
+ * that share the same methodology. For example, the literacy mode has
+ * "baseline", "observed", and "agentic-*" variants.
+ *
+ * Models opt into specific variants via `ModelEntry.variants`. When a model
+ * enrolls in a mode without specifying variants, all defined variants are
+ * included by default.
+ */
+export interface ModeVariantDefinition {
+    /** Variant identifier (e.g., "baseline", "agentic-naive") */
+    id: string;
+    /** Human-readable label (e.g., "Standard (baseline)") */
+    label: string;
+    /** Optional description for docs/CLI help */
+    description?: string;
+}
 /** A registered evaluation mode handler */
 export interface ModeRegistration {
     /** Unique mode identifier (e.g., "api-contract") */
@@ -26,6 +45,14 @@ export interface ModeRegistration {
     rubricTemplateIds: string[];
     /** Compile function module path (loaded at runtime) */
     handlerModule: string;
+    /**
+     * Variants this mode supports. Omit or empty for modes without variants.
+     *
+     * When defined, models can selectively opt into specific variants via
+     * `ModelEntry.variants`. Models that enroll in the mode without specifying
+     * variants participate in all defined variants.
+     */
+    variants?: ModeVariantDefinition[];
 }
 /** A registered assertion type */
 export interface AssertionRegistration {

package/dist/_vendor/ailf-shared/eval-modes.d.ts

@@ -37,6 +37,21 @@ export type RawEvalMode = EvalMode | "agentic" | "baseline" | "full" | "observed
 export declare const CANONICAL_EVAL_MODES: readonly ["literacy", "mcp-server", "agent-harness", "knowledge-probe", "custom"];
 /** Legacy CLI aliases that map to `mode: "literacy"` + variant. */
 export declare const LEGACY_EVAL_MODE_ALIASES: readonly ["baseline", "agentic", "observed", "full"];
+/**
+ * Literacy mode variant names — each is a distinct evaluation strategy.
+ *
+ * These are the valid values for the `variant` field in PipelineRequest
+ * when `mode` is `"literacy"`. They match LEGACY_EVAL_MODE_ALIASES because
+ * variants were originally exposed as top-level mode names.
+ *
+ *   - `baseline` — with-docs / without-docs comparison (gold + floor)
+ *   - `agentic`  — model uses tools to find docs (gold only)
+ *   - `observed` — HTTP-instrumented behavior observation
+ *   - `full`     — combined baseline + agentic
+ */
+export declare const LITERACY_VARIANTS: readonly ["baseline", "agentic", "observed", "full"];
+/** Union of all literacy variant string values. */
+export type LiteracyVariant = (typeof LITERACY_VARIANTS)[number];
 /**
  * All accepted mode names for Zod enum construction.
  * Canonical modes first, then legacy aliases.

package/dist/_vendor/ailf-shared/eval-modes.js

@@ -22,6 +22,24 @@ export const LEGACY_EVAL_MODE_ALIASES = [
     "observed",
     "full",
 ];
+/**
+ * Literacy mode variant names — each is a distinct evaluation strategy.
+ *
+ * These are the valid values for the `variant` field in PipelineRequest
+ * when `mode` is `"literacy"`. They match LEGACY_EVAL_MODE_ALIASES because
+ * variants were originally exposed as top-level mode names.
+ *
+ *   - `baseline` — with-docs / without-docs comparison (gold + floor)
+ *   - `agentic`  — model uses tools to find docs (gold only)
+ *   - `observed` — HTTP-instrumented behavior observation
+ *   - `full`     — combined baseline + agentic
+ */
+export const LITERACY_VARIANTS = [
+    "baseline",
+    "agentic",
+    "observed",
+    "full",
+];
 /**
  * All accepted mode names for Zod enum construction.
  * Canonical modes first, then legacy aliases.

package/dist/_vendor/ailf-tasks/cli.d.ts

@@ -0,0 +1,8 @@
+/**
+ * cli.ts — Minimal CLI for standalone task validation.
+ *
+ * Usage:
+ *   npx @sanity/ailf-tasks validate .ailf/tasks/
+ *   npx @sanity/ailf-tasks validate             # defaults to .ailf/tasks/
+ */
+export declare function run(): void;

package/dist/_vendor/ailf-tasks/cli.js

@@ -0,0 +1,61 @@
+/**
+ * cli.ts — Minimal CLI for standalone task validation.
+ *
+ * Usage:
+ *   npx @sanity/ailf-tasks validate .ailf/tasks/
+ *   npx @sanity/ailf-tasks validate             # defaults to .ailf/tasks/
+ */
+import { loadTaskDir } from "./parser.js";
+import { formatValidationResult, validateRepoTasks } from "./validation.js";
+export function run() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (command === "validate") {
+        const dir = args[1] ?? ".ailf/tasks";
+        validateCommand(dir);
+    }
+    else if (command === "--help" ||
+        command === "-h" ||
+        command === undefined) {
+        printUsage();
+    }
+    else {
+        console.error(`Unknown command: ${command}`);
+        printUsage();
+        process.exit(1);
+    }
+}
+function validateCommand(dir) {
+    try {
+        const tasks = loadTaskDir(dir);
+        // Run semantic validation
+        const result = validateRepoTasks(tasks);
+        const formatted = formatValidationResult(result);
+        console.log(`✅ ${tasks.length} task(s) validated from ${dir}`);
+        for (const task of tasks) {
+            console.log(`   ${task.id} — ${task.description}`);
+        }
+        if (result.warnings.length > 0 || result.errors.length > 0) {
+            console.log("");
+            console.log(formatted);
+        }
+        if (!result.valid) {
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(`❌ ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+function printUsage() {
+    console.log("Usage: ailf-tasks <command> [options]");
+    console.log("");
+    console.log("Commands:");
+    console.log("  validate [dir]  Validate task YAML files (default: .ailf/tasks/)");
+    console.log("");
+    console.log("Examples:");
+    console.log("  ailf-tasks validate");
+    console.log("  ailf-tasks validate .ailf/tasks/");
+    console.log("  ailf-tasks validate /path/to/tasks/");
+}

package/dist/_vendor/ailf-tasks/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @sanity/ailf-tasks — Task definition schemas and YAML parser.
+ *
+ * Lightweight package for parsing and validating .ailf/tasks/*.yaml files
+ * without depending on the full AILF CLI or its heavyweight dependencies
+ * (Promptfoo, LLM SDKs, Sanity client).
+ *
+ * Usage:
+ *   import { parseTaskFile, loadTaskDir, RepoTaskSchema } from '@sanity/ailf-tasks'
+ */
+export { CURATED_ASSERTION_TYPES, RepoTaskFileSchema, RepoTaskSchema, RUBRIC_TEMPLATE_NAMES, type CuratedAssertionType, type RepoTask, type RubricTemplateName, } from "./schemas.js";
+export { loadTaskDir, parseTaskFile } from "./parser.js";
+export { detectSnakeCaseFields, formatValidationResult, validateRepoTasks, type ValidationMessage, type ValidationResult, } from "./validation.js";

package/dist/_vendor/ailf-tasks/index.js

@@ -0,0 +1,16 @@
+/**
+ * @sanity/ailf-tasks — Task definition schemas and YAML parser.
+ *
+ * Lightweight package for parsing and validating .ailf/tasks/*.yaml files
+ * without depending on the full AILF CLI or its heavyweight dependencies
+ * (Promptfoo, LLM SDKs, Sanity client).
+ *
+ * Usage:
+ *   import { parseTaskFile, loadTaskDir, RepoTaskSchema } from '@sanity/ailf-tasks'
+ */
+// Schemas and types
+export { CURATED_ASSERTION_TYPES, RepoTaskFileSchema, RepoTaskSchema, RUBRIC_TEMPLATE_NAMES, } from "./schemas.js";
+// Parsing
+export { loadTaskDir, parseTaskFile } from "./parser.js";
+// Validation
+export { detectSnakeCaseFields, formatValidationResult, validateRepoTasks, } from "./validation.js";

package/dist/_vendor/ailf-tasks/parser.d.ts

@@ -0,0 +1,27 @@
+/**
+ * parser.ts — Standalone task file and directory parsing.
+ *
+ * High-level functions for loading and validating .ailf/tasks/ YAML
+ * files without any dependency on the eval pipeline.
+ *
+ * Usage:
+ *   import { parseTaskFile, loadTaskDir } from '@sanity/ailf-tasks'
+ */
+import { type RepoTask } from "./schemas.js";
+/**
+ * Parse a single task YAML string and return validated tasks.
+ *
+ * @param content - Raw YAML string content
+ * @param filename - Source filename (for error messages)
+ * @returns Validated array of RepoTask objects
+ * @throws Error if YAML parsing or Zod validation fails
+ */
+export declare function parseTaskFile(content: string, filename?: string): RepoTask[];
+/**
+ * Load and parse all task YAML files from a directory.
+ *
+ * @param dirPath - Path to directory containing .yaml/.yml files
+ * @returns All validated tasks, sorted by filename
+ * @throws Error if directory not found, no YAML files, or validation fails
+ */
+export declare function loadTaskDir(dirPath: string): RepoTask[];

package/dist/_vendor/ailf-tasks/parser.js

@@ -0,0 +1,73 @@
+/**
+ * parser.ts — Standalone task file and directory parsing.
+ *
+ * High-level functions for loading and validating .ailf/tasks/ YAML
+ * files without any dependency on the eval pipeline.
+ *
+ * Usage:
+ *   import { parseTaskFile, loadTaskDir } from '@sanity/ailf-tasks'
+ */
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { load } from "js-yaml";
+import { RepoTaskFileSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Parse a single task YAML string and return validated tasks.
+ *
+ * @param content - Raw YAML string content
+ * @param filename - Source filename (for error messages)
+ * @returns Validated array of RepoTask objects
+ * @throws Error if YAML parsing or Zod validation fails
+ */
+export function parseTaskFile(content, filename = "<string>") {
+    const parsed = load(content);
+    if (!Array.isArray(parsed)) {
+        throw new Error(`${filename} did not parse to an array of tasks. ` +
+            "Task files must contain a YAML array of task definitions.");
+    }
+    const result = RepoTaskFileSchema.safeParse(parsed);
+    if (!result.success) {
+        const messages = result.error.issues
+            .map((i) => `  [${i.path.join(".")}]: ${i.message}`)
+            .join("\n");
+        throw new Error(`Invalid task file "${filename}":\n${messages}`);
+    }
+    return result.data;
+}
+/**
+ * Load and parse all task YAML files from a directory.
+ *
+ * @param dirPath - Path to directory containing .yaml/.yml files
+ * @returns All validated tasks, sorted by filename
+ * @throws Error if directory not found, no YAML files, or validation fails
+ */
+export function loadTaskDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        throw new Error(`Tasks directory not found: ${dirPath}\n` +
+            "  Expected a directory containing .ailf/tasks/*.yaml files.");
+    }
+    const yamlFiles = readdirSync(dirPath)
+        .filter((f) => (f.endsWith(".yaml") || f.endsWith(".yml")) && !f.startsWith("."))
+        .sort();
+    if (yamlFiles.length === 0) {
+        throw new Error(`No YAML files found in ${dirPath}\n` +
+            "  Expected .ailf/tasks/*.yaml files with task definitions.");
+    }
+    const allTasks = [];
+    for (const file of yamlFiles) {
+        const filePath = resolve(dirPath, file);
+        const content = readFileSync(filePath, "utf-8");
+        try {
+            const tasks = parseTaskFile(content, file);
+            allTasks.push(...tasks);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to load ${file}:\n${msg}`, { cause: err });
+        }
+    }
+    return allTasks;
+}

package/dist/_vendor/ailf-tasks/schemas.d.ts

@@ -0,0 +1,198 @@
+/**
+ * schemas.ts — Zod schemas for repo-based task definitions.
+ *
+ * Validates .ailf/tasks/*.yaml task files from external repositories.
+ * These schemas are the contract between external repos and the AILF eval
+ * pipeline — they define exactly what fields are accepted, with friendly
+ * error messages for authors writing task YAML by hand.
+ *
+ * This module is the single source of truth for task schemas. The eval
+ * package re-exports from here to avoid duplication.
+ *
+ * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
+ */
+import { z } from "zod";
+/**
+ * The set of assertion types allowed in repo-based task files.
+ *
+ * This is a curated subset of Promptfoo assertion types — we expose only the
+ * types that are stable, well-documented, and useful for external authors.
+ */
+export declare const CURATED_ASSERTION_TYPES: readonly ["llm-rubric", "contains", "contains-any", "contains-all", "not-contains", "icontains", "icontains-any", "regex", "javascript", "similar", "cost", "latency"];
+export type CuratedAssertionType = (typeof CURATED_ASSERTION_TYPES)[number];
+/**
+ * Valid rubric template names — must match keys in config/rubrics.yaml.
+ */
+export declare const RUBRIC_TEMPLATE_NAMES: readonly ["task-completion", "code-correctness", "doc-coverage"];
+export type RubricTemplateName = (typeof RUBRIC_TEMPLATE_NAMES)[number];
+/**
+ * Zod schema for a single repo-based task definition.
+ *
+ * This is the external-author-facing contract. Field names are camelCase
+ * to match the Content Lake document schema (ailf.task).
+ */
+export declare const RepoTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        paused: "paused";
+        archived: "archived";
+    }>>>;
+    featureArea: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    canonicalDocs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        slug: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        slug: z.ZodString;
+        reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: 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>]>>>>;
+    vars: z.ZodOptional<z.ZodObject<{
+        task: z.ZodString;
+    }, z.core.$loose>>;
+    assert: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"llm-rubric">;
+        template: z.ZodEnum<{
+            "task-completion": "task-completion";
+            "code-correctness": "code-correctness";
+            "doc-coverage": "doc-coverage";
+        }>;
+        criteria: z.ZodArray<z.ZodString>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            "llm-rubric": "llm-rubric";
+            contains: "contains";
+            "contains-any": "contains-any";
+            "contains-all": "contains-all";
+            "not-contains": "not-contains";
+            icontains: "icontains";
+            "icontains-any": "icontains-any";
+            regex: "regex";
+            javascript: "javascript";
+            similar: "similar";
+            cost: "cost";
+            latency: "latency";
+        }>;
+        value: z.ZodOptional<z.ZodUnknown>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>]>>;
+    baseline: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        rubric: z.ZodOptional<z.ZodEnum<{
+            abbreviated: "abbreviated";
+            full: "full";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+    docCoverage: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    referenceSolution: z.ZodOptional<z.ZodString>;
+    execution: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        blocking: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        threshold: z.ZodOptional<z.ZodObject<{
+            score: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        trigger: z.ZodOptional<z.ZodObject<{
+            branches: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RepoTask = z.infer<typeof RepoTaskSchema>;
+/**
+ * Schema for an array of repo tasks — what a single .ailf/tasks/*.yaml file
+ * contains. Each file must define at least one task.
+ */
+export declare const RepoTaskFileSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        paused: "paused";
+        archived: "archived";
+    }>>>;
+    featureArea: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    canonicalDocs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        slug: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        slug: z.ZodString;
+        reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: 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>]>>>>;
+    vars: z.ZodOptional<z.ZodObject<{
+        task: z.ZodString;
+    }, z.core.$loose>>;
+    assert: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"llm-rubric">;
+        template: z.ZodEnum<{
+            "task-completion": "task-completion";
+            "code-correctness": "code-correctness";
+            "doc-coverage": "doc-coverage";
+        }>;
+        criteria: z.ZodArray<z.ZodString>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            "llm-rubric": "llm-rubric";
+            contains: "contains";
+            "contains-any": "contains-any";
+            "contains-all": "contains-all";
+            "not-contains": "not-contains";
+            icontains: "icontains";
+            "icontains-any": "icontains-any";
+            regex: "regex";
+            javascript: "javascript";
+            similar: "similar";
+            cost: "cost";
+            latency: "latency";
+        }>;
+        value: z.ZodOptional<z.ZodUnknown>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>]>>;
+    baseline: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        rubric: z.ZodOptional<z.ZodEnum<{
+            abbreviated: "abbreviated";
+            full: "full";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+    docCoverage: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    referenceSolution: z.ZodOptional<z.ZodString>;
+    execution: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        blocking: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        threshold: z.ZodOptional<z.ZodObject<{
+            score: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        trigger: z.ZodOptional<z.ZodObject<{
+            branches: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;

package/dist/_vendor/ailf-tasks/schemas.js

@@ -0,0 +1,180 @@
+/**
+ * schemas.ts — Zod schemas for repo-based task definitions.
+ *
+ * Validates .ailf/tasks/*.yaml task files from external repositories.
+ * These schemas are the contract between external repos and the AILF eval
+ * pipeline — they define exactly what fields are accepted, with friendly
+ * error messages for authors writing task YAML by hand.
+ *
+ * This module is the single source of truth for task schemas. The eval
+ * package re-exports from here to avoid duplication.
+ *
+ * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
+ */
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Constants — curated assertion types and rubric template names
+// ---------------------------------------------------------------------------
+/**
+ * The set of assertion types allowed in repo-based task files.
+ *
+ * This is a curated subset of Promptfoo assertion types — we expose only the
+ * types that are stable, well-documented, and useful for external authors.
+ */
+export const CURATED_ASSERTION_TYPES = [
+    "llm-rubric",
+    "contains",
+    "contains-any",
+    "contains-all",
+    "not-contains",
+    "icontains",
+    "icontains-any",
+    "regex",
+    "javascript",
+    "similar",
+    "cost",
+    "latency",
+];
+/**
+ * Valid rubric template names — must match keys in config/rubrics.yaml.
+ */
+export const RUBRIC_TEMPLATE_NAMES = [
+    "task-completion",
+    "code-correctness",
+    "doc-coverage",
+];
+// ---------------------------------------------------------------------------
+// Assertion schemas
+// ---------------------------------------------------------------------------
+/**
+ * Polymorphic canonical doc reference — discriminated by key presence.
+ * Exactly one resolution key (slug, path, id, or perspective) must be present.
+ *
+ * @see docs/design-docs/canonical-doc-resolution.md
+ */
+const SlugDocRefSchema = z.object({
+    slug: z.string().min(1),
+    reason: z.string().optional().default(""),
+});
+const PathDocRefSchema = z.object({
+    path: z.string().min(1),
+    reason: z.string().optional().default(""),
+});
+const IdDocRefSchema = z.object({
+    id: z.string().min(1),
+    reason: z.string().optional().default(""),
+    /** Human-readable slug annotation (not used for resolution) */
+    slug: z.string().optional(),
+    /** Human-readable path annotation (not used for resolution) */
+    path: z.string().optional(),
+});
+const PerspectiveDocRefSchema = z.object({
+    perspective: z.string().min(1),
+    reason: z.string().optional().default(""),
+});
+// Order matters: IdDocRefSchema first because it may also carry `slug`
+// and `path` as optional annotations. Zod tries schemas in order, so
+// entries like `{ id: "...", slug: "..." }` must match IdDocRefSchema
+// (not SlugDocRefSchema).
+const CanonicalDocRefSchema = z.union([
+    IdDocRefSchema,
+    SlugDocRefSchema,
+    PathDocRefSchema,
+    PerspectiveDocRefSchema,
+]);
+/**
+ * A templated LLM-rubric assertion — uses one of the predefined rubric
+ * templates with author-supplied criteria.
+ */
+const TemplatedAssertionSchema = z.object({
+    type: z.literal("llm-rubric"),
+    template: z.enum(RUBRIC_TEMPLATE_NAMES),
+    criteria: z.array(z.string().min(1)).min(1),
+    weight: z.number().optional(),
+});
+/**
+ * A value-based assertion (contains, regex, cost, etc.). Uses .passthrough()
+ * to allow extra fields for future extension without schema breakage.
+ */
+const ValueAssertionSchema = z
+    .object({
+    type: z.enum(CURATED_ASSERTION_TYPES),
+    value: z.unknown().optional(),
+    threshold: z.number().optional(),
+    weight: z.number().optional(),
+})
+    .passthrough();
+/** Union of all supported assertion shapes. */
+const AssertionSchema = z.union([
+    TemplatedAssertionSchema,
+    ValueAssertionSchema,
+]);
+// ---------------------------------------------------------------------------
+// Nested config schemas
+// ---------------------------------------------------------------------------
+const BaselineConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    rubric: z.enum(["abbreviated", "full", "none"]).optional(),
+})
+    .optional();
+const ExecutionConfigSchema = z
+    .object({
+    enabled: z.boolean().optional().default(true),
+    blocking: z.boolean().optional().default(false),
+    threshold: z
+        .object({
+        score: z.number().min(0).max(100).optional(),
+    })
+        .optional(),
+    trigger: z
+        .object({
+        branches: z.array(z.string()).optional(),
+        paths: z.array(z.string()).optional(),
+    })
+        .optional(),
+    source: z.string().optional(),
+})
+    .optional();
+// ---------------------------------------------------------------------------
+// RepoTaskSchema — a single task definition from .ailf/tasks/*.yaml
+// ---------------------------------------------------------------------------
+/**
+ * Zod schema for a single repo-based task definition.
+ *
+ * This is the external-author-facing contract. Field names are camelCase
+ * to match the Content Lake document schema (ailf.task).
+ */
+export const RepoTaskSchema = z.object({
+    id: z
+        .string()
+        .min(1)
+        .regex(/^[a-z0-9][a-z0-9-]*$/, "Task ID must be lowercase alphanumeric with hyphens"),
+    description: z.string().min(1),
+    status: z
+        .enum(["active", "draft", "paused", "archived"])
+        .optional()
+        .default("active"),
+    featureArea: z
+        .string()
+        .min(1)
+        .regex(/^[a-z0-9][a-z0-9-]*$/, "Feature area must be lowercase alphanumeric with hyphens"),
+    tags: z.array(z.string()).optional(),
+    canonicalDocs: z.array(CanonicalDocRefSchema).optional().default([]),
+    vars: z
+        .object({
+        task: z.string().min(1),
+    })
+        .passthrough()
+        .optional(),
+    assert: z.array(AssertionSchema).min(1),
+    baseline: BaselineConfigSchema,
+    docCoverage: z.boolean().optional().default(false),
+    referenceSolution: z.string().optional(),
+    execution: ExecutionConfigSchema,
+});
+/**
+ * Schema for an array of repo tasks — what a single .ailf/tasks/*.yaml file
+ * contains. Each file must define at least one task.
+ */
+export const RepoTaskFileSchema = z.array(RepoTaskSchema).min(1);