@sanity/ailf 1.0.0 → 2.0.1

package/dist/adapters/task-sources/repo-schemas.js

@@ -1,42 +1,250 @@
 /**
- * repo-schemas.ts — Re-exports task schemas + defines config schemas.
+ * repo-schemas.ts — Canonical Zod schemas for task and config validation.
  *
- * Task schemas (RepoTaskSchema, assertions, etc.) are the single source
- * of truth in @sanity/ailf-tasks. This file re-exports them so existing
- * importers within the eval package don't need to change their paths.
+ * Task schemas validate .ailf/tasks/*.yaml and .task.ts files against the
+ * canonical GeneralizedTaskDefinition shape. Field names match the internal
+ * domain model: `area` (not featureArea), `assertions` (not assert),
+ * `context.docs` (not canonicalDocs), `prompt.text` (not vars.task).
  *
- * Config schemas (RepoConfigSchema, trigger config, etc.) remain here
- * because they are specific to the eval pipeline and not needed by
- * external tools that only validate task YAML.
+ * Previously this file re-exported from @sanity/ailf-tasks. That package
+ * has been eliminated — all schema logic now lives here.
  *
- * @see packages/tasks/src/schemas.ts — task schema source of truth
- * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
+ * Config schemas (RepoConfigSchema, trigger config) are eval-pipeline-
+ * specific and remain here unchanged.
+ *
+ * @see packages/core/src/types/generalized-task.ts — canonical TypeScript types
+ * @see docs/archive/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
  */
-import { RepoTaskFileSchema as _Schema } from "../../_vendor/ailf-tasks/index.js";
 import { z } from "zod";
 // ---------------------------------------------------------------------------
-// Re-exports from @sanity/ailf-tasks (task schemas + validation)
+// Constants — curated assertion types and rubric template names
 // ---------------------------------------------------------------------------
-export { CURATED_ASSERTION_TYPES, RepoTaskFileSchema, RepoTaskSchema, RUBRIC_TEMPLATE_NAMES, } from "../../_vendor/ailf-tasks/index.js";
-export { loadTaskDir, parseTaskFile } from "../../_vendor/ailf-tasks/index.js";
 /**
- * Parse and validate a repo task file's content. Returns typed tasks or throws
- * with a user-friendly Zod error message.
+ * The set of assertion types allowed in task files.
  *
- * NOTE: This accepts pre-parsed YAML data (unknown), not a raw string.
- * For raw YAML strings, use `parseTaskFile()` from @sanity/ailf-tasks.
+ * 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",
+];
+// ---------------------------------------------------------------------------
+// Doc ref schemas — polymorphic canonical doc references
+// ---------------------------------------------------------------------------
+/**
+ * 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,
+]);
+// ---------------------------------------------------------------------------
+// Assertion schemas
+// ---------------------------------------------------------------------------
+/**
+ * A templated LLM-rubric assertion — uses one of the predefined rubric
+ * templates with author-supplied criteria.
  */
