@sanity/ailf 0.1.0

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

@@ -0,0 +1,245 @@
+/**
+ * repo-schemas.ts — Zod schemas for repo-based task definitions.
+ *
+ * Validates .ailf/tasks/*.yaml task files and .ailf/config.yaml trigger
+ * configuration from external repositories (Phase 4 of Tasks as Content).
+ *
+ * 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.
+ *
+ * @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 { 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;
+    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.
+ */
+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>>;
+/**
+ * Zod schema for .ailf/config.yaml — controls how and when evaluations
+ * are triggered from an external repository.
+ */
+export declare const RepoConfigSchema: z.ZodObject<{
+    triggers: z.ZodOptional<z.ZodObject<{
+        pr: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                eval: "eval";
+                "validate-only": "validate-only";
+            }>>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            blocking: z.ZodOptional<z.ZodBoolean>;
+            notify: z.ZodOptional<z.ZodBoolean>;
+            compare: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        "pr-task-change": z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                eval: "eval";
+                "validate-only": "validate-only";
+            }>>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            blocking: z.ZodOptional<z.ZodBoolean>;
+            notify: z.ZodOptional<z.ZodBoolean>;
+            compare: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        main: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                eval: "eval";
+                "validate-only": "validate-only";
+            }>>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            blocking: z.ZodOptional<z.ZodBoolean>;
+            notify: z.ZodOptional<z.ZodBoolean>;
+            compare: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        schedule: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                eval: "eval";
+                "validate-only": "validate-only";
+            }>>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            blocking: z.ZodOptional<z.ZodBoolean>;
+            notify: z.ZodOptional<z.ZodBoolean>;
+            compare: z.ZodOptional<z.ZodBoolean>;
+            cron: z.ZodString;
+        }, z.core.$strip>>;
+    }, 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.
+ */
+export declare function parseRepoConfig(raw: unknown, filename?: string): RepoConfig;

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

