@sanity/ailf 0.4.1 → 1.0.0

package/dist/_vendor/ailf-shared/eval-modes.d.ts

@@ -4,9 +4,41 @@
  * Shared between eval (pipeline orchestrator) and studio (GROQ filters, UI).
  * A new mode added here is immediately visible to both packages.
  */
-/** The evaluation modes supported by the pipeline */
-export type EvalMode = "agentic" | "baseline" | "full" | "observed";
-/** Concrete modes that map 1:1 to a Promptfoo config file */
-export type ConcreteEvalMode = Exclude<EvalMode, "full">;
-/** The sub-modes that compose a `full` evaluation run */
-export declare const FULL_MODE_SUBMODES: ConcreteEvalMode[];
+/**
+ * The evaluation modes supported by the pipeline.
+ *
+ * Canonical mode names identify the KIND of evaluation:
+ *   - `literacy` — documentation effectiveness (gold + baseline prompts)
+ *   - `knowledge-probe` — raw model knowledge without docs
+ *   - `mcp-server` — MCP server tool-call correctness
+ *   - `agent-harness` — sandboxed agent coding evaluation
+ *   - `custom` — user-provided handler
+ *
+ * Legacy variant names are accepted by the CLI for backward compatibility
+ * and normalized at the CLI boundary to `mode: "literacy"` + `variant`:
+ *   - `baseline` → `mode: "literacy", variant: "baseline"`
+ *   - `agentic`  → `mode: "literacy", variant: "agentic"`
+ *   - `observed` → `mode: "literacy", variant: "observed"`
+ *   - `full`     → `mode: "literacy", variant: "full"`
+ */
+export type EvalMode = "agent-harness" | "custom" | "knowledge-probe" | "literacy" | "mcp-server";
+/**
+ * Raw eval mode — includes both canonical and legacy names.
+ *
+ * This is the type that Zod schemas parse from user input (CLI, config, API).
+ * Values must pass through `normalizeMode()` before entering typed pipeline
+ * code that expects `EvalMode`.
+ */
+export type RawEvalMode = EvalMode | "agentic" | "baseline" | "full" | "observed";
+/**
+ * The 5 canonical evaluation modes.
+ * Single source of truth — normalizeMode() and Zod schemas derive from these.
+ */
+export declare const CANONICAL_EVAL_MODES: readonly ["literacy", "mcp-server", "agent-harness", "knowledge-probe", "custom"];
+/** Legacy CLI aliases that map to `mode: "literacy"` + variant. */
+export declare const LEGACY_EVAL_MODE_ALIASES: readonly ["baseline", "agentic", "observed", "full"];
+/**
+ * All accepted mode names for Zod enum construction.
+ * Canonical modes first, then legacy aliases.
+ */
+export declare const RAW_EVAL_MODES: readonly ["literacy", "mcp-server", "agent-harness", "knowledge-probe", "custom", "baseline", "agentic", "observed", "full"];

package/dist/_vendor/ailf-shared/eval-modes.js

@@ -4,5 +4,29 @@
  * Shared between eval (pipeline orchestrator) and studio (GROQ filters, UI).
  * A new mode added here is immediately visible to both packages.
  */
-/** The sub-modes that compose a `full` evaluation run */
-export const FULL_MODE_SUBMODES = ["baseline", "agentic"];
+/**
+ * The 5 canonical evaluation modes.
+ * Single source of truth — normalizeMode() and Zod schemas derive from these.
+ */
+export const CANONICAL_EVAL_MODES = [
+    "literacy",
+    "mcp-server",
+    "agent-harness",
+    "knowledge-probe",
+    "custom",
+];
+/** Legacy CLI aliases that map to `mode: "literacy"` + variant. */
+export const LEGACY_EVAL_MODE_ALIASES = [
+    "baseline",
+    "agentic",
+    "observed",
+    "full",
+];
+/**
+ * All accepted mode names for Zod enum construction.
+ * Canonical modes first, then legacy aliases.
+ */
+export const RAW_EVAL_MODES = [
+    ...CANONICAL_EVAL_MODES,
+    ...LEGACY_EVAL_MODE_ALIASES,
+];

package/dist/_vendor/ailf-shared/index.d.ts

