@sanity/ailf 0.4.1 → 1.0.0

package/dist/adapters/task-sources/content-lake-task-source.js

@@ -1,10 +1,11 @@
 /**
  * Adapter: Load task definitions from the Sanity Content Lake.
  *
- * Fetches ailf.task documents via GROQ and maps them to the canonical
- * TaskDefinition type. This adapter is the Content Lake counterpart of
- * YamlTaskSource — both produce identical TaskDefinition[] for the same
- * logical tasks. The pipeline never knows which adapter loaded the tasks.
+ * Fetches ailf.task documents via GROQ and maps them to
+ * GeneralizedTaskDefinition (LiteracyTaskDefinition variant). This
+ * adapter is the Content Lake counterpart of YamlTaskSource — both
+ * produce identical GeneralizedTaskDefinition[] for the same logical
+ * tasks. The pipeline never knows which adapter loaded the tasks.
  *
  * Wired in the composition root when --task-source content-lake is set.
  *
@@ -16,7 +17,7 @@
 // ---------------------------------------------------------------------------
 /**
  * GROQ query that projects ailf.task documents into a shape suitable for
- * mapping to TaskDefinition.
+ * mapping to LiteracyTaskDefinition.
  *
  * Key projections:
  * - featureArea reference → dereferenced areaId string
@@ -79,7 +80,7 @@ export class ContentLakeTaskSource {
         }
         const definitions = [];
         for (const entry of raw) {
-            const mapped = mapToTaskDefinition(entry);
+            const mapped = mapToLiteracyTask(entry);
             if (!mapped)
                 continue;
             definitions.push(mapped);
@@ -105,17 +106,17 @@ function buildGroqParams(filter) {
     };
 }
 // ---------------------------------------------------------------------------
-// Mapping: Content Lake → TaskDefinition
+// Mapping: Content Lake → LiteracyTaskDefinition
 // ---------------------------------------------------------------------------
 /**
- * Map a Content Lake ailf.task document to the canonical TaskDefinition.
+ * Map a Content Lake ailf.task document directly to a LiteracyTaskDefinition.
  *
  * Returns null if the document is missing required fields (taskId,
  * description, featureAreaId, taskPrompt). These are required by the
  * Studio schema, but defensive coding handles edge cases (drafts,
  * partially-created documents, etc.).
  */
