@sanity/ailf 0.1.6 → 0.1.7

package/dist/adapters/api-client/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * api-client/types.ts — Response types for the AILF API.
+ *
+ * These are the client-side types derived from the API's standard response
+ * envelope pattern (Stripe-style: `object`, `createdAt`, `apiVersion` on
+ * every response). They mirror the shapes returned by the API routes but
+ * are defined independently — the client doesn't import from the API
+ * package.
+ *
+ * @see packages/api/src/lib/envelope.ts — server-side envelope builders
+ * @see packages/api/src/routes/pipeline.ts — POST /v1/pipeline response
+ * @see packages/api/src/routes/jobs.ts — GET /v1/jobs/:id response
+ */
+/** Standard envelope fields present on every API response. */
+export interface ApiEnvelope {
+    object: string;
+    createdAt: string;
+    apiVersion: string;
+}
+/** Possible terminal and non-terminal job statuses. */
+export type JobStatus = "received" | "queued" | "running" | "completed" | "failed" | "timed-out";
+/** Structured error detail attached to failed/timed-out jobs. */
+export interface JobError {
+    message: string;
+    step?: string;
+}
+/** Step-level progress info for running jobs. */
+export interface JobProgress {
+    step: string;
+    current: number;
+    total: number;
+}
+/** Execution backend info. */
+export interface JobExecution {
+    backend: string;
+    runId?: string | null;
+    runUrl?: string | null;
+}
+/** Full job response from GET /v1/jobs/:id. */
+export interface JobResponse extends ApiEnvelope {
+    object: "job";
+    jobId: string;
+    status: JobStatus;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    progress?: JobProgress | null;
+    execution?: JobExecution | null;
+    reportId?: string | null;
+    reportUrl?: string | null;
+    error?: JobError | null;
+}
+/** Response from POST /v1/pipeline. */
+export interface SubmitResponse extends ApiEnvelope {
+    object: "job";
+    jobId: string;
+    status: string;
+    statusUrl: string;
+    backend: string;
+    estimatedDurationMs?: number;
+    runUrl?: string;
+}
+export interface ValidationIssue {
+    severity: string;
+    source: string;
+    message: string;
+}
+export interface ValidationResponse extends ApiEnvelope {
+    object: "validation";
+    valid: boolean;
+    issues?: ValidationIssue[];
+}
+export interface ApiErrorDetail {
+    code: string;
+    message: string;
+    param?: string;
+    issues?: ValidationIssue[];
+    retryAfter?: string;
+}
+export interface ApiErrorResponse extends ApiEnvelope {
+    object: "error";
+    error: ApiErrorDetail;
+}
+/** Configuration for creating an ApiClient instance. */
+export interface ApiClientOptions {
+    /** AILF API key (starts with ailf_live_sk_ or ailf_test_sk_). */
+    apiKey: string;
+    /** Base URL for the AILF API. Defaults to https://ailf-api.sanity.build. */
+    baseUrl?: string;
+}
+/** Options for the waitForCompletion() polling method. */
+export interface WaitOptions {
+    /** Maximum time to wait in milliseconds (default: 20 minutes). */
+    timeoutMs?: number;
+    /** Called after each poll with the current job state. */
+    onProgress?: (job: JobResponse) => void;
+    /** Long-poll wait time in seconds sent via Prefer header (default: 25, max: 25). */
+    longPollSeconds?: number;
+}

package/dist/adapters/api-client/types.js

@@ -0,0 +1,14 @@
+/**
+ * api-client/types.ts — Response types for the AILF API.
+ *
+ * These are the client-side types derived from the API's standard response
+ * envelope pattern (Stripe-style: `object`, `createdAt`, `apiVersion` on
+ * every response). They mirror the shapes returned by the API routes but
+ * are defined independently — the client doesn't import from the API
+ * package.
+ *
+ * @see packages/api/src/lib/envelope.ts — server-side envelope builders
+ * @see packages/api/src/routes/pipeline.ts — POST /v1/pipeline response
+ * @see packages/api/src/routes/jobs.ts — GET /v1/jobs/:id response
+ */
+export {};

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