@@ -0,0 +1,234 @@
+/**
+ * repo-schemas.ts — Zod schemas for repo-based task definitions.
+ *
+ * Validates .ailf/tasks/*.yaml task files and .ailf/config.yaml trigger
+ * configuration from external repositories (Phase 4 of Tasks as Content).
+ *
+ * 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.
+ *
+ * @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 { 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),
+    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);
+// ---------------------------------------------------------------------------
+// RepoConfigSchema — .ailf/config.yaml
+// ---------------------------------------------------------------------------
+const TriggerModeSchema = z.enum(["validate-only", "eval"]);
+const TriggerConfigSchema = z.object({
+    mode: TriggerModeSchema.default("eval"),
+    paths: z.array(z.string()).optional(),
+    blocking: z.boolean().optional(),
+    notify: z.boolean().optional(),
+    compare: z.boolean().optional(),
+});
+const ScheduleTriggerSchema = TriggerConfigSchema.extend({
+    cron: z.string().min(1),
+});
+/**
+ * Zod schema for .ailf/config.yaml — controls how and when evaluations
+ * are triggered from an external repository.
+ */
+export const RepoConfigSchema = z.object({
+    triggers: z
+        .object({
+        pr: TriggerConfigSchema.optional(),
+        "pr-task-change": TriggerConfigSchema.optional(),
+        main: TriggerConfigSchema.optional(),
+        schedule: ScheduleTriggerSchema.optional(),
+    })
+        .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.
+ */
+export function parseRepoConfig(raw, filename = ".ailf/config.yaml") {
+    const result = RepoConfigSchema.safeParse(raw);
+    if (!result.success) {
+        const messages = result.error.issues
+            .map((i) => `  [${i.path.join(".")}]: ${i.message}`)
+            .join("\n");
+        throw new Error(`Invalid repo config "${filename}":\n${messages}`);
+    }
+    return result.data;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Adapter: Load task definitions from .ailf/tasks/*.yaml 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 TaskDefinition is straightforward — field names are already
+ * aligned with the domain type.
+ *
+ * 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)
+ *
+ * @see packages/core/src/ports/task-source.ts — TaskSource port
+ * @see docs/exec-plans/completed/tasks-as-content/phase-4-repo-based-tasks.md
+ */
+import type { FilterOptions, TaskDefinition, TaskSource } from "../../_vendor/ailf-core/index.d.ts";
+export declare class RepoTaskSource implements TaskSource {
+    private readonly tasksDir;
+    constructor(tasksDir: string);
+    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+}

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

@@ -0,0 +1,104 @@
+/**
+ * Adapter: Load task definitions from .ailf/tasks/*.yaml 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 TaskDefinition is straightforward — field names are already
+ * aligned with the domain type.
+ *
+ * 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)
+ *
+ * @see packages/core/src/ports/task-source.ts — TaskSource port
+ * @see docs/exec-plans/completed/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";
+// ---------------------------------------------------------------------------
+// RepoTaskSource adapter
+// ---------------------------------------------------------------------------
+export class RepoTaskSource {
+    tasksDir;
+    constructor(tasksDir) {
+        this.tasksDir = tasksDir;
+    }
+    async loadTasks(filter) {
+        if (!existsSync(this.tasksDir)) {
+            throw new Error(`Repo tasks directory not found: ${this.tasksDir}\n` +
+                "  Provide a valid path via --repo-tasks-path");
+        }
+        const yamlFiles = readdirSync(this.tasksDir)
+            .filter((f) => (f.endsWith(".yaml") || f.endsWith(".yml")) && !f.startsWith("."))
+            .sort();
+        if (yamlFiles.length === 0) {
+            throw new Error(`No YAML files found in ${this.tasksDir}\n` +
+                "  Expected .ailf/tasks/*.yaml files with task definitions");
+        }
+        const definitions = [];
+        for (const file of yamlFiles) {
+            const filePath = resolve(this.tasksDir, file);
+            const raw = readFileSync(filePath, "utf-8");
+            const parsed = load(raw);
+            if (!Array.isArray(parsed)) {
+                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
+            let validated;
+            try {
+                validated = parseRepoTaskFile(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) {
+                // 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;
+                }
+                definitions.push(mapToTaskDefinition(entry));
+            }
+        }
+        return definitions;
+    }
+}
+// ---------------------------------------------------------------------------
+// Mapping helpers
+// ---------------------------------------------------------------------------
+function mapToTaskDefinition(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.
+    // Each entry has exactly one resolution key (slug, path, id, or perspective).
+    const canonicalDocs = (raw.canonicalDocs ??
+        []);
+    const extraVars = Object.keys(rest).length > 0 ? rest : undefined;
+    return {
+        assertions: (raw.assert ?? []),
+        canonicalDocs,
+        description: raw.description,
+        docCoverage: raw.docCoverage ?? false,
+        featureArea: raw.featureArea,
+        id: raw.id,
+        referenceSolution: raw.referenceSolution ?? "",
+        taskPrompt: typeof task === "string" ? task : "",
+        ...(raw.baseline ? { baseline: raw.baseline } : {}),
+        ...(extraVars ? { extraVars } : {}),
+    };
+}

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

@@ -0,0 +1,52 @@
+/**
+ * Trigger processing for repo-based AILF tasks.
+ *
+ * Reads .ailf/config.yaml, determines the current execution context
+ * (PR, main merge, schedule, manual), and resolves which trigger
+ * 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/completed/tasks-as-content/phase-4-repo-based-tasks.md
+ */
+export type TriggerContext = {
+    type: "pr";
+    branch: string;
+    changedFiles?: string[];
+} | {
+    type: "main";
+} | {
+    type: "schedule";
+} | {
+    type: "manual";
+};
+export interface ResolvedTrigger {
+    /** Whether this trigger matched the current context */
+    matched: boolean;
+    /** Eval mode: validate-only (parse checks only) or eval (full run) */
+    mode: "eval" | "validate-only";
+    /** Whether failing scores should block the PR/merge */
+    blocking: boolean;
+    /** Whether to notify (e.g., post PR comment) */
+    notify: boolean;
+    /** Whether to run comparison against baseline */
+    compare: boolean;
+    /** Path filters — only trigger when these paths changed */
+    paths?: string[];
+    /** Cron schedule (only for schedule triggers) */
+    cron?: string;
+}
+/**
+ * Load and resolve the trigger configuration for the current context.
+ *
+ * @param repoRoot - Root of the external repo (contains .ailf/)
+ * @param context - The current execution context (PR, main, schedule, manual)
+ * @returns The resolved trigger config, or a default (eval, non-blocking)
+ */
+export declare function resolveTrigger(repoRoot: string, context: TriggerContext): ResolvedTrigger;
+/**
+ * Detect the current trigger context from environment variables.
+ *
+ * Reads GitHub Actions env vars to determine if we're in a PR,
+ * on the main branch, running on schedule, or manual dispatch.
+ */
+export declare function detectTriggerContext(): TriggerContext;