@sanity/ailf 0.5.0 → 2.0.0

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

@@ -1,8 +1,129 @@
 /**
- * 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 { CURATED_ASSERTION_TYPES, RUBRIC_TEMPLATE_NAMES, } from "./repo-schemas.js";
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * 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 function validateCanonicalTasks(tasks) {
+    const errors = [];
+    const warnings = [];
+    // Check for duplicate IDs
+    const seenIds = new Set();
+    for (const task of tasks) {
+        if (seenIds.has(task.id)) {
+            errors.push({
+                taskId: task.id,
+                field: "id",
+                message: `Duplicate task ID "${task.id}"`,
+            });
+        }
+        seenIds.add(task.id);
+    }
+    for (const task of tasks) {
+        const assertions = task.assertions ?? [];
+        // Check assertion types
+        for (let i = 0; i < assertions.length; i++) {
+            const assertion = assertions[i];
+            if (!CURATED_ASSERTION_TYPES.includes(assertion.type)) {
+                warnings.push({
+                    taskId: task.id,
+                    field: `assertions[${i}].type`,
+                    message: `Unknown assertion type "${assertion.type}". ` +
+                        `Valid types: ${CURATED_ASSERTION_TYPES.join(", ")}`,
+                });
+            }
+            // Check rubric template for llm-rubric assertions
+            if (assertion.type === "llm-rubric" && "template" in assertion) {
+                const template = assertion.template;
+                if (!RUBRIC_TEMPLATE_NAMES.includes(template)) {
+                    warnings.push({
+                        taskId: task.id,
+                        field: `assertions[${i}].template`,
+                        message: `Unknown rubric template "${template}". ` +
+                            `Valid templates: ${RUBRIC_TEMPLATE_NAMES.join(", ")}`,
+                    });
+                }
+            }
+        }
+        // Check canonical doc refs look reasonable
+        const docs = task.context?.docs ?? [];
+        for (let i = 0; i < docs.length; i++) {
+            const doc = docs[i];
+            // Slug refs: warn if they look like URLs or paths
+            if ("slug" in doc && !("id" in doc) && typeof doc.slug === "string") {
+                if (doc.slug.includes("/") || doc.slug.includes("http")) {
+                    warnings.push({
+                        taskId: task.id,
+                        field: `context.docs[${i}].slug`,
+                        message: `Slug "${doc.slug}" looks like a URL or path — use 'path' type for paths or 'slug' for document slugs (e.g., "groq-introduction")`,
+                    });
+                }
+            }
+        }
+        // Check task has at least one llm-rubric assertion (recommended but not required)
+        const hasLlmRubric = assertions.some((a) => a.type === "llm-rubric");
+        if (!hasLlmRubric) {
+            warnings.push({
+                taskId: task.id,
+                field: "assertions",
+                message: "No llm-rubric assertion found. Tasks should have at least one scored rubric for meaningful evaluation.",
+            });
+        }
+        // Check prompt text exists
+        if (!task.prompt?.text) {
+            warnings.push({
+                taskId: task.id,
+                field: "prompt.text",
+                message: "No task prompt found in prompt.text. The LLM will receive an empty implementation request.",
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Format validation results for console output.
  */