@@ -92,5 +92,7 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
         allowedOrigins: config.allowedOrigins,
         searchMode: config.searchMode ?? "open",
         concurrency: config.concurrency,
+        remote: false,
+        apiUrl: "https://ailf-api.sanity.build",
     };
 }

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

@@ -1,189 +1,29 @@
 /**
- * repo-schemas.ts — Zod schemas for repo-based task definitions.
+ * repo-schemas.ts — Re-exports task schemas + defines config schemas.
  *
- * Validates .ailf/tasks/*.yaml task files and .ailf/config.yaml trigger
- * configuration from external repositories (Phase 4 of Tasks as Content).
+ * 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.
  *
- * 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.
+ * 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.
  *
+ * @see packages/tasks/src/schemas.ts — task schema source of truth
  * @see docs/exec-plans/completed/tasks-as-content/phase-4-repo-based-tasks.md
- * @see packages/eval/src/adapters/task-sources/repo-task-source.ts
  */
+import { RepoTaskFileSchema as _Schema } from "../../_vendor/ailf-tasks/index.d.ts";
 import { z } from "zod";
+export { CURATED_ASSERTION_TYPES, RepoTaskFileSchema, RepoTaskSchema, RUBRIC_TEMPLATE_NAMES, type CuratedAssertionType, type RepoTask, type RubricTemplateName, } from "../../_vendor/ailf-tasks/index.d.ts";
+export { loadTaskDir, parseTaskFile } from "../../_vendor/ailf-tasks/index.d.ts";
 /**
- * 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.
+ * Parse and validate a repo task file's content. Returns typed tasks or throws
+ * with a user-friendly Zod error message.
  *
- * 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;
-    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<{
-            full: "full";
-            abbreviated: "abbreviated";
-            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.
+ * NOTE: This accepts pre-parsed YAML data (unknown), not a raw string.
+ * For raw YAML strings, use `parseTaskFile()` from @sanity/ailf-tasks.
  */
