@sanity/ailf 2.0.2 → 2.2.0

package/dist/pipeline/expand-tasks.d.ts

@@ -1,232 +0,0 @@
-/**
- * pipeline/expand-tasks.ts
- *
- * @deprecated This is part of the LEGACY compilation path. New code should
- * use the literacy handler in the compiler pipeline instead:
- *
- *   import { compileLiteracyTask } from "./compiler/mode-handlers/literacy/index.js"
- *
- * @see packages/eval/src/pipeline/compiler/mode-handlers/literacy/index.ts
- *
- * ---
- *
- * Reads task YAML files in the single-definition format and expands each
- * task into gold + baseline Promptfoo test entries. This eliminates the
- * manual duplication where every task had to be written twice.
- *
- * Rubric templates from config/rubrics.yaml are resolved at expansion time:
- * tasks specify `template` + `criteria`, and the expander assembles
- * the full rubric text by injecting criteria into the template.
- *
- * Structured dimension metadata (Approach 5):
- * When a rubric template has a `dimension` field, the resolved assertion
- * includes `metadata.dimension` and `metadata.maxScore`. This flows through
- * Promptfoo into component results, allowing the scoring engine to classify
- * rubrics structurally instead of via heuristic string matching.
- * See docs/design-docs/structured-dimensions.md.
- *
- * Single-definition format:
- *   - id: groq-blog-queries
- *     description: "GROQ - Blog queries with filtering and pagination"
- *     doc_coverage: true
- *     vars:
- *       task: |
- *         Write GROQ queries for a Sanity blog application: ...
- *       docs: file://contexts/canonical/groq-blog-queries.md
- *     assert:
- *       - type: llm-rubric
- *         template: task-completion
- *         criteria:
- *           - GROQ filter with _type == "post"
- *           - Projection with aliased slug field
- *       - type: contains-any
- *         value: ["client.fetch", "createClient"]
- *     baseline:
- *       enabled: true
- *       rubric: full
- *
- * Expands to:
- *   1. Gold entry — uses vars.docs as-is, resolves templates, appends doc-coverage
- *   2. Baseline entry — sets docs: "", uses full rubric (same assertions as gold)
- */
-import type { LiteracyTaskDefinition, Logger } from "../_vendor/ailf-core/index.d.ts";
-import { type RubricConfig } from "./schemas.js";
-import { type LiteracyEvalSubMode } from "./normalize-mode.js";
-import type { FilterOptions } from "./types.js";
-/** Any assertion entry (templated or value-based). */
-export type AssertEntry = TemplatedAssert | ValueAssert;
-/** The output format — a Promptfoo-compatible test entry. */
-export interface ExpandedTestEntry {
-    assert?: ValueAssert[];
-    description: string;
-    /**
-     * Promptfoo prompt filter — restricts which prompts this test runs against.
-     * Matches on prompt `id` or `label`. When absent, all prompts are allowed
-     * (Promptfoo's default cartesian product behavior).
-     *
-     * Gold entries use `['with-docs']` (ceiling measurement).
-     * Baseline entries use `['without-docs']` (floor measurement).
-     *
-     * See: evaluation-ceiling.md for the floor/ceiling/actual decomposition.
-     */
-    prompts?: string[];
-    vars: Record<string, unknown>;
-}
-/** A legacy task entry (the old paired format without an `id` field). */
-export interface LegacyTaskEntry {
-    assert?: AssertEntry[];
-    description: string;
-    transform?: string;
-    vars?: Record<string, unknown>;
-}
-/** A single task definition in the new format (input). */
-export interface SingleTaskDefinition {
-    /** Grading assertions (applied to both gold and baseline by default). */
-    assert: AssertEntry[];
-    /** Baseline generation options. */
-    baseline?: {
-        /** Whether to generate a baseline variant. Default: true. */
-        enabled?: boolean;
-        /** Rubric mode: 'full' copies all asserts, 'abbreviated' generates a
-         *  summary rubric, 'none' omits rubric asserts. Default: 'full'. */
-        rubric?: "abbreviated" | "full" | "none";
-    };
-    /** Human-readable description of what this task tests. */
-    description: string;
-    /** Opt-in: auto-generate a documentation coverage rubric for gold. */
-    doc_coverage?: boolean;
-    /** Feature area this task belongs to (flows through to scoring). */
-    featureArea?: string;
-    /** Explicit task ID — determines the canonical context filename. */
-    id: string;
-    /** Template variables: task prompt and docs path. */
-    vars: {
-        task: string;
-        docs: string;
-        [key: string]: unknown;
-    };
-}
-/** A templated assertion — references a rubric template. */
-export interface TemplatedAssert {
-    criteria: string[];
-    template: string;
-    type: "llm-rubric";
-    weight?: number;
-}
-/** A standard assertion with a value. */
-export interface ValueAssert {
-    [key: string]: unknown;
-    type: string;
-    value?: unknown;
-    weight?: number;
-}
-/**
- * Assemble a full rubric text string from a template and criteria.
- *
- * Output format:
- *   {header}
- *   - {scale[0]}
- *   - {scale[1]}
- *   ...
- *
- *   {criteria_label}
- *   - {criteria[0]}
- *   - {criteria[1]}
- *   ...
- *
- *   {footer}
- */
-export declare function assembleRubric(templateKey: string, criteria: string[], rubricConfig: RubricConfig): string;
-/**
- * Build baseline assertions based on the rubric mode.
- *
- * - 'full': Copy all assertions as-is
- * - 'abbreviated': Keep only the first llm-rubric (task completion) with
- *   a shortened prompt, plus all non-rubric assertions
- * - 'none': No assertions at all
- */
-export declare function buildBaselineAsserts(goldAsserts: ValueAssert[], mode: "abbreviated" | "full" | "none"): ValueAssert[];
-/**
- * Clear the cached rubric config. Used in tests.
- */
-export declare function clearRubricCache(): void;
-/**
- * Expand a single task definition into gold + baseline Promptfoo test entries.
- * Returns 1 entry (gold only) if baseline is disabled, or 2 entries otherwise.
- *
- * Resolves templated assertions and appends doc-coverage if opted in.
- *
- * @param mode - Controls which entries are generated and how:
- *   - `'baseline'` (default): Gold + baseline entries with `prompts` filter
- *     to prevent cartesian product with multiple prompts. Gold entries get
- *     `prompts: ['with-docs']`, baseline entries get `prompts: ['without-docs']`.
- *   - `'agentic'`: Gold entries only, no `prompts` filter (agentic mode has
- *     a single prompt that doesn't use `{{docs}}`; baseline entries would be
- *     pure waste — identical prompts, wasted API calls).
- */
-export declare function expandTask(task: SingleTaskDefinition, rubricConfig: RubricConfig, mode?: LiteracyEvalSubMode): ExpandedTestEntry[];
-/**
- * Expand an array of LiteracyTaskDefinition[] (from any TaskSource adapter)
- * into Promptfoo-compatible test entries. This is the TaskSource-aware
- * counterpart of loadAndExpandTasks() — it skips YAML file I/O and works
- * directly with the domain type.
- *
- * @param tasks - Literacy task definitions from any TaskSource adapter
- * @param rootDir - Eval package root (needed to load rubric templates)
- * @param mode - Expansion mode: 'baseline' (gold + baseline) or 'agentic' (gold only)
- * @returns Expanded test entries and statistics
- */
-export declare function expandTaskDefinitions(tasks: LiteracyTaskDefinition[], rootDir: string, mode?: LiteracyEvalSubMode): {
-    entries: ExpandedTestEntry[];
-    stats: {
-        totalTasks: number;
-        expandedTotal: number;
-    };
-};
-/**
- * Extract all task IDs from task files. Only works with the new
- * single-definition format entries (those that have an `id` field).
- */
-export declare function extractTaskIds(rootDir: string): string[];
-/**
- * Type guard: checks if an entry is in the new single-definition format.
- * The distinguishing feature is the presence of an `id` field.
- */
-export declare function isSingleTaskDefinition(entry: unknown): entry is SingleTaskDefinition;
-/**
- * Type guard: checks if an assertion uses the templated format.
- */
-export declare function isTemplatedAssert(entry: AssertEntry): entry is TemplatedAssert;
-/**
- * Load and expand all task files from the tasks/ directory.
- * Supports both the new single-definition format (has `id`) and the legacy
- * paired format (no `id`). Legacy entries pass through unchanged.
- *
- * @param mode - Controls expansion behavior:
- *   - `'baseline'` (default): Gold + baseline entries with prompt filters.
- *   - `'agentic'`: Gold entries only, no prompt filters.
- *
- * Returns the expanded entries grouped by source file.
- */
-export declare function loadAndExpandTasks(rootDir: string, filter?: FilterOptions, mode?: LiteracyEvalSubMode, logger?: Logger): {
-    /** All expanded test entries, in order. */
-    entries: ExpandedTestEntry[];
-    /** Statistics about what was processed. */
-    stats: {
-        totalFiles: number;
-        singleDefinitions: number;
-        legacyEntries: number;
-        expandedTotal: number;
-    };
-};
-/**
- * Load and validate config/rubrics.yaml from the given root directory.
- * Caches the result for subsequent calls with the same rootDir.
- */
-export declare function loadRubricTemplates(rootDir: string): RubricConfig;
-/**
- * Resolve a single assertion: if it's templated, assemble the rubric text
- * and attach structured dimension metadata when the template has a
- * `dimension` field. Otherwise, pass through unchanged.
- */
-export declare function resolveAssert(entry: AssertEntry, rubricConfig: RubricConfig): ValueAssert;