-export { detectSnakeCaseFields, formatValidationResult, validateRepoTasks, } from "../../_vendor/ailf-tasks/index.js";
+export function formatValidationResult(result) {
+    const lines = [];
+    if (result.errors.length > 0) {
+        lines.push("Errors:");
+        for (const e of result.errors) {
+            lines.push(`  [${e.taskId}] ${e.field}: ${e.message}`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        lines.push("Warnings:");
+        for (const w of result.warnings) {
+            lines.push(`  [${w.taskId}] ${w.field}: ${w.message}`);
+        }
+    }
+    if (result.valid && result.warnings.length === 0) {
+        lines.push("All tasks pass validation");
+    }
+    return lines.join("\n");
+}

package/dist/adapters/task-sources/task-file-loader.d.ts

@@ -0,0 +1,64 @@
+/**
+ * TaskFileLoader — loads task definitions from TypeScript files.
+ *
+ * Supplements the existing YAML-based task loading by supporting
+ * `*.task.ts` and `*.task.js` files in task directories. Files are
+ * loaded via jiti and expected to export GeneralizedTaskDefinition
+ * objects authored with `defineTask()`.
+ *
+ * TS task files export a single task or an array of tasks:
+ *
+ * ```typescript
+ * // single task
+ * import { defineTask } from "@sanity/ailf"
+ * export default defineTask({ id: "my-task", mode: "literacy", ... })
+ *
+ * // multiple tasks
+ * export default [
+ *   defineTask({ id: "task-1", mode: "literacy", ... }),
+ *   defineTask({ id: "task-2", mode: "literacy", ... }),
+ * ]
+ * ```
+ *
+ * The loader integrates into the existing RepoTaskSource adapter — TS
+ * task files are discovered alongside YAML files in the same directory.
+ *
+ * @see docs/design-docs/architecture-overhaul/typescript-configuration.md
+ */
+/** A raw task object loaded from a TS file (pre-validation) */
+export interface RawTsTask {
+    /** Source file path (for error messages) */
+    filePath: string;
+    /** The loaded task data (may be a single object or an array) */
+    tasks: unknown[];
+}
+/**
+ * Discover TS/JS task files in a directory.
+ *
+ * Looks for files matching `*.task.ts` or `*.task.js`.
+ *
+ * @param tasksDir - Absolute path to the tasks directory
+ * @returns Array of absolute file paths
+ */
+export declare function discoverTsTaskFiles(tasksDir: string): string[];
+/**
+ * Load task definitions from a single TS/JS task file.
+ *
+ * The file's default export can be:
+ * - A single task object → wrapped in an array
+ * - An array of task objects → used as-is
+ *
+ * Returns the raw task data without validation — the caller is
+ * responsible for running the result through Zod schemas.
+ *
+ * @param filePath - Absolute path to the .task.ts or .task.js file
+ * @returns The loaded task(s), or throws on load failure
+ */
+export declare function loadTsTaskFile(filePath: string): Promise<RawTsTask>;
+/**
+ * Load all TS task files from a directory.
+ *
+ * @param tasksDir - Absolute path to the tasks directory
+ * @returns Array of raw task data from all files
+ */
+export declare function loadAllTsTaskFiles(tasksDir: string): Promise<RawTsTask[]>;

package/dist/adapters/task-sources/task-file-loader.js

@@ -0,0 +1,83 @@
+/**
+ * TaskFileLoader — loads task definitions from TypeScript files.
+ *
+ * Supplements the existing YAML-based task loading by supporting
+ * `*.task.ts` and `*.task.js` files in task directories. Files are
+ * loaded via jiti and expected to export GeneralizedTaskDefinition
+ * objects authored with `defineTask()`.
+ *
+ * TS task files export a single task or an array of tasks:
+ *
+ * ```typescript
+ * // single task
+ * import { defineTask } from "@sanity/ailf"
+ * export default defineTask({ id: "my-task", mode: "literacy", ... })
+ *
+ * // multiple tasks
+ * export default [
+ *   defineTask({ id: "task-1", mode: "literacy", ... }),
+ *   defineTask({ id: "task-2", mode: "literacy", ... }),
+ * ]
+ * ```
+ *
+ * The loader integrates into the existing RepoTaskSource adapter — TS
+ * task files are discovered alongside YAML files in the same directory.
+ *
+ * @see docs/design-docs/architecture-overhaul/typescript-configuration.md
+ */
+import { existsSync, readdirSync } from "fs";
+import { resolve } from "path";
+import { loadTsConfig } from "../config-sources/ts-config-loader.js";
+/**
+ * Discover TS/JS task files in a directory.
+ *
+ * Looks for files matching `*.task.ts` or `*.task.js`.
+ *
+ * @param tasksDir - Absolute path to the tasks directory
+ * @returns Array of absolute file paths
+ */
+export function discoverTsTaskFiles(tasksDir) {
+    if (!existsSync(tasksDir))
+        return [];
+    return readdirSync(tasksDir)
+        .filter((f) => (f.endsWith(".task.ts") || f.endsWith(".task.js")) && !f.startsWith("."))
+        .sort()
+        .map((f) => resolve(tasksDir, f));
+}
+/**
+ * Load task definitions from a single TS/JS task file.
+ *
+ * The file's default export can be:
+ * - A single task object → wrapped in an array
+ * - An array of task objects → used as-is
+ *
+ * Returns the raw task data without validation — the caller is
+ * responsible for running the result through Zod schemas.
+ *
+ * @param filePath - Absolute path to the .task.ts or .task.js file
+ * @returns The loaded task(s), or throws on load failure
+ */
+export async function loadTsTaskFile(filePath) {
+    const result = await loadTsConfig(filePath);
+    if (!result.ok) {
+        throw new Error(result.error);
+    }
+    const value = result.value;
+    // Normalize: single object → array of one
+    const tasks = Array.isArray(value) ? value : [value];
+    return { filePath, tasks };
+}
+/**
+ * Load all TS task files from a directory.
+ *
+ * @param tasksDir - Absolute path to the tasks directory
+ * @returns Array of raw task data from all files
+ */
+export async function loadAllTsTaskFiles(tasksDir) {
+    const files = discoverTsTaskFiles(tasksDir);
+    const results = [];
+    for (const file of files) {
+        results.push(await loadTsTaskFile(file));
+    }
+    return results;
+}

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

@@ -2,17 +2,17 @@
  * Adapter: Load task definitions from tasks/*.yaml files.
  *
  * This adapter reads the raw YAML task definitions (before Promptfoo
- * expansion) and maps them to the canonical TaskDefinition type from
- * @sanity/ailf-core. It handles area filtering (filename stem) and
- * task ID filtering.
+ * expansion) and maps them to GeneralizedTaskDefinition
+ * (LiteracyTaskDefinition variant) from @sanity/ailf-core. It handles
+ * area filtering (filename stem) and task ID filtering.
  *
  * Unlike loadAndExpandTasks() — which produces Promptfoo-specific
  * ExpandedTestEntry objects — this adapter produces domain-level
- * TaskDefinition objects suitable for the pipeline orchestrator.
+ * GeneralizedTaskDefinition objects suitable for the pipeline orchestrator.
  */
-import type { FilterOptions, TaskDefinition, TaskSource } from "../../_vendor/ailf-core/index.d.ts";
+import type { FilterOptions, GeneralizedTaskDefinition, TaskSource } from "../../_vendor/ailf-core/index.d.ts";
 export declare class YamlTaskSource implements TaskSource {
     private readonly rootDir;
     constructor(rootDir: string);
-    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+    loadTasks(filter?: FilterOptions): Promise<GeneralizedTaskDefinition[]>;
 }

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

@@ -2,13 +2,13 @@
  * Adapter: Load task definitions from tasks/*.yaml files.
  *
  * This adapter reads the raw YAML task definitions (before Promptfoo
- * expansion) and maps them to the canonical TaskDefinition type from
- * @sanity/ailf-core. It handles area filtering (filename stem) and
- * task ID filtering.
+ * expansion) and maps them to GeneralizedTaskDefinition
+ * (LiteracyTaskDefinition variant) from @sanity/ailf-core. It handles
+ * area filtering (filename stem) and task ID filtering.
  *
  * Unlike loadAndExpandTasks() — which produces Promptfoo-specific
  * ExpandedTestEntry objects — this adapter produces domain-level
- * TaskDefinition objects suitable for the pipeline orchestrator.
+ * GeneralizedTaskDefinition objects suitable for the pipeline orchestrator.
  */
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { resolve } from "path";
@@ -55,7 +55,7 @@ export class YamlTaskSource {
                     !filter.taskIds.includes(entry.id)) {
                     continue;
                 }
-                definitions.push(mapToTaskDefinition(entry, featureArea));
+                definitions.push(mapToLiteracyTask(entry, featureArea));
             }
         }
         return definitions;