@@ -13,4 +13,3 @@ export * from "./document-ref.js";
 export * from "./score-grades.js";
 export * from "./noise-threshold.js";
 export * from "./eval-modes.js";
-export * from "./dimension-names.js";

package/dist/_vendor/ailf-shared/index.js

@@ -13,4 +13,3 @@ export * from "./document-ref.js";
 export * from "./score-grades.js";
 export * from "./noise-threshold.js";
 export * from "./eval-modes.js";
-export * from "./dimension-names.js";

package/dist/adapters/api-client/build-request.js

@@ -15,6 +15,7 @@
 import { existsSync } from "fs";
 import { resolve } from "path";
 import { PipelineRequestSchema, } from "../../_vendor/ailf-core/index.js";
+import { LiteracyVariant } from "../../pipeline/normalize-mode.js";
 import { RepoTaskSource } from "../task-sources/repo-task-source.js";
 // ---------------------------------------------------------------------------
 // Public API
@@ -35,7 +36,7 @@ export async function buildRemoteRequest(options) {
     // 1. Load and validate local tasks
     const taskSource = new RepoTaskSource(tasksDir);
     const filterOptions = buildFilterOptions(config);
-    const tasks = await taskSource.loadTasks(filterOptions);
+    const tasks = (await taskSource.loadTasks(filterOptions)).filter((t) => t.mode === "literacy");
     if (tasks.length === 0) {
         throw new Error("No tasks found after applying filters.\n" +
             `  Tasks directory: ${tasksDir}\n` +
@@ -51,7 +52,7 @@ export async function buildRemoteRequest(options) {
         inlineTasks,
     };
     // Mode
-    if (config.mode && config.mode !== "full") {
+    if (config.mode && config.mode !== LiteracyVariant.FULL) {
         raw.mode = config.mode;
     }
     // Debug
@@ -144,25 +145,25 @@ export function resolveTasksDir(rootDir, explicitPath) {
 // Helpers
 // ---------------------------------------------------------------------------
 /**
- * Convert a TaskDefinition back to the camelCase inline format expected
- * by the API. This is essentially the inverse of RepoTaskSource's
- * `mapToTaskDefinition()`.
+ * Convert a LiteracyTaskDefinition to the camelCase inline format expected
+ * by the API.
  */
 function taskToInlineFormat(task) {
     const inline = {
         id: task.id,
-        description: task.description,
-        featureArea: task.featureArea,
-        assert: task.assertions,
+        description: task.title,
+        featureArea: task.area ?? "",
+        assert: task.assertions ?? [],
     };
-    if (task.canonicalDocs?.length) {
-        inline.canonicalDocs = task.canonicalDocs;
+    if (task.context?.docs?.length) {
+        inline.canonicalDocs = task.context.docs;
     }
-    if (task.taskPrompt) {
+    const taskPrompt = task.prompt?.text ?? "";
+    if (taskPrompt) {
         inline.vars = {
-            task: task.taskPrompt,
+            task: taskPrompt,
             docs: "",
-            ...(task.extraVars ?? {}),
+            ...(task.prompt?.vars ?? {}),
         };
     }
     if (task.docCoverage) {

package/dist/adapters/config-sources/file-config-adapter.d.ts

@@ -1,26 +1,35 @@
 /**
- * FileConfigAdapter — resolves pipeline config from a local JSON/YAML file.
+ * FileConfigAdapter — resolves pipeline config from a local config file.
  *
- * Enables `ailf pipeline --config config.json` to load all pipeline
- * options from a file instead of CLI flags. Supports two schemas:
+ * Enables `ailf pipeline --config <path>` to load all pipeline options
+ * from a file instead of CLI flags. Supports multiple formats in
+ * priority order:
  *
- * 1. PipelineRequestSchema (JSON) — the universal API contract.
- *    Used by: API gateway payloads, GitHub Actions dispatch.
- *    Tried first for .json files.
+ * 1. TypeScript (.ts) — loaded via jiti, validated through Zod
+ * 2. JavaScript (.js) — loaded via jiti, validated through Zod
+ * 3. YAML (.yaml/.yml) — parsed via js-yaml, validated through Zod
+ * 4. JSON (.json) — parsed via JSON.parse, tries PipelineRequestSchema
+ *    first (API contract), then EvalConfigSchema (developer config)
  *
- * 2. EvalConfigSchema (JSON/YAML) — the developer-facing config.
- *    Used by: local config files, manual --config usage.
- *    Fallback for .json files; primary for .yaml/.yml files.
+ * Schemas:
+ * - PipelineRequestSchema (JSON only) — the universal API contract.
+ *   Used by: API gateway payloads, GitHub Actions dispatch.
+ * - EvalConfigSchema (all formats) — the developer-facing config.
+ *   Used by: local config files, manual --config usage.
  *
  * @see packages/core/src/schemas/pipeline-request.ts — PipelineRequestSchema
  * @see packages/core/src/schemas/eval-config.ts — EvalConfigSchema
+ * @see docs/design-docs/architecture-overhaul/typescript-configuration.md
  */
-import { type ResolvedConfig } from "../../_vendor/ailf-core/index.d.ts";
-import type { ConfigSource } from "../../_vendor/ailf-core/index.d.ts";
+import { type ConfigSource, type ResolvedConfig } from "../../_vendor/ailf-core/index.d.ts";
 export declare class FileConfigAdapter implements ConfigSource {
     private readonly filePath;
     private readonly rootDir;
     readonly label: string;
     constructor(filePath: string, rootDir: string);
     resolve(): Promise<ResolvedConfig>;
+    /**
+     * Validate the raw config object through Zod and map to ResolvedConfig.
+     */
+    private validateAndMap;
 }

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

@@ -1,24 +1,32 @@
 /**
- * FileConfigAdapter — resolves pipeline config from a local JSON/YAML file.
+ * FileConfigAdapter — resolves pipeline config from a local config file.
  *
- * Enables `ailf pipeline --config config.json` to load all pipeline
- * options from a file instead of CLI flags. Supports two schemas:
+ * Enables `ailf pipeline --config <path>` to load all pipeline options
+ * from a file instead of CLI flags. Supports multiple formats in
+ * priority order:
  *
- * 1. PipelineRequestSchema (JSON) — the universal API contract.
- *    Used by: API gateway payloads, GitHub Actions dispatch.
- *    Tried first for .json files.
+ * 1. TypeScript (.ts) — loaded via jiti, validated through Zod
+ * 2. JavaScript (.js) — loaded via jiti, validated through Zod
+ * 3. YAML (.yaml/.yml) — parsed via js-yaml, validated through Zod
+ * 4. JSON (.json) — parsed via JSON.parse, tries PipelineRequestSchema
+ *    first (API contract), then EvalConfigSchema (developer config)
  *
- * 2. EvalConfigSchema (JSON/YAML) — the developer-facing config.
- *    Used by: local config files, manual --config usage.
- *    Fallback for .json files; primary for .yaml/.yml files.
+ * Schemas:
+ * - PipelineRequestSchema (JSON only) — the universal API contract.
+ *   Used by: API gateway payloads, GitHub Actions dispatch.
+ * - EvalConfigSchema (all formats) — the developer-facing config.
+ *   Used by: local config files, manual --config usage.
  *
  * @see packages/core/src/schemas/pipeline-request.ts — PipelineRequestSchema
  * @see packages/core/src/schemas/eval-config.ts — EvalConfigSchema
+ * @see docs/design-docs/architecture-overhaul/typescript-configuration.md
  */
 import { readFileSync } from "fs";
 import { extname } from "path";
 import { EvalConfigSchema, PipelineRequestSchema, } from "../../_vendor/ailf-core/index.js";
 import { mapRequestToConfig } from "../../pipeline/map-request-to-config.js";
+import { normalizeMode } from "../../pipeline/normalize-mode.js";
+import { loadTsConfig } from "./ts-config-loader.js";
 export class FileConfigAdapter {
     filePath;
     rootDir;
@@ -29,8 +37,23 @@ export class FileConfigAdapter {
         this.label = `config file: ${filePath}`;
     }
     async resolve() {
-        const raw = readConfigFile(this.filePath);
         const ext = extname(this.filePath).toLowerCase();
+        // TypeScript / JavaScript files — load via jiti
+        if (ext === ".ts" || ext === ".js") {
+            const result = await loadTsConfig(this.filePath);
+            if (!result.ok) {
+                throw new Error(result.error);
+            }
+            return this.validateAndMap(result.value, ext);
+        }
+        // YAML / JSON files — load via fs
+        const raw = readConfigFile(this.filePath);
+        return this.validateAndMap(raw, ext);
+    }
+    /**
+     * Validate the raw config object through Zod and map to ResolvedConfig.
+     */
+    validateAndMap(raw, ext) {
         // For JSON files, try PipelineRequestSchema first (API contract)
         if (ext === ".json") {
             const pipelineResult = PipelineRequestSchema.safeParse(raw);
@@ -38,7 +61,7 @@ export class FileConfigAdapter {
                 return mapRequestToConfig(pipelineResult.data, this.rootDir);
             }
         }
-        // Fall back to EvalConfigSchema (developer config)
+        // Fall back to EvalConfigSchema (developer config) — works for all formats
         const validated = EvalConfigSchema.parse(raw);
         return mapEvalConfigToResolvedConfig(validated, this.rootDir);
     }
@@ -66,9 +89,12 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
     else if (typeof config.debug === "object") {
         debug = { enabled: config.debug.enabled ?? true, ...config.debug };
     }
+    // Normalize legacy mode names (e.g., "full" → literacy + variant)
+    const normalized = normalizeMode(config.mode ?? "literacy");
     return {
         rootDir,
-        mode: config.mode ?? "full",
+        mode: normalized.mode,
+        variant: normalized.variant,
         noAutoScope: config.noAutoScope ?? false,
         debug,
         areas: config.areas,

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

@@ -1,2 +1,4 @@
 export { CliConfigAdapter } from "./cli-config-adapter.js";
 export { FileConfigAdapter } from "./file-config-adapter.js";
+export { checkFormatConflict, loadTsConfig, resolveConfigPath, } from "./ts-config-loader.js";
+export type { TsLoadResult } from "./ts-config-loader.js";

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

@@ -1,2 +1,3 @@
 export { CliConfigAdapter } from "./cli-config-adapter.js";
 export { FileConfigAdapter } from "./file-config-adapter.js";
+export { checkFormatConflict, loadTsConfig, resolveConfigPath, } from "./ts-config-loader.js";

package/dist/adapters/config-sources/ts-config-loader.d.ts

@@ -0,0 +1,59 @@
+/**
+ * TsConfigLoader — loads TypeScript/JavaScript configuration files via jiti.
+ *
+ * Provides the runtime loading layer for TypeScript configuration files
+ * (ailf.config.ts, config/models.ts, tasks/*.task.ts, etc.). Uses `jiti`
+ * for zero-config TypeScript import with ESM/CJS support.
+ *
+ * The loader:
+ * 1. Imports the file via jiti (strips types, handles ESM interop)
+ * 2. Extracts the default export
+ * 3. Returns the raw object — validation is the caller's responsibility
+ *
+ * @see docs/design-docs/architecture-overhaul/typescript-configuration.md
+ */
+/**
+ * Result of a TS config load attempt.
+ *
+ * - `ok: true` — file loaded successfully; `value` is the default export.
+ * - `ok: false` — file not found or load failed; `error` describes what
+ *   happened.
+ */
+export type TsLoadResult<T = unknown> = {
+    ok: true;
+    value: T;
+    path: string;
+} | {
+    ok: false;
+    error: string;
+    path: string;
+};
+/**
+ * Load a TypeScript or JavaScript config file and return its default export.
+ *
+ * Does NOT validate the result — the caller is responsible for passing
+ * the returned value through the appropriate Zod schema.
+ *
+ * @param filePath - Absolute path to the .ts or .js file
+ * @returns The default export of the file, or an error
+ */
+export declare function loadTsConfig<T = unknown>(filePath: string): Promise<TsLoadResult<T>>;
+/**
+ * Resolve a config file path with the TS > JS > YAML > JSON priority chain.
+ *
+ * Given a base path without extension (e.g., `"/path/to/config/models"`),
+ * returns the first existing file in priority order, or null if none exist.
+ *
+ * @param basePath - Path without extension
+ * @returns The resolved path with extension, or null
+ */
+export declare function resolveConfigPath(basePath: string): {
+    path: string;
+    format: "json" | "ts" | "yaml";
+} | null;
+/**
+ * Check if a higher-priority TS/JS file exists alongside a YAML/JSON file.
+ *
+ * Returns a warning message if both exist, or null if no conflict.
+ */
+export declare function checkFormatConflict(basePath: string, activeFormat: "json" | "ts" | "yaml"): string | null;

package/dist/adapters/config-sources/ts-config-loader.js

@@ -0,0 +1,133 @@
+/**
+ * TsConfigLoader — loads TypeScript/JavaScript configuration files via jiti.
+ *
+ * Provides the runtime loading layer for TypeScript configuration files
+ * (ailf.config.ts, config/models.ts, tasks/*.task.ts, etc.). Uses `jiti`
+ * for zero-config TypeScript import with ESM/CJS support.
+ *
+ * The loader:
+ * 1. Imports the file via jiti (strips types, handles ESM interop)
+ * 2. Extracts the default export
+ * 3. Returns the raw object — validation is the caller's responsibility
+ *
+ * @see docs/design-docs/architecture-overhaul/typescript-configuration.md
+ */
+import { existsSync } from "fs";
+import { createJiti } from "jiti";
+// ---------------------------------------------------------------------------
+// Singleton jiti instance — reused across all loads for caching
+// ---------------------------------------------------------------------------
+let _jiti = null;
+function getJiti() {
+    if (!_jiti) {
+        _jiti = createJiti(import.meta.url, {
+            // Interop: handle both `export default` and `module.exports`
+            interopDefault: true,
+            // Don't require file extensions in imports
+            requireCache: true,
+        });
+    }
+    return _jiti;
+}
+/**
+ * Load a TypeScript or JavaScript config file and return its default export.
+ *
+ * Does NOT validate the result — the caller is responsible for passing
+ * the returned value through the appropriate Zod schema.
+ *
+ * @param filePath - Absolute path to the .ts or .js file
+ * @returns The default export of the file, or an error
+ */
+export async function loadTsConfig(filePath) {
+    if (!existsSync(filePath)) {
+        return { ok: false, error: `File not found: ${filePath}`, path: filePath };
+    }
+    try {
+        const jiti = getJiti();
+        const mod = await jiti.import(filePath);
+        const value = extractDefault(mod);
+        if (value === undefined || value === null) {
+            return {
+                ok: false,
+                error: `No default export found in ${filePath}. Config files must use \`export default\`.`,
+                path: filePath,
+            };
+        }
+        return { ok: true, value: value, path: filePath };
+    }
+    catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        return {
+            ok: false,
+            error: `Failed to load ${filePath}: ${message}`,
+            path: filePath,
+        };
+    }
+}
+/**
+ * Resolve a config file path with the TS > JS > YAML > JSON priority chain.
+ *
+ * Given a base path without extension (e.g., `"/path/to/config/models"`),
+ * returns the first existing file in priority order, or null if none exist.
+ *
+ * @param basePath - Path without extension
+ * @returns The resolved path with extension, or null
+ */
+export function resolveConfigPath(basePath) {
+    const candidates = [
+        { ext: ".ts", format: "ts" },
+        { ext: ".js", format: "ts" }, // JS files also go through jiti
+        { ext: ".yaml", format: "yaml" },
+        { ext: ".yml", format: "yaml" },
+        { ext: ".json", format: "json" },
+    ];
+    for (const { ext, format } of candidates) {
+        const candidate = basePath + ext;
+        if (existsSync(candidate)) {
+            return { path: candidate, format };
+        }
+    }
+    return null;
+}
+/**
+ * Check if a higher-priority TS/JS file exists alongside a YAML/JSON file.
+ *
+ * Returns a warning message if both exist, or null if no conflict.
+ */
+export function checkFormatConflict(basePath, activeFormat) {
+    if (activeFormat !== "ts")
+        return null;
+    // Check if a YAML file also exists
+    for (const ext of [".yaml", ".yml"]) {
+        if (existsSync(basePath + ext)) {
+            return (`Both TypeScript and YAML config files exist for ${basePath}. ` +
+                `Using TypeScript file; YAML file (${basePath + ext}) is ignored.`);
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract the default export from a module, handling ESM/CJS interop.
+ *
+ * Handles these shapes:
+ * - `{ default: value }` (ESM default export)
+ * - `value` (already the export)
+ * - `{ default: { default: value } }` (double-wrapped by interop)
+ */
+function extractDefault(mod) {
+    if (mod === null || mod === undefined)
+        return mod;
+    // If it's an object with a `default` property, unwrap it
+    if (typeof mod === "object" && "default" in mod) {
+        const inner = mod.default;
+        // Handle double-wrapping
+        if (inner !== null && typeof inner === "object" && "default" in inner) {
+            return inner.default;
+        }
+        return inner;
+    }
+    return mod;
+}

package/dist/adapters/doc-fetchers/sanity-doc-fetcher.d.ts

@@ -13,11 +13,12 @@
  * The pipeline step (FetchDocsStep) calls ctx.docFetcher.fetch() and
  * writes the returned metadata to disk for downstream consumption.
  */
-import { type DocFetcher, type DocSourceConfig, type FetchResult, type TaskDefinition } from "../../_vendor/ailf-core/index.d.ts";
+import { type DocFetcher, type DocSourceConfig, type FetchResult, type GeneralizedTaskDefinition } from "../../_vendor/ailf-core/index.d.ts";
 export declare class SanityDocFetcher implements DocFetcher {
     private readonly rootDir;
     constructor(rootDir: string);
-    fetch(tasks: TaskDefinition[], source?: DocSourceConfig): Promise<FetchResult>;
+    fetch(tasks: GeneralizedTaskDefinition[], source?: DocSourceConfig): Promise<FetchResult>;
+    private fetchInternal;
     private fetchManifest;
     /**
      * Batch-resolve document ID refs to their article slugs.

package/dist/adapters/doc-fetchers/sanity-doc-fetcher.js

@@ -65,6 +65,11 @@ export class SanityDocFetcher {
         this.rootDir = rootDir;
     }
     async fetch(tasks, source) {
+        // Narrow to literacy tasks — only they have context.docs for doc resolution.
+        const literacyTasks = tasks.filter((t) => t.mode === "literacy");
+        return this.fetchInternal(literacyTasks, source);
+    }
+    async fetchInternal(tasks, source) {
         // 1. Collect all unique slugs and IDs across every task.
         // ID refs are resolved to slugs via a batch query so the rest of the
         // slug-based pipeline works unchanged.
@@ -73,7 +78,7 @@ export class SanityDocFetcher {
         const pathRefs = [];
         const perspectiveRefs = [];
         for (const task of tasks) {
-            for (const ref of task.canonicalDocs) {
+            for (const ref of task.context?.docs ?? []) {
                 if (isSlugRef(ref)) {
                     allSlugs.add(ref.slug);
                 }
@@ -212,7 +217,7 @@ export class SanityDocFetcher {
         const contexts = tasks.map((task) => {
             const parts = [];
             const slugs = [];
-            for (const ref of task.canonicalDocs) {
+            for (const ref of task.context?.docs ?? []) {
                 // Perspective refs expand to multiple slugs
                 if (isPerspectiveRef(ref)) {
                     const expanded = perspectiveToSlugs.get(ref.perspective) ?? [];

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

@@ -7,14 +7,14 @@
  * logged on ID collision.
  *
  * This is how the pipeline sees both Content Lake tasks and repo-based
- * tasks in a single TaskDefinition[].
+ * tasks in a single GeneralizedTaskDefinition[].
  *
  * @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 CompositeTaskSource implements TaskSource {
     private readonly sources;
     constructor(sources: TaskSource[]);
-    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+    loadTasks(filter?: FilterOptions): Promise<GeneralizedTaskDefinition[]>;
 }

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

@@ -7,7 +7,7 @@
  * logged on ID collision.
  *
  * This is how the pipeline sees both Content Lake tasks and repo-based
- * tasks in a single TaskDefinition[].
+ * tasks in a single GeneralizedTaskDefinition[].
  *
  * @see packages/core/src/ports/task-source.ts — TaskSource port
  * @see docs/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md

package/dist/adapters/task-sources/content-lake-task-source.d.ts

@@ -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.
  *
@@ -12,9 +13,9 @@
  * @see docs/exec-plans/tasks-as-content/phase-2-pipeline-integration.md
  */
 import type { SanityClient } from "@sanity/client";
-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 ContentLakeTaskSource implements TaskSource {
     private readonly client;
     constructor(client: SanityClient);
-    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+    loadTasks(filter?: FilterOptions): Promise<GeneralizedTaskDefinition[]>;
 }