@sanity/ailf 0.4.1 → 1.0.0

package/dist/pipeline/validate.js

@@ -10,6 +10,7 @@
 import fs from "fs";
 import path from "path";
 import { load } from "js-yaml";
+import { tryLoadConfigFile } from "./compiler/config-loader.js";
 import { resolveMappings } from "./resolve-mappings.js";
 import { FeatureRegistrySchema, formatZodErrors, RubricConfigSchema, TaskFileSchema, ThresholdConfigSchema, } from "./schemas.js";
 // ---------------------------------------------------------------------------
@@ -64,7 +65,7 @@ export function validateContexts(rootDir) {
     return issues;
 }
 /**
- * Check that config/features.yaml exists, parses, and conforms to the Zod schema.
+ * Check that config/features exists, parses, and conforms to the Zod schema.
  * Also cross-references covered features against actual task files for consistency.
  *
  * Returns warnings (not errors) if the file is missing — the feature registry
@@ -73,20 +74,24 @@ export function validateContexts(rootDir) {
 export function validateFeaturesYaml(rootDir) {
     const source = "validateFeaturesYaml";
     const issues = [];
-    const filePath = path.join(rootDir, "config", "features.yaml");
-    if (!fs.existsSync(filePath)) {
+    const loaded = tryLoadConfigFile("features", rootDir);
+    if (!loaded) {
         // Feature registry is optional — warn, don't error
-        issues.push(warning(source, "config/features.yaml not found — coverage audit unavailable", filePath));
+        issues.push(warning(source, "config/features not found — coverage audit unavailable", path.join(rootDir, "config")));
+        return issues;
+    }
+    // Empty features array is valid — it means features come from the preset.
+    // The Zod schema requires .min(1) for non-empty configs, but an empty
+    // stub is the expected state when the preset provides all features.
+    const raw = loaded.data;
+    if (Array.isArray(raw?.features) && raw.features.length === 0) {
         return issues;
     }
-    const result = parseYamlFile(filePath, source);
-    if (!result.ok)
-        return [result.issue];
-    const zodResult = FeatureRegistrySchema.safeParse(result.data);
+    const zodResult = FeatureRegistrySchema.safeParse(loaded.data);
     if (!zodResult.success) {
         const lines = formatZodErrors(zodResult.error);
         for (const line of lines) {
-            issues.push(error(source, `config/features.yaml: ${line.trim()}`, filePath));
+            issues.push(error(source, `config/features: ${line.trim()}`, loaded.filePath));
         }
         return issues;
     }
@@ -95,18 +100,18 @@ export function validateFeaturesYaml(rootDir) {
     if (fs.existsSync(tasksDir)) {
         const taskFiles = new Set(fs
             .readdirSync(tasksDir)
-            .filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"))
-            .map((f) => f.replace(/\.(yaml|yml)$/, "")));
+            .filter((f) => /\.(yaml|yml|task\.ts|task\.js)$/.test(f))
+            .map((f) => f.replace(/\.(yaml|yml|task\.ts|task\.js)$/, "")));
         for (const feature of zodResult.data.features) {
             if (feature.status === "covered" && feature.area) {
                 if (!taskFiles.has(feature.area)) {
-                    issues.push(warning(source, `Feature '${feature.id}' is status: covered with area: '${feature.area}', but tasks/${feature.area}.yaml does not exist`, filePath));
+                    issues.push(warning(source, `Feature '${feature.id}' is status: covered with area: '${feature.area}', but tasks/${feature.area} does not exist`, loaded.filePath));
                 }
             }
             // Warn if an "uncovered" feature has a matching task file
             if (feature.status === "uncovered" && feature.area) {
                 if (taskFiles.has(feature.area)) {
-                    issues.push(warning(source, `Feature '${feature.id}' is status: uncovered but tasks/${feature.area}.yaml exists — consider updating status to 'covered'`, filePath));
+                    issues.push(warning(source, `Feature '${feature.id}' is status: uncovered but tasks/${feature.area} task file exists — consider updating status to 'covered'`, loaded.filePath));
                 }
             }
         }
@@ -114,7 +119,7 @@ export function validateFeaturesYaml(rootDir) {
         const ids = new Set();
         for (const feature of zodResult.data.features) {
             if (ids.has(feature.id)) {
-                issues.push(error(source, `Duplicate feature id '${feature.id}' in config/features.yaml`, filePath));
+                issues.push(error(source, `Duplicate feature id '${feature.id}' in config/features`, loaded.filePath));
             }
             ids.add(feature.id);
         }
@@ -122,47 +127,57 @@ export function validateFeaturesYaml(rootDir) {
     return issues;
 }
 /**
- * Check that config/models.yaml exists, parses, has at least one model with an id
+ * Check that config/models exists, parses, has at least one model with an id
  * and label, and has a grader defined.
  */
 export function validateModelsYaml(rootDir) {
     const source = "validateModelsYaml";
     const issues = [];
-    const filePath = path.join(rootDir, "config", "models.yaml");
-    const result = parseYamlFile(filePath, source);
-    if (!result.ok)
-        return [result.issue];
-    const { data } = result;
+    let data;
+    try {
+        data = loadConfigFileForValidation("models", rootDir);
+    }
+    catch {
+        issues.push(error(source, "config/models not found", path.join(rootDir, "config")));
+        return issues;
+    }
     if (!data || typeof data !== "object") {
-        issues.push(error(source, "config/models.yaml did not parse to an object", filePath));
+        issues.push(error(source, "config/models did not parse to an object", path.join(rootDir, "config")));
         return issues;
     }
     // Check models array
     if (!Array.isArray(data.models)) {
-        issues.push(error(source, "config/models.yaml is missing a 'models' array", filePath));
+        issues.push(error(source, "config/models is missing a 'models' array", path.join(rootDir, "config")));
     }
     else if (data.models.length === 0) {
-        issues.push(error(source, "config/models.yaml has an empty 'models' array", filePath));
+        issues.push(error(source, "config/models has an empty 'models' array", path.join(rootDir, "config")));
     }
     else {
         for (const [i, model] of data.models.entries()) {
             if (!model.id) {
-                issues.push(error(source, `models[${i}] is missing 'id'`, filePath));
+                issues.push(error(source, `models[${i}] is missing 'id'`, path.join(rootDir, "config")));
             }
             if (!model.label) {
-                issues.push(error(source, `models[${i}] is missing 'label'`, filePath));
+                issues.push(error(source, `models[${i}] is missing 'label'`, path.join(rootDir, "config")));
             }
         }
     }
     // Check grader
     if (!data.grader) {
-        issues.push(error(source, "config/models.yaml is missing a 'grader' section", filePath));
+        issues.push(error(source, "config/models is missing a 'grader' section", path.join(rootDir, "config")));
     }
     else if (!data.grader.id) {
-        issues.push(error(source, "config/models.yaml grader is missing 'id'", filePath));
+        issues.push(error(source, "config/models grader is missing 'id'", path.join(rootDir, "config")));
     }
     return issues;
 }