package/dist/pipeline/expand-tasks.js

@@ -1,467 +0,0 @@
-/**
- * pipeline/expand-tasks.ts
- *
- * @deprecated This is part of the LEGACY compilation path. New code should
- * use the literacy handler in the compiler pipeline instead:
- *
- *   import { compileLiteracyTask } from "./compiler/mode-handlers/literacy/index.js"
- *
- * @see packages/eval/src/pipeline/compiler/mode-handlers/literacy/index.ts
- *
- * ---
- *
- * Reads task YAML files in the single-definition format and expands each
- * task into gold + baseline Promptfoo test entries. This eliminates the
- * manual duplication where every task had to be written twice.
- *
- * Rubric templates from config/rubrics.yaml are resolved at expansion time:
- * tasks specify `template` + `criteria`, and the expander assembles
- * the full rubric text by injecting criteria into the template.
- *
- * Structured dimension metadata (Approach 5):
- * When a rubric template has a `dimension` field, the resolved assertion
- * includes `metadata.dimension` and `metadata.maxScore`. This flows through
- * Promptfoo into component results, allowing the scoring engine to classify
- * rubrics structurally instead of via heuristic string matching.
- * See docs/design-docs/structured-dimensions.md.
- *
- * Single-definition format:
- *   - id: groq-blog-queries
- *     description: "GROQ - Blog queries with filtering and pagination"
- *     doc_coverage: true
- *     vars:
- *       task: |
- *         Write GROQ queries for a Sanity blog application: ...
- *       docs: file://contexts/canonical/groq-blog-queries.md
- *     assert:
- *       - type: llm-rubric
- *         template: task-completion
- *         criteria:
- *           - GROQ filter with _type == "post"
- *           - Projection with aliased slug field
- *       - type: contains-any
- *         value: ["client.fetch", "createClient"]
- *     baseline:
- *       enabled: true
- *       rubric: full
- *
- * Expands to:
- *   1. Gold entry — uses vars.docs as-is, resolves templates, appends doc-coverage
- *   2. Baseline entry — sets docs: "", uses full rubric (same assertions as gold)
- */
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { resolve } from "path";
-import { load } from "js-yaml";
-import { ConsoleLogger } from "../adapters/loggers/index.js";
-import { loadConfigFile } from "./compiler/config-loader.js";
-import { RubricConfigSchema } from "./schemas.js";
-import { LiteracyVariant } from "./normalize-mode.js";
-// ---------------------------------------------------------------------------
-// Rubric template loading and assembly
-// ---------------------------------------------------------------------------
-/** Cached rubric config — loaded once per process. */
-let cachedRubricConfig = null;
-/**
- * Assemble a full rubric text string from a template and criteria.
- *
- * Output format:
- *   {header}
- *   - {scale[0]}
- *   - {scale[1]}
- *   ...
- *
- *   {criteria_label}
- *   - {criteria[0]}
- *   - {criteria[1]}
- *   ...
- *
- *   {footer}
- */
-export function assembleRubric(templateKey, criteria, rubricConfig) {
-    const template = rubricConfig.templates[templateKey];
-    if (!template) {
-        throw new Error(`Unknown rubric template '${templateKey}'. Available: ${Object.keys(rubricConfig.templates).join(", ")}`);
-    }
-    const parts = [];
-    // Header
-    parts.push(template.header);
-    // Scale
-    for (const item of template.scale) {
-        parts.push(`- ${item}`);
-    }
-    // Criteria (if template has a label and criteria are provided)
-    if (template.criteria_label && criteria.length > 0) {
-        parts.push(""); // blank line
-        parts.push(template.criteria_label);
-        for (const c of criteria) {
-            parts.push(`- ${c}`);
-        }
-    }
-    // Footer
-    parts.push(""); // blank line
-    parts.push(rubricConfig.footer);
-    return parts.join("\n");
-}
-/**
- * Build baseline assertions based on the rubric mode.
- *
- * - 'full': Copy all assertions as-is
- * - 'abbreviated': Keep only the first llm-rubric (task completion) with
- *   a shortened prompt, plus all non-rubric assertions
- * - 'none': No assertions at all
- */
-export function buildBaselineAsserts(goldAsserts, mode) {
-    if (mode === "none")
-        return [];
-    if (mode === "full")
-        return [...goldAsserts];
-    // Abbreviated: keep the first llm-rubric with a summary, drop the rest
-    const abbreviated = [];
-    let foundFirstRubric = false;
-    for (const a of goldAsserts) {
-        if (a.type === "llm-rubric") {
-            if (!foundFirstRubric) {
-                foundFirstRubric = true;
-                abbreviated.push({
-                    type: "llm-rubric",
-                    value: 'Score task completion from 0 to 100 (same criteria as above).\nReturn ONLY a JSON object: {"score": <number>, "reason": "<explanation>"}',
-                });
-            }
-            // Skip subsequent llm-rubrics (code correctness, doc coverage)
-        }
-        // Non-rubric assertions are excluded from baseline to match current behavior
-    }
-    return abbreviated;
-}
-/**
- * Clear the cached rubric config. Used in tests.
- */
-export function clearRubricCache() {
-    cachedRubricConfig = null;
-}
-/**
- * Expand a single task definition into gold + baseline Promptfoo test entries.
- * Returns 1 entry (gold only) if baseline is disabled, or 2 entries otherwise.
- *
- * Resolves templated assertions and appends doc-coverage if opted in.
- *
- * @param mode - Controls which entries are generated and how:
- *   - `'baseline'` (default): Gold + baseline entries with `prompts` filter
- *     to prevent cartesian product with multiple prompts. Gold entries get
- *     `prompts: ['with-docs']`, baseline entries get `prompts: ['without-docs']`.
- *   - `'agentic'`: Gold entries only, no `prompts` filter (agentic mode has
- *     a single prompt that doesn't use `{{docs}}`; baseline entries would be
- *     pure waste — identical prompts, wasted API calls).
- */
-export function expandTask(task, rubricConfig, mode = LiteracyVariant.STANDARD) {
-    const entries = [];
-    // Resolve all templated assertions
-    const resolvedAsserts = task.assert.map((a) => resolveAssert(a, rubricConfig));
-    // Append doc-coverage rubric if opted in
-    if (task.doc_coverage) {
-        const dcTemplate = rubricConfig.templates["doc-coverage"];
-        resolvedAsserts.push({
-            type: "llm-rubric",
-            value: assembleRubric("doc-coverage", [], rubricConfig),
-            ...(dcTemplate?.dimension && {
-                metadata: {
-                    dimension: dcTemplate.dimension,
-                    maxScore: 100,
-                },
-            }),
-        });
-    }
-    // Gold entry — ceiling measurement (canonical docs injected directly).
-    // In baseline/observed mode: restricted to the 'with-docs' prompt to
-    // prevent cartesian product with the 'without-docs' prompt.
-    // In agentic mode: no filter needed (single prompt, id = 'agentic').
-    // See evaluation-ceiling.md for the floor/ceiling/actual decomposition.
-    entries.push({
-        assert: [...resolvedAsserts],
-        description: `${task.description} (gold)`,
-        ...(mode === LiteracyVariant.STANDARD ? { prompts: ["with-docs"] } : {}),
-        vars: { ...task.vars, __featureArea: task.featureArea ?? "" },
-    });
-    // Baseline entry — floor measurement (no docs, parametric knowledge only).
-    // Skipped entirely in agentic mode: the agentic prompt doesn't reference
-    // {{docs}}, so gold and baseline would produce identical prompts — pure
-    // waste of API calls and cost.
-    if (mode === LiteracyVariant.AGENTIC) {
-        return entries;
-    }
-    // Restricted to the 'without-docs' prompt. Unless explicitly disabled.
-    const baselineEnabled = task.baseline?.enabled !== false;
-    if (baselineEnabled) {
-        const rubricMode = task.baseline?.rubric ?? "full";
-        const baselineAsserts = buildBaselineAsserts(resolvedAsserts, rubricMode);
-        entries.push({
-            description: `${task.description} (baseline)`,
-            prompts: ["without-docs"],
-            vars: {
-                ...task.vars,
-                docs: "",
-                __featureArea: task.featureArea ?? "",
-            },
-            ...(baselineAsserts.length > 0 ? { assert: baselineAsserts } : {}),
-        });
-    }
-    return entries;
-}
-/**
- * Convert a LiteracyTaskDefinition to the local SingleTaskDefinition
- * format used by expandTask().
- *
- * When a task has no canonical docs, the `docs` var is set to empty string
- * instead of a file path. This prevents Promptfoo from trying to read a
- * context file that was never created by FetchDocsStep (which skips tasks
- * without canonical docs). The gold entry still runs — it just tests model
- * knowledge alone, same as the baseline variant.
- */
-function literacyTaskToSingle(task) {
-    const hasDocs = (task.context?.docs?.length ?? 0) > 0;
-    return {
-        assert: (task.assertions ?? []).map((a) => ({ ...a })),
-        baseline: task.baseline,
-        description: task.title,
-        doc_coverage: task.docCoverage,
-        featureArea: task.area ?? "",
-        id: task.id,
-        vars: {
-            docs: hasDocs ? `file://contexts/canonical/${task.id}.md` : "",
-            task: task.prompt?.text ?? "",
-            ...task.prompt?.vars,
-        },
-    };
-}
-/**
- * Expand an array of LiteracyTaskDefinition[] (from any TaskSource adapter)
- * into Promptfoo-compatible test entries. This is the TaskSource-aware
- * counterpart of loadAndExpandTasks() — it skips YAML file I/O and works
- * directly with the domain type.
- *
- * @param tasks - Literacy task definitions from any TaskSource adapter
- * @param rootDir - Eval package root (needed to load rubric templates)
- * @param mode - Expansion mode: 'baseline' (gold + baseline) or 'agentic' (gold only)
- * @returns Expanded test entries and statistics
- */
-export function expandTaskDefinitions(tasks, rootDir, mode = LiteracyVariant.STANDARD) {
-    const rubricConfig = loadRubricTemplates(rootDir);
-    const entries = [];
-    for (const task of tasks) {
-        const single = literacyTaskToSingle(task);
-        entries.push(...expandTask(single, rubricConfig, mode));
-    }
-    return {
-        entries,
-        stats: {
-            expandedTotal: entries.length,
-            totalTasks: tasks.length,
-        },
-    };
-}
-/**
- * Extract all task IDs from task files. Only works with the new
- * single-definition format entries (those that have an `id` field).
- */
-export function extractTaskIds(rootDir) {
-    const tasksDir = resolve(rootDir, "tasks");
-    if (!existsSync(tasksDir))
-        return [];
-    const yamlFiles = readdirSync(tasksDir)
-        .filter((f) => (f.endsWith(".yaml") || f.endsWith(".yml")) && !f.startsWith("."))
-        .sort();
-    const ids = [];
-    for (const file of yamlFiles) {
-        const filePath = resolve(tasksDir, file);
-        const raw = readFileSync(filePath, "utf-8");
-        const parsed = load(raw);
-        if (!Array.isArray(parsed))
-            continue;
-        for (const entry of parsed) {
-            if (isSingleTaskDefinition(entry)) {
-                ids.push(entry.id);
-            }
-        }
-    }
-    return ids;
-}
-// ---------------------------------------------------------------------------
-// Core expansion logic
-// ---------------------------------------------------------------------------
-/**
- * Type guard: checks if an entry is in the new single-definition format.
- * The distinguishing feature is the presence of an `id` field.
- */
-export function isSingleTaskDefinition(entry) {
-    return (typeof entry === "object" &&
-        entry !== null &&
-        "id" in entry &&
-        typeof entry.id === "string" &&
-        "description" in entry &&
-        "vars" in entry &&
-        "assert" in entry);
-}
-/**
- * Type guard: checks if an assertion uses the templated format.
- */
-export function isTemplatedAssert(entry) {
-    return (entry.type === "llm-rubric" &&
-        "template" in entry &&
-        typeof entry.template === "string" &&
-        "criteria" in entry &&
-        Array.isArray(entry.criteria));
-}
-// ---------------------------------------------------------------------------
-// Task file loading
-// ---------------------------------------------------------------------------
-/**
- * Load and expand all task files from the tasks/ directory.
- * Supports both the new single-definition format (has `id`) and the legacy
- * paired format (no `id`). Legacy entries pass through unchanged.
- *
- * @param mode - Controls expansion behavior:
- *   - `'baseline'` (default): Gold + baseline entries with prompt filters.
- *   - `'agentic'`: Gold entries only, no prompt filters.
- *
- * Returns the expanded entries grouped by source file.
- */
-export function loadAndExpandTasks(rootDir, filter, mode = LiteracyVariant.STANDARD, logger) {
-    const log = logger ?? new ConsoleLogger();
-    const tasksDir = resolve(rootDir, "tasks");
-    if (!existsSync(tasksDir)) {
-        log.debug("Tasks directory not found, returning empty (tasks may come from Content Lake)", {
-            tasksDir,
-        });
-        // tasks/ may not exist when task definitions come from Content Lake
-        return {
-            entries: [],
-            stats: {
-                expandedTotal: 0,
-                legacyEntries: 0,
-                singleDefinitions: 0,
-                totalFiles: 0,
-            },
-        };
-    }
-    // Load rubric templates
-    const rubricConfig = loadRubricTemplates(rootDir);
-    let yamlFiles = readdirSync(tasksDir)
-        .filter((f) => (f.endsWith(".yaml") || f.endsWith(".yml")) && !f.startsWith("."))
-        .sort();
-    log.debug("Discovered task YAML files", {
-        directory: tasksDir,
-        fileCount: yamlFiles.length,
-        files: yamlFiles,
-    });
-    // Apply area filter — area name = filename stem (e.g., "groq" matches "groq.yaml")
-    if (filter?.areas && filter.areas.length > 0) {
-        const allowedAreas = new Set(filter.areas.map((a) => a.toLowerCase()));
-        const beforeCount = yamlFiles.length;
-        yamlFiles = yamlFiles.filter((f) => {
-            const stem = f.replace(/\.ya?ml$/, "").toLowerCase();
-            return allowedAreas.has(stem);
-        });
-        log.debug("Applied area filter", {
-            allowedAreas: [...allowedAreas],
-            beforeCount,
-            afterCount: yamlFiles.length,
-            matchedFiles: yamlFiles,
-        });
-    }
-    const entries = [];
-    let singleDefinitions = 0;
-    let legacyEntries = 0;
-    for (const file of yamlFiles) {
-        const filePath = resolve(tasksDir, file);
-        const raw = readFileSync(filePath, "utf-8");
-        let parsed = load(raw);
-        if (!Array.isArray(parsed)) {
-            throw new Error(`${file} did not parse to an array of tasks`);
-        }
-        // Apply task ID filter
-        if (filter?.taskIds && filter.taskIds.length > 0) {
-            const allowedIds = new Set(filter.taskIds);
-            const beforeCount = parsed.length;
-            parsed = parsed.filter((entry) => typeof entry === "object" &&
-                entry !== null &&
-                "id" in entry &&
-                allowedIds.has(entry.id));
-            log.debug("Applied task ID filter", {
-                file,
-                allowedIds: [...allowedIds],
-                beforeCount,
-                afterCount: parsed.length,
-            });
-        }
-        for (const entry of parsed) {
-            if (isSingleTaskDefinition(entry)) {
-                singleDefinitions++;
-                entries.push(...expandTask(entry, rubricConfig, mode));
-            }
-            else {
-                legacyEntries++;
-                entries.push(entry);
-            }
-        }
-    }
-    if (filter?.areas || filter?.taskIds) {
-        log.info(`Filter: ${filter.areas ? `areas=[${filter.areas.join(", ")}]` : ""}${filter.areas && filter.taskIds ? ", " : ""}${filter.taskIds ? `tasks=[${filter.taskIds.join(", ")}]` : ""}`);
-    }
-    log.debug("Task expansion complete", {
-        totalFiles: yamlFiles.length,
-        singleDefinitions,
-        legacyEntries,
-        expandedTotal: entries.length,
-        mode,
-    });
-    return {
-        entries,
-        stats: {
-            expandedTotal: entries.length,
-            legacyEntries,
-            singleDefinitions,
-            totalFiles: yamlFiles.length,
-        },
-    };
-}
-/**
- * Load and validate config/rubrics.yaml from the given root directory.
- * Caches the result for subsequent calls with the same rootDir.
- */
-export function loadRubricTemplates(rootDir) {
-    if (cachedRubricConfig)
-        return cachedRubricConfig;
-    const { data } = loadConfigFile("rubrics", rootDir);
-    const result = RubricConfigSchema.safeParse(data);
-    if (!result.success) {
-        const messages = result.error.issues
-            .map((i) => `  [${i.path.join(".")}]: ${i.message}`)
-            .join("\n");
-        throw new Error(`Invalid config/rubrics:\n${messages}`);
-    }
-    cachedRubricConfig = result.data;
-    return result.data;
-}
-/**
- * Resolve a single assertion: if it's templated, assemble the rubric text
- * and attach structured dimension metadata when the template has a
- * `dimension` field. Otherwise, pass through unchanged.
- */
-export function resolveAssert(entry, rubricConfig) {
-    if (isTemplatedAssert(entry)) {
-        const template = rubricConfig.templates[entry.template];
-        return {
-            type: "llm-rubric",
-            value: assembleRubric(entry.template, entry.criteria, rubricConfig),
-            ...(entry.weight !== undefined ? { weight: entry.weight } : {}),
-            // Structured dimension metadata (Approach 5)
-            ...(template?.dimension && {
-                metadata: {
-                    dimension: template.dimension,
-                    maxScore: 100,
-                },
-            }),
-        };
-    }
-    return entry;
-}