@@ -65,29 +65,32 @@ export class YamlTaskSource {
 // Mapping helpers
 // ---------------------------------------------------------------------------
 /**
- * Map a raw YAML entry to a canonical TaskDefinition.
+ * Map a raw YAML entry directly to a LiteracyTaskDefinition.
  *
- * Renames snake_case YAML keys to camelCase domain types and extracts
- * the task prompt from `vars.task`. Additional vars beyond `task` and
- * `docs` are collected into `extraVars`.
+ * Renames snake_case YAML keys to the generalized type's field names and
+ * extracts the task prompt from `vars.task`. Additional vars beyond `task`
+ * and `docs` are collected into `prompt.vars`.
  */
-function mapToTaskDefinition(raw, featureArea) {
+function mapToLiteracyTask(raw, featureArea) {
     const { task, docs: _docs, ...rest } = (raw.vars ?? {});
-    const canonicalDocs = (raw.canonical_docs ?? [])
+    const docs = (raw.canonical_docs ?? [])
         .map(mapCanonicalDoc)
         .filter((d) => d !== null);
     const extraVars = Object.keys(rest).length > 0 ? rest : undefined;
     return {
+        mode: "literacy",
         id: raw.id,
-        description: raw.description,
-        featureArea,
-        taskPrompt: typeof task === "string" ? task : "",
-        canonicalDocs,
+        title: raw.description,
+        area: featureArea,
+        prompt: {
+            text: typeof task === "string" ? task : "",
+            ...(extraVars ? { vars: extraVars } : {}),
+        },
+        context: { docs },
         referenceSolution: raw.reference_solution ?? "",
         docCoverage: raw.doc_coverage ?? false,
         assertions: (raw.assert ?? []),
         ...(raw.baseline ? { baseline: raw.baseline } : {}),
-        ...(extraVars ? { extraVars } : {}),
     };
 }
 // ---------------------------------------------------------------------------

package/dist/cli.js

@@ -157,8 +157,6 @@ import { createValidateTasksCommand } from "./commands/validate-tasks.js";
 program.addCommand(createValidateTasksCommand().helpGroup(CommandGroup.SetupConfig));
 import { createFetchDocsCommand } from "./commands/fetch-docs.js";
 program.addCommand(createFetchDocsCommand().helpGroup(CommandGroup.SetupConfig));
-import { createGenerateConfigsCommand } from "./commands/generate-configs.js";
-program.addCommand(createGenerateConfigsCommand().helpGroup(CommandGroup.SetupConfig));
 import { createCacheCommand } from "./commands/cache.js";
 program.addCommand(createCacheCommand().helpGroup(CommandGroup.SetupConfig));
 // ── Pipeline Internals ────────────────────────────────────────────────

package/dist/commands/baseline.js

@@ -11,8 +11,11 @@ import { Command } from "commander";
 import { compareBaseline, listBaselines, saveBaseline, } from "../pipeline/baseline.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, "../..");
+// CLI command name — kept as a constant to centralize the string literal.
+// "baseline" here refers to score baseline snapshots, not the legacy eval mode.
+const CMD_NAME = "baseline";
 export function createBaselineCommand() {
-    const cmd = new Command("baseline").description("Manage historical baseline snapshots of evaluation scores");
+    const cmd = new Command(CMD_NAME).description("Manage historical baseline snapshots of evaluation scores");
     // -----------------------------------------------------------------------
     // baseline save
     // -----------------------------------------------------------------------

package/dist/commands/calculate-scores.js

@@ -20,7 +20,7 @@ export function createCalculateScoresCommand() {
         try {
             const ctx = createAppContext({
                 rootDir: ROOT,
-                mode: "baseline",
+                mode: "literacy",
                 noAutoScope: false,
                 skipFetch: true,
                 skipEval: true,

package/dist/commands/coverage-audit.js

@@ -3,10 +3,13 @@
  * against task files to produce a documentation coverage audit.
  *
  */
+import { InMemoryPluginRegistry } from "../_vendor/ailf-core/index.js";
 import { Command } from "commander";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { countReferencedDocs, formatCoverageConsole, formatCoverageMarkdown, runCoverageAudit, } from "../pipeline/coverage-audit.js";
+import { createLiteracyModeBase } from "../pipeline/compiler/mode-bases/index.js";
+import { createSanityLiteracyPreset } from "../pipeline/compiler/presets/index.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, "..", "..");
 export function createCoverageAuditCommand() {
@@ -15,7 +18,12 @@ export function createCoverageAuditCommand() {
         .option("--format <fmt>", "Output format: table, md, markdown")
         .option("--json", "Output raw JSON", false)
         .action(async (opts) => {
-        const report = runCoverageAudit(ROOT);
+        // Build a registry with mode base + preset so coverage audit works
+        // even when config/features.ts is empty (preset is source of truth).
+        const registry = new InMemoryPluginRegistry();
+        registry.registerModeBase(createLiteracyModeBase());
+        registry.registerPreset(createSanityLiteracyPreset({ rootDir: ROOT }));
+        const report = runCoverageAudit(ROOT, { registry });
         if (!report) {
             console.error("❌ Coverage audit failed. Ensure config/features.yaml exists and is valid.");
             process.exit(1);

package/dist/commands/explain-handler.js

@@ -23,6 +23,7 @@ import { TASK_FILE_NAMES } from "../_vendor/ailf-core/index.js";
 import { buildPipelinePlan, buildSimpleCommandPlan, } from "../pipeline/plan.js";
 import { formatPlanConsole, formatPlanJson } from "../pipeline/plan-format.js";
 import { computeResolvedOptions } from "./pipeline-action.js";
+import { LiteracyVariant } from "../pipeline/normalize-mode.js";
 // ---------------------------------------------------------------------------
 // Registry
 // ---------------------------------------------------------------------------
@@ -84,8 +85,8 @@ const EXPLAIN_REGISTRY = {
         filesCreated: ["results/latest/score-summary.json"],
         filesRead: [
             "results/latest/eval-results.json",
-            "config/rubrics.yaml",
-            "config/models.yaml",
+            "config/rubrics.ts",
+            "config/models.ts",
         ],
         steps: [
             {
@@ -138,12 +139,12 @@ const EXPLAIN_REGISTRY = {
     },
     "coverage-audit": {
         description: "Cross-reference feature registry against evaluation tasks for coverage gaps",
-        filesRead: ["config/features.yaml", "tasks/*.yaml"],
+        filesRead: ["config/features.ts", "tasks/*.{yaml,task.ts,task.js}"],
         steps: [
             {
                 cacheStatus: "miss",
                 name: "Load feature registry",
-                reason: "Parse config/features.yaml for product feature list",
+                reason: "Parse config/features.ts for product feature list",
                 willRun: true,
             },
             {
@@ -201,7 +202,7 @@ const EXPLAIN_REGISTRY = {
     "fetch-docs": {
         description: "Fetch documentation from Sanity CMS and generate canonical context files",
         filesCreated: ["contexts/canonical/*.md"],
-        filesRead: ["config/sources.yaml", "config/models.yaml"],
+        filesRead: ["config/sources.ts", "config/models.ts"],
         steps: [
             {
                 cacheStatus: "miss",
@@ -224,7 +225,7 @@ const EXPLAIN_REGISTRY = {
         ],
     },
     "generate-configs": {
-        description: "Generate Promptfoo config files from models.yaml and task definitions",
+        description: "Generate Promptfoo config files from models.ts and task definitions",
         filesCreated: [
             "promptfooconfig.yaml",
             "promptfooconfig.observed.yaml",
@@ -232,16 +233,16 @@ const EXPLAIN_REGISTRY = {
             "tasks/.expanded.yaml",
         ],
         filesRead: [
-            "config/models.yaml",
-            "config/prompts.yaml",
-            "config/rubrics.yaml",
-            "config/sources.yaml",
+            "config/models.ts",
+            "config/prompts.ts",
+            "config/rubrics.ts",
+            "config/sources.ts",
         ],
         steps: [
             {
                 cacheStatus: "miss",
                 name: "Load models",
-                reason: "Parse config/models.yaml for active model list",
+                reason: "Parse config/models.ts for active model list",
                 willRun: true,
             },
             {
@@ -262,7 +263,7 @@ const EXPLAIN_REGISTRY = {
         description: "Grader reliability tools (consistency, compare, sensitivity, validate)",
         filesRead: [
             "results/latest/eval-results.json",
-            "config/rubrics.yaml",
+            "config/rubrics.ts",
             "canonical/reference-solutions/",
         ],
         steps: [
@@ -369,7 +370,7 @@ const EXPLAIN_REGISTRY = {
         filesRead: [
             "results/latest/score-summary.json",
             "results/latest/gap-analysis.json",
-            "config/thresholds.yaml",
+            "config/thresholds.ts",
             "results/baselines/",
         ],
         filesCreated: ["results/latest/readiness-report.md"],
@@ -377,7 +378,7 @@ const EXPLAIN_REGISTRY = {
             {
                 cacheStatus: "miss",
                 name: "Load scores + thresholds",
-                reason: "Read score-summary.json and thresholds.yaml for gate evaluation",
+                reason: "Read score-summary.json and thresholds.ts for gate evaluation",
                 willRun: true,
             },
             {
@@ -395,18 +396,18 @@ const EXPLAIN_REGISTRY = {
         ],
     },
     validate: {
-        description: "Validate all YAML config files, task definitions, reference solutions, and environment",
+        description: "Validate all config files, task definitions, reference solutions, and environment",
         filesRead: [
-            "config/models.yaml",
-            "config/rubrics.yaml",
-            "config/features.yaml",
-            "config/thresholds.yaml",
+            "config/models.ts",
+            "config/rubrics.ts",
+            "config/features.ts",
+            "config/thresholds.ts",
         ],
         steps: [
             {
                 cacheStatus: "miss",
                 name: "Validate configuration",
-                reason: "Parse all YAML configs through Zod schemas, cross-reference mappings",
+                reason: "Parse all config files through Zod schemas, cross-reference mappings",
                 willRun: true,
             },
             {
@@ -454,12 +455,12 @@ const EXPLAIN_REGISTRY = {
     },
     "weekly-digest": {
         description: "Generate and deliver a weekly evaluation trend digest via Slack",
-        filesRead: ["config/schedules.yaml", "config/sinks.yaml"],
+        filesRead: ["config/schedules.ts", "config/sinks.ts"],
         steps: [
             {
                 cacheStatus: "miss",
                 name: "Load digest config",
-                reason: "Read schedules.yaml for lookback window and delivery targets",
+                reason: "Read schedules.ts for lookback window and delivery targets",
                 willRun: true,
             },
             {
@@ -670,7 +671,7 @@ async function buildPipelineExplainPlan(actionCommand, rootDir) {
         graderReplications: raw.graderReplications,
         header: raw.header ?? [],
         headers: raw.headers ?? [],
-        mode: raw.mode ?? "full",
+        mode: raw.mode ?? LiteracyVariant.FULL,
         output: raw.output,
         promptfooUrl: raw.promptfooUrl,
         publish: raw.publish,
@@ -714,6 +715,7 @@ async function buildPipelineExplainPlan(actionCommand, rootDir) {
         gapAnalysisEnabled: resolved.gapAnalysisEnabled,
         graderReplications: resolved.graderReplications,
         mode: resolved.mode,
+        variant: resolved.variant,
         noCache: resolved.noCache,
         publishEnabled: resolved.publishEnabled,
         readinessEnabled: resolved.readinessEnabled,

package/dist/commands/fetch-docs.js

@@ -41,7 +41,7 @@ async function executeFetchDocs(opts) {
     // Build a minimal ResolvedConfig for the composition root
     const ctx = createAppContext({
         rootDir: ROOT,
-        mode: "baseline",
+        mode: "literacy",
         noAutoScope: false,
         skipFetch: false,
         skipEval: true,
@@ -83,7 +83,8 @@ async function executeFetchDocs(opts) {
     }
     // Canonical contexts — same code path as the pipeline
     const tasks = await ctx.taskSource.loadTasks();
-    const tasksWithDocs = tasks.filter((t) => t.canonicalDocs.length > 0);
+    // Bridge: narrow to literacy tasks with docs (only literacy tasks have context.docs)
+    const tasksWithDocs = tasks.filter((t) => t.mode === "literacy" && (t.context?.docs?.length ?? 0) > 0);
     if (tasksWithDocs.length > 0) {
         console.log("\nGenerating canonical (gold-retrieval) contexts...\n");
         const result = await fetcher.fetch(tasksWithDocs, resolvedSource);

package/dist/commands/generate-configs.js

@@ -19,7 +19,7 @@ export function createGenerateConfigsCommand() {
         try {
             const ctx = createAppContext({
                 rootDir: ROOT,
-                mode: "baseline",
+                mode: "literacy",
                 noAutoScope: false,
                 skipFetch: true,
                 skipEval: true,

package/dist/commands/init.d.ts

@@ -5,12 +5,14 @@
  * task files. The generated files are ready-to-edit starting points —
  * not live evaluation tasks.
  *
- * YAML output (default) preserves the inline comments from the source
- * YAML files in packages/core/examples/. JSON output is a plain
- * serialization of the parsed data — no comments.
+ * TypeScript output (default) uses define* helpers from @sanity/ailf-core
+ * for full IDE autocomplete and type checking. YAML output preserves
+ * inline comments from the source files. JSON output is a plain
+ * serialization of the parsed data.
  *
  * Usage:
- *   ailf init                        # YAML output (default)
+ *   ailf init                        # TypeScript output (default)
+ *   ailf init --output-format yaml   # YAML output
  *   ailf init --output-format json   # JSON output
  *   ailf init --force                # overwrite existing files
  *   ailf init --path ./my-dir        # target a specific directory