+/** Helper: load a config file for validation (throws on not found) */
+function loadConfigFileForValidation(name, rootDir) {
+    const result = tryLoadConfigFile(name, rootDir);
+    if (!result)
+        throw new Error(`Config "${name}" not found`);
+    return result.data;
+}
 // ---------------------------------------------------------------------------
 // Validators
 // ---------------------------------------------------------------------------
@@ -198,22 +213,23 @@ export function validateReferenceSolutions(rootDir) {
     return issues;
 }
 /**
- * Check that config/rubrics.yaml exists, parses, and conforms to the Zod schema.
+ * Check that config/rubrics exists, parses, and conforms to the Zod schema.
  * Returns the set of valid template keys for cross-referencing by task
  * validation.
  */
 export function validateRubricsYaml(rootDir) {
     const source = "validateRubricsYaml";
     const issues = [];
-    const filePath = path.join(rootDir, "config", "rubrics.yaml");
-    const result = parseYamlFile(filePath, source);
-    if (!result.ok)
-        return [result.issue];
-    const zodResult = RubricConfigSchema.safeParse(result.data);
+    const loaded = tryLoadConfigFile("rubrics", rootDir);
+    if (!loaded) {
+        issues.push(error(source, "config/rubrics not found", path.join(rootDir, "config")));
+        return issues;
+    }
+    const zodResult = RubricConfigSchema.safeParse(loaded.data);
     if (!zodResult.success) {
         const lines = formatZodErrors(zodResult.error);
         for (const line of lines) {
-            issues.push(error(source, `config/rubrics.yaml: ${line.trim()}`, filePath));
+            issues.push(error(source, `config/rubrics: ${line.trim()}`, loaded.filePath));
         }
     }
     return issues;
@@ -281,7 +297,7 @@ export function validateTaskFiles(rootDir) {
                         issues.push(warning(source, `${file}: id is '${entry.id}' but docs path is '${vars.docs}' (expected '${expectedPath}')`, filePath));
                     }
                 }