-export function parseRepoTaskFile(raw, filename) {
-    const result = _Schema.safeParse(raw);
+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();
+// ---------------------------------------------------------------------------
+// CanonicalTaskSchema — the single canonical task shape
+//
+// Validates the GeneralizedTaskDefinition shape. Field names match the
+// internal domain model directly — no mapping layer needed.
+//
+// YAML tasks may omit `mode` (defaults to "literacy"). All other fields
+// use the canonical names: `title`, `area`, `prompt.text`, `context.docs`,
+// `assertions`.
+// ---------------------------------------------------------------------------
+/**
+ * Zod schema for a single task definition using canonical field names.
+ *
+ * Uses .passthrough() to allow mode-specific fields (serverConfig, sandbox,
+ * handler, etc.) without listing every possible field. Mode-specific
+ * validation is deferred to the pipeline's mode handlers.
+ */
+export const CanonicalTaskSchema = z
+    .object({
+    id: z
+        .string()
+        .min(1)
+        .regex(/^[a-z0-9][a-z0-9-]*$/, "Task ID must be lowercase alphanumeric with hyphens"),
+    mode: z.string().default("literacy"),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    area: z.string().optional(),
+    difficulty: z.enum(["basic", "intermediate", "advanced"]).optional(),
+    status: z
+        .enum(["active", "draft", "paused", "archived"])
+        .optional()
+        .default("active"),
+    tags: z.array(z.string()).optional(),
+    prompt: z
+        .object({
+        template: z.string().optional(),
+        text: z.string().optional(),
+        systemMessage: z.string().optional(),
+        vars: z.record(z.string(), z.unknown()).optional(),
+    })
+        .optional(),
+    context: z
+        .object({
+        docs: z.array(CanonicalDocRefSchema).optional(),
+        fixtures: z.array(z.string()).optional(),
+    })
+        .optional(),
+    assertions: z.array(AssertionSchema).optional(),
+    referenceSolution: z.string().optional(),
+    docCoverage: z.boolean().optional().default(false),
+    baseline: BaselineConfigSchema,
+    rubric: z.unknown().optional(),
+    providers: z.array(z.unknown()).optional(),
+    options: z.unknown().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+/**
+ * Schema for an array of canonical tasks — what a single .ailf/tasks/*.yaml
+ * file contains. Each file must define at least one task.
+ */
+export const CanonicalTaskFileSchema = z.array(CanonicalTaskSchema).min(1);
+/**
+ * Parse and validate a task file's content against the canonical schema.
+ * Returns typed tasks or throws with a user-friendly Zod error message.
+ *
+ * Accepts pre-parsed YAML data (unknown), not a raw string.
+ */
+export function parseCanonicalTaskFile(raw, filename) {
+    const result = CanonicalTaskFileSchema.safeParse(raw);
     if (!result.success) {
         const messages = result.error.issues
             .map((i) => `  [${i.path.join(".")}]: ${i.message}`)
             .join("\n");
-        throw new Error(`Invalid repo task file "${filename}":\n${messages}`);
+        throw new Error(`Invalid task file "${filename}":\n${messages}`);
     }
     return result.data;
 }
 // ---------------------------------------------------------------------------
+// Legacy field name detection
+//
+// When authors accidentally use the old @sanity/ailf-tasks field names
+// (featureArea, canonicalDocs, assert, vars), surface a helpful error
+// message telling them what the canonical names are.
+// ---------------------------------------------------------------------------
+/** Old field names from @sanity/ailf-tasks → canonical equivalents */
+const LEGACY_FIELD_MAP = {
+    featureArea: "area",
+    canonicalDocs: "context.docs (nested under context: { docs: [...] })",
+    assert: "assertions",
+    vars: "prompt (nested under prompt: { text: ... })",
+};
+/**
+ * Detect legacy field names in raw task data and return helpful messages.
+ *
+ * Runs BEFORE Zod parsing to catch the most common migration mistake —
+ * using old field names from @sanity/ailf-tasks instead of the canonical
+ * GeneralizedTaskDefinition shape.
+ */
+export function detectLegacyFieldNames(raw, filename) {
+    const warnings = [];
+    if (!Array.isArray(raw))
+        return warnings;
+    for (let i = 0; i < raw.length; i++) {
+        const entry = raw[i];
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const obj = entry;
+        const taskId = typeof obj.id === "string" ? obj.id : `task[${i}]`;
+        for (const [legacy, canonical] of Object.entries(LEGACY_FIELD_MAP)) {
+            if (legacy in obj) {
+                warnings.push(`[${filename}] ${taskId}: Found legacy field "${legacy}" — ` +
+                    `use "${canonical}" instead. ` +
+                    "See contributing-tasks.md for the canonical task format.");
+            }
+        }
+    }
+    return warnings;
+}
+// ---------------------------------------------------------------------------
 // Config schemas — specific to the eval pipeline
 // ---------------------------------------------------------------------------
 const TriggerModeSchema = z.enum(["validate-only", "eval"]);

package/dist/adapters/task-sources/repo-task-source.d.ts

@@ -1,18 +1,22 @@
 /**
- * Adapter: Load task definitions from .ailf/tasks/*.yaml in an external repo.
+ * Adapter: Load task definitions from .ailf/tasks/ in an external repo.
  *
- * Repo-based tasks use a camelCase YAML format (matching the Content Lake
- * document schema) with slug strings instead of Sanity references. The
- * mapping to LiteracyTaskDefinition is straightforward — field names are
- * already aligned with the domain type.
+ * Supports two task file formats:
  *
- * This adapter is structurally similar to YamlTaskSource but:
- * - Reads from an arbitrary directory (not the framework's tasks/ dir)
- * - Uses camelCase field names (not snake_case)
- * - Has an explicit featureArea field per task (not derived from filename)
+ * 1. **TypeScript (.task.ts)** — Tasks authored with `defineTask()` from
+ *    `@sanity/ailf`. These use `GeneralizedTaskDefinition` field names
+ *    and are passed through with basic runtime guards.
  *
+ * 2. **YAML (.yaml)** — Tasks using the canonical `GeneralizedTaskDefinition`
+ *    field names (area, context.docs, assertions, prompt.text). Validated
+ *    through the CanonicalTaskSchema Zod schema.
+ *
+ * All tasks use the single canonical shape — no mapping layer, no dual-shape
+ * detection. The `mode` field defaults to "literacy" for YAML tasks that
+ * omit it.
+ *
+ * @see packages/core/src/types/generalized-task.ts — canonical types
  * @see packages/core/src/ports/task-source.ts — TaskSource port
- * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
  */
 import type { FilterOptions, GeneralizedTaskDefinition, TaskSource } from "../../_vendor/ailf-core/index.d.ts";
 export declare class RepoTaskSource implements TaskSource {

package/dist/adapters/task-sources/repo-task-source.js

@@ -1,24 +1,31 @@
 /**
- * Adapter: Load task definitions from .ailf/tasks/*.yaml in an external repo.
+ * Adapter: Load task definitions from .ailf/tasks/ in an external repo.
  *
- * Repo-based tasks use a camelCase YAML format (matching the Content Lake
- * document schema) with slug strings instead of Sanity references. The
- * mapping to LiteracyTaskDefinition is straightforward — field names are
- * already aligned with the domain type.
+ * Supports two task file formats:
  *
- * This adapter is structurally similar to YamlTaskSource but:
- * - Reads from an arbitrary directory (not the framework's tasks/ dir)
- * - Uses camelCase field names (not snake_case)
- * - Has an explicit featureArea field per task (not derived from filename)
+ * 1. **TypeScript (.task.ts)** — Tasks authored with `defineTask()` from
+ *    `@sanity/ailf`. These use `GeneralizedTaskDefinition` field names
+ *    and are passed through with basic runtime guards.
  *
+ * 2. **YAML (.yaml)** — Tasks using the canonical `GeneralizedTaskDefinition`
+ *    field names (area, context.docs, assertions, prompt.text). Validated
+ *    through the CanonicalTaskSchema Zod schema.
+ *
+ * All tasks use the single canonical shape — no mapping layer, no dual-shape
+ * detection. The `mode` field defaults to "literacy" for YAML tasks that
+ * omit it.
+ *
+ * @see packages/core/src/types/generalized-task.ts — canonical types
  * @see packages/core/src/ports/task-source.ts — TaskSource port
- * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
  */
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { resolve } from "path";
 import { load } from "js-yaml";
-import { parseRepoTaskFile } from "./repo-schemas.js";
+import { CANONICAL_EVAL_MODES } from "../../_vendor/ailf-shared/index.js";
+import { detectLegacyFieldNames, parseCanonicalTaskFile, } from "./repo-schemas.js";
 import { discoverTsTaskFiles, loadTsTaskFile } from "./task-file-loader.js";
+/** Set of canonical mode names for O(1) lookup */
+const KNOWN_MODES = new Set(CANONICAL_EVAL_MODES);
 // ---------------------------------------------------------------------------
 // RepoTaskSource adapter
 // ---------------------------------------------------------------------------
@@ -41,6 +48,7 @@ export class RepoTaskSource {
                 "  Expected .ailf/tasks/*.yaml or .ailf/tasks/*.task.ts files");
         }
         const definitions = [];
+        // Load YAML task files
         for (const file of yamlFiles) {
             const filePath = resolve(this.tasksDir, file);
             const raw = readFileSync(filePath, "utf-8");
@@ -49,139 +57,90 @@ export class RepoTaskSource {
                 throw new Error(`${file} did not parse to an array of tasks. ` +
                     "Repo task files must contain a YAML array of task definitions.");
             }
-            // Validate entire file through Zod schema
+            // Detect legacy field names (featureArea, canonicalDocs, assert, vars)
+            // and surface helpful migration messages before Zod validation fails.
+            const legacyWarnings = detectLegacyFieldNames(parsed, file);
+            if (legacyWarnings.length > 0) {
+                throw new Error(`${file} uses legacy field names from @sanity/ailf-tasks.\n` +
+                    "Task files must use canonical GeneralizedTaskDefinition field names.\n\n" +
+                    legacyWarnings.join("\n") +
+                    "\n\nSee contributing-tasks.md for the canonical task format.");
+            }
+            // Validate through canonical Zod schema
             let validated;
             try {
-                validated = parseRepoTaskFile(parsed, file);
+                validated = parseCanonicalTaskFile(parsed, file);
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
                 throw new Error(`Failed to validate ${file}:\n${msg}`, { cause: err });
             }
-            for (const entry of validated) {
-                // Filter stages:
-                // 1. Area filter — skip tasks outside requested feature areas
-                // 2. Task ID filter — skip tasks not matching explicit task IDs
-                // 3. Status filter — skip non-active tasks (unless targeting by ID)
-                // 4. Tag filter — skip tasks not matching requested tags
-                // Area filter
-                if (filter?.areas &&
-                    filter.areas.length > 0 &&
-                    !filter.areas
-                        .map((a) => a.toLowerCase())
-                        .includes(entry.featureArea.toLowerCase())) {
-                    continue;
-                }
-                // Task ID filter
-                if (filter?.taskIds &&
-                    filter.taskIds.length > 0 &&
-                    !filter.taskIds.includes(entry.id)) {
-                    continue;
-                }
-                // Status filter — unified lifecycle control
-                // Resolve effective status: explicit status field wins,
-                // then fall back to execution.enabled for backwards compat
-                const effectiveStatus = entry.status ??
-                    (entry.execution?.enabled === false ? "paused" : "active");
-                const isTargetedById = filter?.taskIds && filter.taskIds.includes(entry.id);
-                if (effectiveStatus === "archived") {
-                    continue; // Archived is always excluded, even with --task
-                }
-                if (effectiveStatus === "paused" && !isTargetedById) {
-                    continue; // Paused skipped unless explicitly targeted
+            for (const task of validated) {
+                if (passesFilter(task, filter)) {
+                    definitions.push(task);
                 }
-                if (effectiveStatus === "draft" &&
-                    !isTargetedById &&
-                    !filter?.includeDrafts) {
-                    continue; // Draft skipped unless targeted or includeDrafts
-                }
-                // Tag filter — skip tasks that don't match any requested tag
-                if (filter?.tags &&
-                    filter.tags.length > 0 &&
-                    (!entry.tags || !entry.tags.some((t) => filter.tags.includes(t)))) {
-                    continue;
-                }
-                definitions.push(mapToLiteracyTask(entry));
             }
         }
         // Load TS task files (.task.ts / .task.js)
         for (const tsFile of tsFiles) {
             const loaded = await loadTsTaskFile(tsFile);
             const filename = tsFile.split("/").pop() ?? tsFile;
-            // Validate through the same schema as YAML tasks
-            let validated;
-            try {
-                validated = parseRepoTaskFile(loaded.tasks, filename);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                throw new Error(`Failed to validate ${filename}:\n${msg}`, {
-                    cause: err,
-                });
-            }
-            for (const entry of validated) {
-                // Apply the same filtering as YAML tasks
-                if (filter?.areas &&
-                    filter.areas.length > 0 &&
-                    !filter.areas
-                        .map((a) => a.toLowerCase())
-                        .includes(entry.featureArea.toLowerCase())) {
-                    continue;
+            for (const raw of loaded.tasks) {
+                const task = raw;
+                if (!task.id || typeof task.id !== "string") {
+                    throw new Error(`Task in ${filename} is missing a valid "id" field`);
                 }
-                if (filter?.taskIds &&
-                    filter.taskIds.length > 0 &&
-                    !filter.taskIds.includes(entry.id)) {
-                    continue;
+                if (!task.mode || !KNOWN_MODES.has(task.mode)) {
+                    throw new Error(`Task "${task.id}" in ${filename} has missing or unknown mode "${task.mode}". ` +
+                        `Valid modes: ${[...KNOWN_MODES].join(", ")}`);
                 }
-                const effectiveStatus = entry.status ??
-                    (entry.execution?.enabled === false ? "paused" : "active");
-                const isTargetedById = filter?.taskIds && filter.taskIds.includes(entry.id);
-                if (effectiveStatus === "archived")
-                    continue;
-                if (effectiveStatus === "paused" && !isTargetedById)
-                    continue;
-                if (effectiveStatus === "draft" &&
-                    !isTargetedById &&
-                    !filter?.includeDrafts) {
-                    continue;
+                if (passesFilter(task, filter)) {
+                    definitions.push(task);
                 }
-                if (filter?.tags &&
-                    filter.tags.length > 0 &&
-                    (!entry.tags || !entry.tags.some((t) => filter.tags.includes(t)))) {
-                    continue;
-                }
-                definitions.push(mapToLiteracyTask(entry));
             }
         }
         return definitions;
     }
 }
 // ---------------------------------------------------------------------------
-// Mapping helpers
+// Filter helper
 // ---------------------------------------------------------------------------
-function mapToLiteracyTask(raw) {
-    // Extract task prompt from vars.task (same convention as YAML tasks)
-    const vars = (raw.vars ?? {});
-    const { docs: _docs, task, ...rest } = vars;
-    // Canonical docs are already parsed into the polymorphic union by Zod.
-    const docs = (raw.canonicalDocs ??
-        []);
-    const extraVars = Object.keys(rest).length > 0 ? rest : undefined;
-    return {
-        mode: "literacy",
-        id: raw.id,
-        title: raw.description,
-        area: raw.featureArea,
-        prompt: {
-            text: typeof task === "string" ? task : "",
-            ...(extraVars ? { vars: extraVars } : {}),
-        },
-        context: { docs },
-        assertions: (raw.assert ?? []),
-        referenceSolution: raw.referenceSolution ?? "",
-        docCoverage: raw.docCoverage ?? false,
-        ...(raw.baseline ? { baseline: raw.baseline } : {}),
-        ...(raw.status && raw.status !== "active" ? { status: raw.status } : {}),
-        ...(raw.tags?.length ? { tags: raw.tags } : {}),
-    };
+/**
+ * Apply standard task filtering. Used for both YAML and TS tasks.
+ */
+function passesFilter(task, filter) {
+    // Area filter
+    if (filter?.areas &&
+        filter.areas.length > 0 &&
+        (!task.area ||
+            !filter.areas
+                .map((a) => a.toLowerCase())
+                .includes(task.area.toLowerCase()))) {
+        return false;
+    }
+    // Task ID filter
+    if (filter?.taskIds &&
+        filter.taskIds.length > 0 &&
+        !filter.taskIds.includes(task.id)) {
+        return false;
+    }
+    // Status filter — unified lifecycle control
+    const effectiveStatus = task.status ?? "active";
+    const isTargetedById = filter?.taskIds && filter.taskIds.includes(task.id);
+    if (effectiveStatus === "archived")
+        return false;
+    if (effectiveStatus === "paused" && !isTargetedById)
+        return false;
+    if (effectiveStatus === "draft" &&
+        !isTargetedById &&
+        !filter?.includeDrafts) {
+        return false;
+    }
+    // Tag filter
+    if (filter?.tags &&
+        filter.tags.length > 0 &&
+        (!task.tags || !task.tags.some((t) => filter.tags.includes(t)))) {
+        return false;
+    }
+    return true;
 }

package/dist/adapters/task-sources/repo-trigger.d.ts

@@ -6,7 +6,7 @@
  * config applies. This drives whether the pipeline runs in validate-only
  * mode or full eval mode, and whether results are blocking.
  *
- * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
+ * @see docs/archive/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
  */
 export type TriggerContext = {
     type: "pr";

package/dist/adapters/task-sources/repo-trigger.js

@@ -6,7 +6,7 @@
  * config applies. This drives whether the pipeline runs in validate-only
  * mode or full eval mode, and whether results are blocking.
  *
- * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
+ * @see docs/archive/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
  */
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";

package/dist/adapters/task-sources/repo-validation.d.ts

@@ -1,8 +1,39 @@
 /**
- * repo-validation.ts — Re-exports semantic validation from @sanity/ailf-tasks.
+ * repo-validation.ts — Semantic validation for task definitions.
  *
- * The validation logic is the single source of truth in @sanity/ailf-tasks.
- * This file re-exports so existing eval-package importers don't need
- * to change their import paths.
+ * Checks that go beyond Zod schema parsing:
+ * - Assertion types are in the curated set
+ * - Rubric template names resolve to known templates
+ * - Doc ref slugs look reasonable (slugs, not URLs)
+ * - Tasks have at least one LLM rubric assertion (recommended)
+ * - Tasks have a prompt text (recommended)
+ *
+ * These produce warnings, not errors — the pipeline can still run
+ * with imperfect tasks. Only structural failures (caught by Zod) block.
+ *
+ * Previously this file re-exported from @sanity/ailf-tasks. That package
+ * has been eliminated — all validation logic now lives here.
+ */
+import { type CanonicalTask } from "./repo-schemas.js";
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationMessage[];
+    warnings: ValidationMessage[];
+}
+export interface ValidationMessage {
+    taskId: string;
+    field: string;
+    message: string;
+}
+/**
+ * Run semantic validation on an array of parsed canonical tasks.
+ *
+ * Returns warnings for issues that don't block execution (unknown feature
+ * areas, unresolved slugs) and errors for issues that would cause pipeline
+ * failures (completely missing required fields — though Zod catches most).
+ */
+export declare function validateCanonicalTasks(tasks: CanonicalTask[]): ValidationResult;
+/**
+ * Format validation results for console output.
  */
-export { detectSnakeCaseFields, formatValidationResult, validateRepoTasks, type ValidationMessage, type ValidationResult, } from "../../_vendor/ailf-tasks/index.d.ts";
+export declare function formatValidationResult(result: ValidationResult): string;