-function mapToTaskDefinition(raw) {
+function mapToLiteracyTask(raw) {
     // Required fields — skip malformed documents
     if (!raw.taskId ||
         !raw.description ||
@@ -123,17 +124,14 @@ function mapToTaskDefinition(raw) {
         !raw.taskPrompt) {
         return null;
     }
-    const canonicalDocs = (raw.canonicalDocs ?? [])
+    const docs = (raw.canonicalDocs ?? [])
         .map(mapCanonicalDocRef)
         .filter((d) => d !== null);
     const assertions = mapAssertions(raw.assert ?? []);
     // Append raw pass-through assertions (escape hatch for arbitrary Promptfoo
     // assertion types that aren't in the curated list). These bypass template
     // resolution and flow directly into the expanded Promptfoo test case as
-    // value-based assertions. In baseline mode, buildBaselineAsserts() with
-    // "abbreviated" (the default) drops non-rubric assertions, so rawAssert
-    // entries only run in the gold variant — consistent with how regular
-    // value-based assertions like `contains` or `regex` behave.
+    // value-based assertions.
     const rawAssertions = (raw.rawAssert ?? [])
         .filter((a) => !!a.type)
         .map((a) => ({
@@ -141,7 +139,10 @@ function mapToTaskDefinition(raw) {
         ...(a.value !== undefined ? { value: a.value } : {}),
         ...(a.threshold !== undefined ? { threshold: a.threshold } : {}),
     }));
-    const allAssertions = [...assertions, ...rawAssertions];
+    const allAssertions = [
+        ...assertions,
+        ...rawAssertions,
+    ];
     const baseline = raw.baseline
         ? {
             ...(raw.baseline.enabled !== undefined
@@ -155,19 +156,17 @@ function mapToTaskDefinition(raw) {
         }
         : undefined;
     return {
+        mode: "literacy",
+        id: raw.taskId,
+        title: raw.description,
+        area: raw.featureAreaId,
+        prompt: { text: raw.taskPrompt },
+        context: { docs },
         assertions: allAssertions,
-        canonicalDocs,
-        description: raw.description,
         docCoverage: raw.docCoverage ?? false,
-        featureArea: raw.featureAreaId,
-        id: raw.taskId,
         // Reference solution path is not meaningful for CL tasks — the solution
         // content lives in the Content Lake document, not on the filesystem.
-        // Downstream consumers that need the solution content will need to fetch
-        // it via the referenceSolution reference. For now, use empty string
-        // (same as tasks without a reference solution).
         referenceSolution: "",
-        taskPrompt: raw.taskPrompt,
         ...(baseline ? { baseline } : {}),
         ...(raw.tags?.length ? { tags: raw.tags } : {}),
     };

package/dist/adapters/task-sources/index.d.ts

@@ -4,4 +4,5 @@ export { parseRepoConfig, parseRepoTaskFile, RepoConfigSchema, RepoTaskSchema, C
 export { RepoTaskSource } from "./repo-task-source.js";
 export { detectTriggerContext, resolveTrigger, type ResolvedTrigger, type TriggerContext, } from "./repo-trigger.js";
 export { formatValidationResult, validateRepoTasks, type ValidationMessage, type ValidationResult, } from "./repo-validation.js";
+export { discoverTsTaskFiles, loadAllTsTaskFiles, loadTsTaskFile, } from "./task-file-loader.js";
 export { YamlTaskSource } from "./yaml-task-source.js";

package/dist/adapters/task-sources/index.js

@@ -4,4 +4,5 @@ export { parseRepoConfig, parseRepoTaskFile, RepoConfigSchema, RepoTaskSchema, C
 export { RepoTaskSource } from "./repo-task-source.js";
 export { detectTriggerContext, resolveTrigger, } from "./repo-trigger.js";
 export { formatValidationResult, validateRepoTasks, } from "./repo-validation.js";
+export { discoverTsTaskFiles, loadAllTsTaskFiles, loadTsTaskFile, } from "./task-file-loader.js";
 export { YamlTaskSource } from "./yaml-task-source.js";

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

@@ -3,8 +3,8 @@
  *
  * 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.
+ * mapping to LiteracyTaskDefinition 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)
@@ -14,9 +14,9 @@
  * @see packages/core/src/ports/task-source.ts — TaskSource port
  * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
  */
-import type { FilterOptions, TaskDefinition, TaskSource } from "../../_vendor/ailf-core/index.d.ts";
+import type { FilterOptions, GeneralizedTaskDefinition, 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[]>;
+    loadTasks(filter?: FilterOptions): Promise<GeneralizedTaskDefinition[]>;
 }

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

@@ -3,8 +3,8 @@
  *
  * 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.
+ * mapping to LiteracyTaskDefinition 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)
@@ -18,6 +18,7 @@ import { existsSync, readdirSync, readFileSync } from "fs";
 import { resolve } from "path";
 import { load } from "js-yaml";
 import { parseRepoTaskFile } from "./repo-schemas.js";
+import { discoverTsTaskFiles, loadTsTaskFile } from "./task-file-loader.js";
 // ---------------------------------------------------------------------------
 // RepoTaskSource adapter
 // ---------------------------------------------------------------------------
@@ -34,9 +35,10 @@ export class RepoTaskSource {
         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 tsFiles = discoverTsTaskFiles(this.tasksDir);
+        if (yamlFiles.length === 0 && tsFiles.length === 0) {
+            throw new Error(`No task files found in ${this.tasksDir}\n` +
+                "  Expected .ailf/tasks/*.yaml or .ailf/tasks/*.task.ts files");
         }
         const definitions = [];
         for (const file of yamlFiles) {
@@ -99,7 +101,56 @@ export class RepoTaskSource {
                     (!entry.tags || !entry.tags.some((t) => filter.tags.includes(t)))) {
                     continue;
                 }
-                definitions.push(mapToTaskDefinition(entry));
+                definitions.push(mapToLiteracyTask(entry));
+            }
+        }
+        // Load TS task files (.task.ts / .task.js)
+        for (const tsFile of tsFiles) {
+            const loaded = await loadTsTaskFile(tsFile);
+            const filename = tsFile.split("/").pop() ?? tsFile;
+            // Validate through the same schema as YAML tasks
+            let validated;
+            try {
+                validated = parseRepoTaskFile(loaded.tasks, filename);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                throw new Error(`Failed to validate ${filename}:\n${msg}`, {
+                    cause: err,
+                });
+            }
+            for (const entry of validated) {
+                // Apply the same filtering as YAML tasks
+                if (filter?.areas &&
+                    filter.areas.length > 0 &&
+                    !filter.areas
+                        .map((a) => a.toLowerCase())
+                        .includes(entry.featureArea.toLowerCase())) {
+                    continue;
+                }
+                if (filter?.taskIds &&
+                    filter.taskIds.length > 0 &&
+                    !filter.taskIds.includes(entry.id)) {
+                    continue;
+                }
+                const effectiveStatus = entry.status ??
+                    (entry.execution?.enabled === false ? "paused" : "active");
+                const isTargetedById = filter?.taskIds && filter.taskIds.includes(entry.id);
+                if (effectiveStatus === "archived")
+                    continue;
+                if (effectiveStatus === "paused" && !isTargetedById)
+                    continue;
+                if (effectiveStatus === "draft" &&
+                    !isTargetedById &&
+                    !filter?.includeDrafts) {
+                    continue;
+                }
+                if (filter?.tags &&
+                    filter.tags.length > 0 &&
+                    (!entry.tags || !entry.tags.some((t) => filter.tags.includes(t)))) {
+                    continue;
+                }
+                definitions.push(mapToLiteracyTask(entry));
             }
         }
         return definitions;
@@ -108,26 +159,28 @@ export class RepoTaskSource {
 // ---------------------------------------------------------------------------
 // Mapping helpers
 // ---------------------------------------------------------------------------
-function mapToTaskDefinition(raw) {
+function mapToLiteracyTask(raw) {
     // Extract task prompt from vars.task (same convention as YAML tasks)
     const vars = (raw.vars ?? {});
     const { docs: _docs, task, ...rest } = vars;
     // Canonical docs are already parsed into the polymorphic union by Zod.
-    // Each entry has exactly one resolution key (slug, path, id, or perspective).
-    const canonicalDocs = (raw.canonicalDocs ??
+    const docs = (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,
+        mode: "literacy",
         id: raw.id,
+        title: raw.description,
+        area: raw.featureArea,
+        prompt: {
+            text: typeof task === "string" ? task : "",
+            ...(extraVars ? { vars: extraVars } : {}),
+        },
+        context: { docs },
+        assertions: (raw.assert ?? []),
         referenceSolution: raw.referenceSolution ?? "",
-        taskPrompt: typeof task === "string" ? task : "",
+        docCoverage: raw.docCoverage ?? false,
         ...(raw.baseline ? { baseline: raw.baseline } : {}),
-        ...(extraVars ? { extraVars } : {}),
         ...(raw.status && raw.status !== "active" ? { status: raw.status } : {}),
         ...(raw.tags?.length ? { tags: raw.tags } : {}),
     };

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 validated through the RepoTaskSchema from
+ * @sanity/ailf-tasks.
+ *
+ * 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 validated through the RepoTaskSchema from
+ * @sanity/ailf-tasks.
+ *
+ * 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,12 @@
  * 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 { createSanityLiteracyPreset } from "../pipeline/compiler/presets/index.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, "..", "..");
 export function createCoverageAuditCommand() {
@@ -15,7 +17,11 @@ 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 preset features so coverage audit works
+        // even when config/features.ts is empty (preset is source of truth).
+        const registry = new InMemoryPluginRegistry();
+        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);