-                // Check that llm-rubric template references exist in config/rubrics.yaml
+                // Check that llm-rubric template references exist in config/rubrics
                 const asserts = entry.assert;
                 if (Array.isArray(asserts) && templateKeys.size > 0) {
                     for (const a of asserts) {
@@ -300,7 +316,7 @@ export function validateTaskFiles(rootDir) {
     return issues;
 }
 /**
- * Check that config/thresholds.yaml exists, parses, and conforms to the Zod schema.
+ * Check that config/thresholds exists, parses, and conforms to the Zod schema.
  *
  * Returns warnings (not errors) if the file is missing — thresholds are
  * optional and don't block evaluation. They only activate when
@@ -309,20 +325,17 @@ export function validateTaskFiles(rootDir) {
 export function validateThresholdsYaml(rootDir) {
     const source = "validateThresholdsYaml";
     const issues = [];
-    const filePath = path.join(rootDir, "config", "thresholds.yaml");
-    if (!fs.existsSync(filePath)) {
+    const loaded = tryLoadConfigFile("thresholds", rootDir);
+    if (!loaded) {
         // Thresholds are optional — warn, don't error
-        issues.push(warning(source, "config/thresholds.yaml not found — readiness gates and threshold alerts unavailable", filePath));
+        issues.push(warning(source, "config/thresholds not found — readiness gates and threshold alerts unavailable", path.join(rootDir, "config")));
         return issues;
     }
-    const result = parseYamlFile(filePath, source);
-    if (!result.ok)
-        return [result.issue];
-    const zodResult = ThresholdConfigSchema.safeParse(result.data);
+    const zodResult = ThresholdConfigSchema.safeParse(loaded.data);
     if (!zodResult.success) {
         const lines = formatZodErrors(zodResult.error);
         for (const line of lines) {
-            issues.push(error(source, `config/thresholds.yaml: ${line.trim()}`, filePath));
+            issues.push(error(source, `config/thresholds: ${line.trim()}`, loaded.filePath));
         }
         return issues;
     }
@@ -332,11 +345,11 @@ export function validateThresholdsYaml(rootDir) {
         if (fs.existsSync(tasksDir)) {
             const taskFiles = new Set(fs
                 .readdirSync(tasksDir)
-                .filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"))
-                .map((f) => f.replace(/\.(yaml|yml)$/, "")));
+                .filter((f) => /\.(yaml|yml|task\.ts|task\.js)$/.test(f))
+                .map((f) => f.replace(/\.(yaml|yml|task\.ts|task\.js)$/, "")));
             for (const areaName of Object.keys(zodResult.data.areas)) {
                 if (!taskFiles.has(areaName)) {
-                    issues.push(warning(source, `config/thresholds.yaml: area override '${areaName}' has no matching tasks/${areaName}.yaml`, filePath));
+                    issues.push(warning(source, `config/thresholds: area override '${areaName}' has no matching tasks/${areaName}`, loaded.filePath));
                 }
             }
         }
@@ -352,17 +365,15 @@ function error(source, message, filePath) {
     };
 }
 /**
- * Load the set of valid rubric template keys from config/rubrics.yaml.
+ * Load the set of valid rubric template keys from config/rubrics.
  * Returns an empty set if the file is missing or invalid.
  */
 function loadTemplateKeys(rootDir) {
-    const filePath = path.join(rootDir, "config", "rubrics.yaml");
-    if (!fs.existsSync(filePath))
+    const loaded = tryLoadConfigFile("rubrics", rootDir);
+    if (!loaded)
         return new Set();
     try {
-        const raw = fs.readFileSync(filePath, "utf-8");
-        const parsed = load(raw);
-        const templates = parsed?.templates;
+        const templates = loaded.data?.templates;
         if (templates && typeof templates === "object") {
             return new Set(Object.keys(templates));
         }

package/dist/schedules/loader.js

@@ -14,12 +14,13 @@ import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { load } from "js-yaml";
 import { interpolate } from "../interpolate.js";
+import { tryLoadConfigFile } from "../pipeline/compiler/config-loader.js";
 import { SchedulesFileSchema, } from "./schema.js";
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const DEFAULT_CONFIG_PATH = resolve(__dirname, "..", "..", "config", "schedules.yaml");
+const PACKAGE_ROOT = resolve(__dirname, "..", "..");
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -56,14 +57,23 @@ export function getEnabledSchedules(configPath) {
  * @param configPath - Override the default config file location
  * @returns Parsed and validated schedules file, or null if not found/invalid
  */
-export function loadSchedules(configPath = DEFAULT_CONFIG_PATH) {
-    if (!existsSync(configPath)) {
-        return null;
-    }
+export function loadSchedules(configPath) {
     try {
-        const raw = readFileSync(configPath, "utf-8");
-        const parsed = load(raw);
-        const interpolated = interpolate(parsed);
+        let data;
+        if (configPath) {
+            // Explicit path override (used by tests) — read directly
+            if (!existsSync(configPath))
+                return null;
+            data = load(readFileSync(configPath, "utf-8"));
+        }
+        else {
+            // Default: use unified config loader
+            const loaded = tryLoadConfigFile("schedules", PACKAGE_ROOT);
+            if (!loaded)
+                return null;
+            data = loaded.data;
+        }
+        const interpolated = interpolate(data);
         return SchedulesFileSchema.parse(interpolated);
     }
     catch (error) {

package/dist/scripts/migrate-task-mode.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env tsx
+/**
+ * Migration script: Add mode: "literacy" to Content Lake task documents.
+ *
+ * Phase 7f of the Architecture Overhaul. Queries all ailf.task documents
+ * that lack an explicit `mode` field and patches them with
+ * `mode: "literacy"` (the default mode for existing tasks).
+ *
+ * Idempotent — the GROQ query only matches documents where
+ * `!defined(mode)`, so re-running has no effect on already-patched
+ * documents.
+ *
+ * Usage:
+ *   cd packages/eval
+ *   npx tsx src/scripts/migrate-task-mode.ts --dry-run
+ *   npx tsx src/scripts/migrate-task-mode.ts
+ *
+ * Prerequisites:
+ *   - SANITY_API_TOKEN with write access to the project
+ *   - SANITY_PROJECT_ID and SANITY_DATASET configured (or defaults used)
+ *
+ * @see docs/exec-plans/architecture-overhaul/phase-7-migrate-literacy.md
+ */
+export {};

package/dist/scripts/migrate-task-mode.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env tsx
+/**
+ * Migration script: Add mode: "literacy" to Content Lake task documents.
+ *
+ * Phase 7f of the Architecture Overhaul. Queries all ailf.task documents
+ * that lack an explicit `mode` field and patches them with
+ * `mode: "literacy"` (the default mode for existing tasks).
+ *
+ * Idempotent — the GROQ query only matches documents where
+ * `!defined(mode)`, so re-running has no effect on already-patched
+ * documents.
+ *
+ * Usage:
+ *   cd packages/eval
+ *   npx tsx src/scripts/migrate-task-mode.ts --dry-run
+ *   npx tsx src/scripts/migrate-task-mode.ts
+ *
+ * Prerequisites:
+ *   - SANITY_API_TOKEN with write access to the project
+ *   - SANITY_PROJECT_ID and SANITY_DATASET configured (or defaults used)
+ *
+ * @see docs/exec-plans/architecture-overhaul/phase-7-migrate-literacy.md
+ */
+import { config as dotenvConfig } from "dotenv";
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { getSanityClient } from "../sanity/client.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..", "..");
+// Load .env from repository root (same as CLI entry point)
+const envPath = resolve(ROOT, "..", "..", ".env");
+if (existsSync(envPath)) {
+    dotenvConfig({ override: true, path: envPath });
+}
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+const DRY_RUN = process.argv.includes("--dry-run");
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    console.log("╭──────────────────────────────────────────────╮");
+    console.log('│ Phase 7f: Migrate task mode → "literacy"      │');
+    console.log("╰──────────────────────────────────────────────╯");
+    console.log();
+    if (DRY_RUN) {
+        console.log("  🏷️  DRY RUN — no documents will be modified.\n");
+    }
+    const client = getSanityClient({
+        token: process.env.AILF_REPORT_SANITY_API_TOKEN || process.env.SANITY_API_TOKEN,
+    });
+    // Step 1: Find all ailf.task documents without an explicit mode
+    const query = `*[_type == "ailf.task" && !defined(mode)]{ _id, title }`;
+    const tasksWithoutMode = await client.fetch(query);
+    console.log(`  Found ${tasksWithoutMode.length} task(s) without an explicit mode.\n`);
+    if (tasksWithoutMode.length === 0) {
+        console.log("  ✅ Nothing to migrate — all tasks already have a mode.");
+        return;
+    }
+    // Step 2: Show what would be patched
+    for (const task of tasksWithoutMode) {
+        const label = task.title ?? task._id;
+        console.log(`    • ${label} (${task._id})`);
+    }
+    console.log();
+    if (DRY_RUN) {
+        console.log(`  Would patch ${tasksWithoutMode.length} document(s) with mode: "literacy".`);
+        console.log("  Re-run without --dry-run to apply.\n");
+        return;
+    }
+    // Step 3: Patch all matching documents in a transaction
+    const transaction = client.transaction();
+    for (const task of tasksWithoutMode) {
+        transaction.patch(task._id, (patch) => patch.set({ mode: "literacy" }));
+    }
+    const result = await transaction.commit();
+    console.log(`  ✅ Patched ${tasksWithoutMode.length} document(s) with mode: "literacy".`);
+    console.log(`  Transaction ID: ${result.transactionId}\n`);
+}
+main().catch((err) => {
+    console.error("Migration failed:", err);
+    process.exit(1);
+});

package/dist/scripts/migrate-tasks-to-content-lake.js

@@ -138,12 +138,12 @@ function buildReferenceSolutionDoc(task, code, language) {
         _type: "ailf.referenceSolution",
         content: sourceToPortableText(code, language),
         language,
-        title: `${task.description} — Reference Solution`,
+        title: `${task.title} — Reference Solution`,
     };
 }
 function buildTaskDoc(task, slugToDocId, hasReferenceSolution) {
     // Build canonical docs array with resolved references (slug refs only)
-    const canonicalDocs = task.canonicalDocs.map((ref) => {
+    const canonicalDocs = (task.context?.docs ?? []).map((ref) => {
         const resolvedId = isSlugRef(ref) ? slugToDocId.get(ref.slug) : undefined;
         return {
             _key: ptKey(),
@@ -152,7 +152,7 @@ function buildTaskDoc(task, slugToDocId, hasReferenceSolution) {
         };
     });
     // Build assertions array
-    const assertArray = task.assertions.map((a) => {
+    const assertArray = (task.assertions ?? []).map((a) => {
         const entry = {
             _key: ptKey(),
             type: a.type,
@@ -176,19 +176,20 @@ function buildTaskDoc(task, slugToDocId, hasReferenceSolution) {
         }
         return entry;
     });
+    const area = task.area ?? "";
     const doc = {
         _id: taskDocId(task.id),
         _type: "ailf.task",
         assert: assertArray,
         canonicalDocs,
-        description: task.description,
-        docCoverage: task.docCoverage,
+        description: task.title,
+        docCoverage: task.docCoverage ?? false,
         featureArea: {
-            _ref: featureAreaDocId(task.featureArea),
+            _ref: featureAreaDocId(area),
             _type: "reference",
         },
         id: { _type: "slug", current: task.id },
-        taskPrompt: task.taskPrompt,
+        taskPrompt: task.prompt?.text ?? "",
     };
     // Optional reference solution
     if (hasReferenceSolution) {
@@ -220,14 +221,14 @@ async function migrate() {
     // 1. Load all tasks from YAML
     console.log("\n1️⃣  Loading tasks from YAML...");
     const taskSource = new YamlTaskSource(ROOT);
-    const tasks = await taskSource.loadTasks();
+    const tasks = (await taskSource.loadTasks()).filter((t) => t.mode === "literacy");
     console.log(`  Loaded ${tasks.length} tasks`);
     // 2. Extract unique feature areas
-    const areas = [...new Set(tasks.map((t) => t.featureArea))].sort();
+    const areas = [...new Set(tasks.map((t) => t.area ?? ""))].sort();
     console.log(`  Found ${areas.length} feature areas: ${areas.join(", ")}`);
     // 3. Collect all canonical doc slugs for batch resolution (slug refs only)
     const allSlugs = [
-        ...new Set(tasks.flatMap((t) => t.canonicalDocs.filter(isSlugRef).map((d) => d.slug))),
+        ...new Set(tasks.flatMap((t) => (t.context?.docs ?? []).filter(isSlugRef).map((d) => d.slug))),
     ];
     console.log(`  Found ${allSlugs.length} unique canonical doc slugs`);
     // 4. Create Sanity client with write token

package/dist/scripts/validate-task-sources.d.ts

@@ -3,7 +3,7 @@
  * Validation script: Compare YamlTaskSource vs ContentLakeTaskSource
  *
  * Loads tasks from both sources and compares them field-by-field to verify
- * that the Content Lake migration produced identical TaskDefinition[] output.
+ * that the Content Lake migration produced identical LiteracyTaskDefinition[] output.
  *
  * This is Phase 3b of the tasks-as-content exec plan — parallel validation
  * before deleting YAML files.

package/dist/scripts/validate-task-sources.js

@@ -3,7 +3,7 @@
  * Validation script: Compare YamlTaskSource vs ContentLakeTaskSource
  *
  * Loads tasks from both sources and compares them field-by-field to verify
- * that the Content Lake migration produced identical TaskDefinition[] output.
+ * that the Content Lake migration produced identical LiteracyTaskDefinition[] output.
  *
  * This is Phase 3b of the tasks-as-content exec plan — parallel validation
  * before deleting YAML files.
@@ -34,7 +34,7 @@ if (existsSync(envPath)) {
     dotenvConfig({ override: true, path: envPath });
 }
 /**
- * Compare two TaskDefinition arrays field-by-field.
+ * Compare two LiteracyTaskDefinition arrays field-by-field.
  * Returns a list of differences.
  */
 function compareTasks(yamlTasks, clTasks) {
@@ -50,26 +50,26 @@ function compareTasks(yamlTasks, clTasks) {
         if (!clTask)
             continue;
         // Compare each field
-        compareField(diffs, id, "description", yamlTask.description, clTask.description);
-        compareField(diffs, id, "featureArea", yamlTask.featureArea, clTask.featureArea);
+        compareField(diffs, id, "title", yamlTask.title, clTask.title);
+        compareField(diffs, id, "area", yamlTask.area, clTask.area);
         compareField(diffs, id, "docCoverage", yamlTask.docCoverage, clTask.docCoverage);
-        // taskPrompt — normalize whitespace for comparison (YAML multiline vs CL text)
-        const yamlPrompt = yamlTask.taskPrompt.trim();
-        const clPrompt = clTask.taskPrompt.trim();
+        // prompt.text — normalize whitespace for comparison (YAML multiline vs CL text)
+        const yamlPrompt = (yamlTask.prompt?.text ?? "").trim();
+        const clPrompt = (clTask.prompt?.text ?? "").trim();
         if (yamlPrompt !== clPrompt) {
             diffs.push({
                 clValue: truncate(clPrompt, 100),
-                field: "taskPrompt",
+                field: "prompt.text",
                 taskId: id,
                 yamlValue: truncate(yamlPrompt, 100),
             });
         }
-        // canonicalDocs — compare slug sets (slug refs only for comparison)
-        const yamlSlugs = yamlTask.canonicalDocs
+        // context.docs — compare slug sets (slug refs only for comparison)
+        const yamlSlugs = (yamlTask.context?.docs ?? [])
             .filter(isSlugRef)
             .map((d) => d.slug)
             .sort();
-        const clSlugs = clTask.canonicalDocs
+        const clSlugs = (clTask.context?.docs ?? [])
             .filter(isSlugRef)
             .map((d) => d.slug)
             .sort();
@@ -82,7 +82,7 @@ function compareTasks(yamlTasks, clTasks) {
             });
         }
         // assertions — compare type + template arrays
-        const yamlAssertTypes = yamlTask.assertions
+        const yamlAssertTypes = (yamlTask.assertions ?? [])
             .map((a) => {
             const base = a.type;
             if ("template" in a)
@@ -90,7 +90,7 @@ function compareTasks(yamlTasks, clTasks) {
             return base;
         })
             .sort();
-        const clAssertTypes = clTask.assertions
+        const clAssertTypes = (clTask.assertions ?? [])
             .map((a) => {
             const base = a.type;
             if ("template" in a)
@@ -130,7 +130,7 @@ async function validate() {
     // Load from YAML
     console.log("\n1️⃣  Loading from YAML (tasks/*.yaml)...");
     const yamlSource = new YamlTaskSource(ROOT);
-    const yamlTasks = await yamlSource.loadTasks();
+    const yamlTasks = (await yamlSource.loadTasks()).filter((t) => t.mode === "literacy");
     console.log(`  Loaded ${yamlTasks.length} tasks`);
     // Load from Content Lake (use write token since task docs may require it)
     console.log("\n2️⃣  Loading from Content Lake (ailf.task)...");
@@ -140,7 +140,7 @@ async function validate() {
             undefined,
     });
     const clSource = new ContentLakeTaskSource(client);
-    const clTasks = await clSource.loadTasks();
+    const clTasks = (await clSource.loadTasks()).filter((t) => t.mode === "literacy");
     console.log(`  Loaded ${clTasks.length} tasks`);
     // Compare
     console.log("\n3️⃣  Comparing...");

package/dist/sinks/loader.js

@@ -7,11 +7,10 @@
  *
  * @see docs/design-docs/report-store/sink-architecture.md
  */
-import { existsSync, readFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
-import { load } from "js-yaml";
 import { interpolate } from "../interpolate.js";
+import { tryLoadConfigFile } from "../pipeline/compiler/config-loader.js";
 import { BigQuerySink } from "./bigquery/index.js";
 import { SinksFileSchema } from "./schema.js";
 import { SlackSink } from "./slack/index.js";
@@ -20,7 +19,7 @@ import { WebhookSink } from "./webhook/index.js";
 // Paths
 // ---------------------------------------------------------------------------
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const SINKS_CONFIG_PATH = resolve(__dirname, "..", "..", "config", "sinks.yaml");
+const PACKAGE_ROOT = resolve(__dirname, "..", "..");
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -32,13 +31,12 @@ const SINKS_CONFIG_PATH = resolve(__dirname, "..", "..", "config", "sinks.yaml")
  * - The config file fails to parse or validate
  */
 export function loadSinks() {
-    if (!existsSync(SINKS_CONFIG_PATH)) {
+    const loaded = tryLoadConfigFile("sinks", PACKAGE_ROOT);
+    if (!loaded) {
         return [];
     }
     try {
-        const raw = readFileSync(SINKS_CONFIG_PATH, "utf-8");
-        const parsed = load(raw);
-        const interpolated = interpolate(parsed);
+        const interpolated = interpolate(loaded.data);
         // When all sinks are commented out, js-yaml returns { sinks: null }.
         // Normalize null → undefined so Zod's .default([]) can apply.
         const normalized = interpolated && typeof interpolated === "object"