-export declare const RepoTaskFileSchema: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    description: z.ZodString;
-    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<{
-            full: "full";
-            abbreviated: "abbreviated";
-            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 declare function parseRepoTaskFile(raw: unknown, filename: string): z.infer<typeof _Schema>;
 /**
  * Zod schema for .ailf/config.yaml — controls documentation source,
  * report destination, and trigger behavior for evaluations from an
@@ -244,11 +84,6 @@ export declare const RepoConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type RepoConfig = z.infer<typeof RepoConfigSchema>;
-/**
- * Parse and validate a repo task file's content. Returns typed tasks or throws
- * with a user-friendly Zod error message.
- */
-export declare function parseRepoTaskFile(raw: unknown, filename: string): RepoTask[];
 /**
  * Parse and validate .ailf/config.yaml content. Returns typed config or throws.
  */

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

@@ -1,181 +1,43 @@
 /**
- * repo-schemas.ts — Zod schemas for repo-based task definitions.
+ * repo-schemas.ts — Re-exports task schemas + defines config schemas.
  *
- * Validates .ailf/tasks/*.yaml task files and .ailf/config.yaml trigger
- * configuration from external repositories (Phase 4 of Tasks as Content).
+ * 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.
  *
- * 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.
+ * 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.
  *
+ * @see packages/tasks/src/schemas.ts — task schema source of truth
  * @see docs/exec-plans/completed/tasks-as-content/phase-4-repo-based-tasks.md
- * @see packages/eval/src/adapters/task-sources/repo-task-source.ts
  */
+import { RepoTaskFileSchema as _Schema } from "../../_vendor/ailf-tasks/index.js";
 import { z } from "zod";
 // ---------------------------------------------------------------------------
-// Constants — curated assertion types and rubric template names
+// Re-exports from @sanity/ailf-tasks (task schemas + validation)
 // ---------------------------------------------------------------------------
+export { CURATED_ASSERTION_TYPES, RepoTaskFileSchema, RepoTaskSchema, RUBRIC_TEMPLATE_NAMES, } from "../../_vendor/ailf-tasks/index.js";
+export { loadTaskDir, parseTaskFile } from "../../_vendor/ailf-tasks/index.js";
 /**
- * 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.
+ * Parse and validate a repo task file's content. Returns typed tasks or throws
+ * with a user-friendly Zod error message.
  *
- * This is the external-author-facing contract. Field names are camelCase
- * to match the Content Lake document schema (ailf.task).
+ * NOTE: This accepts pre-parsed YAML data (unknown), not a raw string.
+ * For raw YAML strings, use `parseTaskFile()` from @sanity/ailf-tasks.
  */
-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),
-    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);
+export function parseRepoTaskFile(raw, filename) {
+    const result = _Schema.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}`);
+    }
+    return result.data;
+}
 // ---------------------------------------------------------------------------
-// RepoConfigSchema — .ailf/config.yaml
+// Config schemas — specific to the eval pipeline
 // ---------------------------------------------------------------------------
 const TriggerModeSchema = z.enum(["validate-only", "eval"]);
 const TriggerConfigSchema = z.object({
@@ -202,8 +64,6 @@ const SourceConfigSchema = z
 /**
  * Report store configuration.
  * Defines which Sanity project receives `ailf.report` documents.
- * This should match the project/dataset configured in the user's Studio.
- * The API token comes from the AILF_REPORT_SANITY_API_TOKEN env var.
  */
 const ReportStoreConfigSchema = z
     .object({
@@ -228,23 +88,6 @@ export const RepoConfigSchema = z.object({
     })
         .optional(),
 });
-// ---------------------------------------------------------------------------
-// Validation helpers
-// ---------------------------------------------------------------------------
-/**
- * Parse and validate a repo task file's content. Returns typed tasks or throws
- * with a user-friendly Zod error message.
- */
-export function parseRepoTaskFile(raw, filename) {
-    const result = RepoTaskFileSchema.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}`);
-    }
-    return result.data;
-}
 /**
  * Parse and validate .ailf/config.yaml content. Returns typed config or throws.
  */

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

@@ -1,49 +1,8 @@
 /**
- * Semantic validation for repo-based tasks.
+ * repo-validation.ts — Re-exports semantic validation from @sanity/ailf-tasks.
  *
- * Checks that go beyond Zod schema parsing:
- * - Assertion types are in the curated set
- * - Rubric template names resolve to known templates
- * - Feature area strings are well-formed
- * - Canonical doc slugs look reasonable (slugs, not URLs)
- *
- * These produce warnings, not errors — the pipeline can still run
- * with imperfect tasks. Only structural failures (caught by Zod) block.
- *
- * @see packages/eval/src/adapters/task-sources/repo-schemas.ts
- */
-import { type RepoTask } 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 repo 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 validateRepoTasks(tasks: RepoTask[]): ValidationResult;
-/**
- * Format validation results for console output.
- */
-export declare function formatValidationResult(result: ValidationResult): string;
-/**
- * Detect snake_case field names in raw task YAML data.
- *
- * This runs BEFORE Zod parsing to provide a user-friendly error message
- * when authors use framework-internal snake_case names instead of the
- * camelCase names expected in repo task files.
- *
- * @param raw - Raw parsed YAML (before Zod validation)
- * @param filename - Source filename for error messages
- * @returns Array of warning messages (empty if no issues)
+ * 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.
  */
-export declare function detectSnakeCaseFields(raw: unknown, filename: string): string[];
+export { detectSnakeCaseFields, formatValidationResult, validateRepoTasks, type ValidationMessage, type ValidationResult, } from "../../_vendor/ailf-tasks/index.d.ts";