@sanity/ailf 0.1.0

package/dist/pipeline/resolve-mappings.d.ts

@@ -0,0 +1,35 @@
+/**
+ * pipeline/resolve-mappings.ts
+ *
+ * Extracts canonical mappings from inline task YAML definitions.
+ * Each task file contains canonical_docs and reference_solution fields
+ * directly — there is no separate mappings.yaml file.
+ *
+ * The output shape matches what downstream consumers expect so
+ * fetch-docs, validate, and calculate-scores work without changes.
+ */
+export interface CanonicalDoc {
+    reason: string;
+    slug: string;
+}
+export interface CanonicalTask {
+    canonical_docs: CanonicalDoc[];
+    description: string;
+    id: string;
+    reference_solution: string;
+}
+export interface ResolvedMappings {
+    feature_areas: Record<string, {
+        tasks: CanonicalTask[];
+    }>;
+}
+/**
+ * Extract inline canonical mappings from task YAML files.
+ * Only tasks with both an id and canonical_docs fields are included.
+ */
+export declare function extractInlineMappings(rootDir: string): ResolvedMappings;
+/**
+ * Resolve canonical mappings from inline task YAML definitions.
+ * This is the single source of truth — there is no external mappings file.
+ */
+export declare function resolveMappings(rootDir: string): ResolvedMappings;

package/dist/pipeline/resolve-mappings.js

@@ -0,0 +1,72 @@
+/**
+ * pipeline/resolve-mappings.ts
+ *
+ * Extracts canonical mappings from inline task YAML definitions.
+ * Each task file contains canonical_docs and reference_solution fields
+ * directly — there is no separate mappings.yaml file.
+ *
+ * The output shape matches what downstream consumers expect so
+ * fetch-docs, validate, and calculate-scores work without changes.
+ */
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { resolve } from "path";
+import { load } from "js-yaml";
+// ---------------------------------------------------------------------------
+// Resolution
+// ---------------------------------------------------------------------------
+/**
+ * Extract inline canonical mappings from task YAML files.
+ * Only tasks with both an id and canonical_docs fields are included.
+ */
+export function extractInlineMappings(rootDir) {
+    const tasksDir = resolve(rootDir, "tasks");
+    const result = { feature_areas: {} };
+    if (!existsSync(tasksDir))
+        return result;
+    const yamlFiles = readdirSync(tasksDir)
+        .filter((f) => (f.endsWith(".yaml") || f.endsWith(".yml")) && !f.startsWith("."))
+        .sort();
+    for (const file of yamlFiles) {
+        const featureArea = file.replace(/\.(yaml|yml)$/, "");
+        const filePath = resolve(tasksDir, file);
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = load(raw);
+        if (!Array.isArray(parsed))
+            continue;
+        const tasks = [];
+        for (const entry of parsed) {
+            if (!isInlineTaskWithMappings(entry))
+                continue;
+            tasks.push({
+                canonical_docs: entry.canonical_docs,
+                description: entry.description,
+                id: entry.id,
+                reference_solution: entry.reference_solution,
+            });
+        }
+        if (tasks.length > 0) {
+            result.feature_areas[featureArea] = { tasks };
+        }
+    }
+    return result;
+}
+/**
+ * Resolve canonical mappings from inline task YAML definitions.
+ * This is the single source of truth — there is no external mappings file.
+ */
+export function resolveMappings(rootDir) {
+    return extractInlineMappings(rootDir);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isInlineTaskWithMappings(entry) {
+    if (typeof entry !== "object" || entry === null)
+        return false;
+    const e = entry;
+    return (typeof e.id === "string" &&
+        typeof e.description === "string" &&
+        Array.isArray(e.canonical_docs) &&
+        e.canonical_docs.length > 0 &&
+        typeof e.reference_solution === "string");
+}

package/dist/pipeline/retrieval-metrics.d.ts

@@ -0,0 +1,39 @@
+/**
+ * pipeline/retrieval-metrics.ts
+ *
+ * Computes retrieval precision and recall by comparing agent-retrieved
+ * doc slugs against canonical_docs defined in task YAML files.
+ *
+ * This is a pure computation module — no file I/O beyond reading task YAMLs.
+ */
+import type { RetrievalMetrics, TaskRetrievalMetrics } from "./types.js";
+export interface AgenticBehaviorData {
+    /** Feature area (from detectFeatureArea) */
+    area: string;
+    /** Test description (used to match tasks) */
+    description: string;
+    /** Doc slugs the agent actually visited */
+    docSlugsVisited: string[];
+    /** Task ID (extracted from description if possible) */
+    taskId?: string;
+}
+/**
+ * Compute retrieval metrics from agentic behavior data.
+ *
+ * @param rootDir  Package root (to find tasks/*.yaml)
+ * @param behaviors  Agentic behavior data per task
+ * @returns RetrievalMetrics or null if no canonical docs or behavior data
+ */
+export declare function computeRetrievalMetrics(rootDir: string, behaviors: AgenticBehaviorData[]): null | RetrievalMetrics;
+/**
+ * Compute retrieval metrics for a single task.
+ */
+export declare function computeTaskMetrics(taskId: string, area: string, retrieved: string[], canonical: Set<string>): TaskRetrievalMetrics;
+/**
+ * Load canonical_docs from all task YAML files.
+ * Returns a map of taskId → { slugs: Set<string>, area: string }.
+ */
+export declare function loadCanonicalDocs(rootDir: string): Map<string, {
+    area: string;
+    slugs: Set<string>;
+}>;

package/dist/pipeline/retrieval-metrics.js

@@ -0,0 +1,136 @@
+/**
+ * pipeline/retrieval-metrics.ts
+ *
+ * Computes retrieval precision and recall by comparing agent-retrieved
+ * doc slugs against canonical_docs defined in task YAML files.
+ *
+ * This is a pure computation module — no file I/O beyond reading task YAMLs.
+ */
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { resolve } from "path";
+import { load } from "js-yaml";
+/**
+ * Compute retrieval metrics from agentic behavior data.
+ *
+ * @param rootDir  Package root (to find tasks/*.yaml)
+ * @param behaviors  Agentic behavior data per task
+ * @returns RetrievalMetrics or null if no canonical docs or behavior data
+ */
+export function computeRetrievalMetrics(rootDir, behaviors) {
+    const canonicalMap = loadCanonicalDocs(rootDir);
+    if (canonicalMap.size === 0)
+        return null;
+    if (behaviors.length === 0)
+        return null;
+    // Compute per-task metrics
+    const taskMetrics = [];
+    for (const behavior of behaviors) {
+        const taskId = behavior.taskId;
+        if (!taskId)
+            continue;
+        const canonical = canonicalMap.get(taskId);
+        if (!canonical)
+            continue;
+        taskMetrics.push(computeTaskMetrics(taskId, canonical.area, behavior.docSlugsVisited, canonical.slugs));
+    }
+    if (taskMetrics.length === 0)
+        return null;
+    // Group by area
+    const byArea = new Map();
+    for (const tm of taskMetrics) {
+        if (!byArea.has(tm.area))
+            byArea.set(tm.area, []);
+        byArea.get(tm.area).push(tm);
+    }
+    const areas = [...byArea.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([area, tasks]) => {
+        const avgPrecision = tasks.reduce((s, t) => s + t.precision, 0) / tasks.length;
+        const avgRecall = tasks.reduce((s, t) => s + t.recall, 0) / tasks.length;
+        const avgF1 = tasks.reduce((s, t) => s + t.f1, 0) / tasks.length;
+        // Invisible docs: canonical docs never retrieved across tasks in this area
+        const allRetrieved = new Set(tasks.flatMap((t) => t.retrieved));
+        const allExpected = new Set(tasks.flatMap((t) => t.expected));
+        const invisibleDocs = [...allExpected]
+            .filter((s) => !allRetrieved.has(s))
+            .sort();
+        return {
+            area,
+            avgF1,
+            avgPrecision,
+            avgRecall,
+            invisibleDocs,
+            taskCount: tasks.length,
+            tasks,
+        };
+    });
+    // Overall averages
+    const overall = {
+        avgF1: areas.reduce((s, a) => s + a.avgF1, 0) / (areas.length || 1),
+        avgPrecision: areas.reduce((s, a) => s + a.avgPrecision, 0) / (areas.length || 1),
+        avgRecall: areas.reduce((s, a) => s + a.avgRecall, 0) / (areas.length || 1),
+    };
+    // Global invisible docs
+    const allRetrieved = new Set(taskMetrics.flatMap((t) => t.retrieved));
+    const allExpected = new Set(taskMetrics.flatMap((t) => t.expected));
+    const globalInvisibleDocs = [...allExpected]
+        .filter((s) => !allRetrieved.has(s))
+        .sort();
+    return {
+        areas,
+        globalInvisibleDocs,
+        overall,
+    };
+}
+/**
+ * Compute retrieval metrics for a single task.
+ */
+export function computeTaskMetrics(taskId, area, retrieved, canonical) {
+    const retrievedSet = new Set(retrieved);
+    const hits = [...retrievedSet].filter((s) => canonical.has(s));
+    const missed = [...canonical].filter((s) => !retrievedSet.has(s));
+    const unexpected = [...retrievedSet].filter((s) => !canonical.has(s));
+    const precision = retrievedSet.size > 0 ? hits.length / retrievedSet.size : 0;
+    const recall = canonical.size > 0 ? hits.length / canonical.size : 0;
+    const f1 = precision + recall > 0 ? (2 * precision * recall) / (precision + recall) : 0;
+    return {
+        area,
+        expected: [...canonical],
+        f1,
+        hits,
+        missed,
+        precision,
+        recall,
+        retrieved: [...retrievedSet],
+        taskId,
+        unexpected,
+    };
+}
+/**
+ * Load canonical_docs from all task YAML files.
+ * Returns a map of taskId → { slugs: Set<string>, area: string }.
+ */
+export function loadCanonicalDocs(rootDir) {
+    const tasksDir = resolve(rootDir, "tasks");
+    if (!existsSync(tasksDir))
+        return new Map();
+    const result = new Map();
+    const files = readdirSync(tasksDir).filter((f) => (f.endsWith(".yaml") || f.endsWith(".yml")) && !f.startsWith("."));
+    for (const file of files) {
+        const area = file.replace(/\.ya?ml$/, "");
+        const raw = readFileSync(resolve(tasksDir, file), "utf-8");
+        const parsed = load(raw);
+        if (!Array.isArray(parsed))
+            continue;
+        for (const entry of parsed) {
+            const task = entry;
+            if (task.id && task.canonical_docs && task.canonical_docs.length > 0) {
+                result.set(task.id, {
+                    area,
+                    slugs: new Set(task.canonical_docs.map((d) => d.slug)),
+                });
+            }
+        }
+    }
+    return result;
+}

package/dist/pipeline/reverse-mapping.d.ts

@@ -0,0 +1,67 @@
+/**
+ * pipeline/reverse-mapping.ts
+ *
+ * Builds a reverse index from document slugs to feature areas.
+ *
+ * The canonical_docs in each task YAML define which docs are relevant to
+ * each task. This module inverts that mapping: given a document slug,
+ * return which feature areas (and specific tasks) would be affected if
+ * that document changed.
+ *
+ * This is the foundation for event-driven evaluation triggers — when a
+ * content webhook fires for a document, we look up affected areas and
+ * dispatch a scoped evaluation.
+ *
+ * @see docs/design-docs/report-store/visibility-workflows.md — Event-Driven Triggers
+ */
+import { type ResolvedMappings } from "./resolve-mappings.js";
+/** A feature area + task affected by a document change */
+export interface AffectedTarget {
+    /** Feature area name (filename stem, e.g., "groq") */
+    area: string;
+    /** Task ID within the area (e.g., "groq-blog-queries") */
+    taskId: string;
+}
+/** Summary of impact for a set of changed slugs */
+export interface ImpactSummary {
+    /** Unique affected area names (for --area flag) */
+    areas: string[];
+    /** All affected targets with area + task detail */
+    targets: AffectedTarget[];
+    /** Unique affected task IDs (for --task flag) */
+    taskIds: string[];
+    /** Slugs that don't match any canonical docs (untracked) */
+    unmatchedSlugs: string[];
+}
+/** The reverse mapping: document slug → affected areas/tasks */
+export type ReverseMapping = Map<string, AffectedTarget[]>;
+/**
+ * Get all unique canonical doc slugs across all tasks.
+ * Useful for checking if a webhook payload matches any tracked document.
+ */
+export declare function allTrackedSlugs(reverseMapping: ReverseMapping): string[];
+/**
+ * Given a set of changed document slugs, determine which areas and tasks
+ * are affected and should be re-evaluated.
+ *
+ * @param slugs - Document slugs that changed
+ * @param reverseMapping - Pre-built reverse mapping (or will build from rootDir)
+ * @returns Impact summary with deduplicated areas and tasks
+ */
+export declare function assessImpact(slugs: string[], reverseMapping: ReverseMapping): ImpactSummary;
+/**
+ * Build a reverse mapping from document slugs to feature areas.
+ *
+ * Reads all task YAML files and inverts the canonical_docs mappings.
+ * A single slug may map to multiple areas/tasks (e.g., "groq-introduction"
+ * is referenced by multiple GROQ tasks).
+ *
+ * @param rootDir - Path to the eval package root (packages/eval)
+ * @returns Map from slug → array of affected targets
+ */
+export declare function buildReverseMapping(rootDir: string): ReverseMapping;
+/**
+ * Build a reverse mapping from already-resolved mappings.
+ * Useful for testing without filesystem access.
+ */
+export declare function buildReverseMappingFromResolved(mappings: ResolvedMappings): ReverseMapping;

package/dist/pipeline/reverse-mapping.js

@@ -0,0 +1,88 @@
+/**
+ * pipeline/reverse-mapping.ts
+ *
+ * Builds a reverse index from document slugs to feature areas.
+ *
+ * The canonical_docs in each task YAML define which docs are relevant to
+ * each task. This module inverts that mapping: given a document slug,
+ * return which feature areas (and specific tasks) would be affected if
+ * that document changed.
+ *
+ * This is the foundation for event-driven evaluation triggers — when a
+ * content webhook fires for a document, we look up affected areas and
+ * dispatch a scoped evaluation.
+ *
+ * @see docs/design-docs/report-store/visibility-workflows.md — Event-Driven Triggers
+ */
+import { resolveMappings } from "./resolve-mappings.js";
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Get all unique canonical doc slugs across all tasks.
+ * Useful for checking if a webhook payload matches any tracked document.
+ */
+export function allTrackedSlugs(reverseMapping) {
+    return [...reverseMapping.keys()].sort();
+}
+/**
+ * Given a set of changed document slugs, determine which areas and tasks
+ * are affected and should be re-evaluated.
+ *
+ * @param slugs - Document slugs that changed
+ * @param reverseMapping - Pre-built reverse mapping (or will build from rootDir)
+ * @returns Impact summary with deduplicated areas and tasks
+ */
+export function assessImpact(slugs, reverseMapping) {
+    const allTargets = [];
+    const unmatchedSlugs = [];
+    for (const slug of slugs) {
+        const targets = reverseMapping.get(slug);
+        if (targets && targets.length > 0) {
+            allTargets.push(...targets);
+        }
+        else {
+            unmatchedSlugs.push(slug);
+        }
+    }
+    // Deduplicate areas and task IDs
+    const areas = [...new Set(allTargets.map((t) => t.area))].sort();
+    const taskIds = [...new Set(allTargets.map((t) => t.taskId))].sort();
+    return {
+        areas,
+        targets: allTargets,
+        taskIds,
+        unmatchedSlugs,
+    };
+}
+/**
+ * Build a reverse mapping from document slugs to feature areas.
+ *
+ * Reads all task YAML files and inverts the canonical_docs mappings.
+ * A single slug may map to multiple areas/tasks (e.g., "groq-introduction"
+ * is referenced by multiple GROQ tasks).
+ *
+ * @param rootDir - Path to the eval package root (packages/eval)
+ * @returns Map from slug → array of affected targets
+ */
+export function buildReverseMapping(rootDir) {
+    const mappings = resolveMappings(rootDir);
+    return buildReverseMappingFromResolved(mappings);
+}
+/**
+ * Build a reverse mapping from already-resolved mappings.
+ * Useful for testing without filesystem access.
+ */
+export function buildReverseMappingFromResolved(mappings) {
+    const reverse = new Map();
+    for (const [area, config] of Object.entries(mappings.feature_areas)) {
+        for (const task of config.tasks) {
+            for (const doc of task.canonical_docs) {
+                const existing = reverse.get(doc.slug) ?? [];
+                existing.push({ area, taskId: task.id });
+                reverse.set(doc.slug, existing);
+            }
+        }
+    }
+    return reverse;
+}

package/dist/pipeline/schemas.d.ts

@@ -0,0 +1,9 @@
+/**
+ * pipeline/schemas.ts — Re-export barrel
+ *
+ * All pipeline Zod schemas now live in @sanity/ailf-core. This file
+ * re-exports them for backward compatibility.
+ *
+ * @see packages/core/src/schemas/pipeline.ts (canonical source)
+ */
+export * from "../_vendor/ailf-core/index.d.ts";

package/dist/pipeline/schemas.js

@@ -0,0 +1,9 @@
+/**
+ * pipeline/schemas.ts — Re-export barrel
+ *
+ * All pipeline Zod schemas now live in @sanity/ailf-core. This file
+ * re-exports them for backward compatibility.
+ *
+ * @see packages/core/src/schemas/pipeline.ts (canonical source)
+ */
+export * from "../_vendor/ailf-core/index.js";

package/dist/pipeline/steps/calculate-scores-step.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Pipeline step: Calculate AI Literacy Scores from eval results.
+ *
+ * Preconditions: eval-results.json exists and is valid
+ * Postconditions: score-summary.json exists and is valid
+ *
+ * Cache key: eval results JSON file(s)
+ * Cache outputs: results/latest/score-summary.json
+ */
+import type { EvalMode, StepResult } from "../types.js";
+export declare function runCalculateScores(source?: string, mode?: EvalMode, noCache?: boolean): StepResult;

package/dist/pipeline/steps/calculate-scores-step.js

@@ -0,0 +1,89 @@
+/**
+ * Pipeline step: Calculate AI Literacy Scores from eval results.
+ *
+ * Preconditions: eval-results.json exists and is valid
+ * Postconditions: score-summary.json exists and is valid
+ *
+ * Cache key: eval results JSON file(s)
+ * Cache outputs: results/latest/score-summary.json
+ */
+import { execSync } from "child_process";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { getStepInputPaths, hashFiles, lookupCache, recordCache, } from "../cache.js";
+import { checkResultsExist, checkScoreSummaryValid } from "../checks.js";
+import { RESULTS_FILES } from "./eval-step.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..", "..", "..");
+export function runCalculateScores(source, mode = "baseline", noCache = false) {
+    const start = Date.now();
+    // For full mode, use the baseline results file as the primary input
+    // (calculate-scores reads all available results files internally)
+    const primaryMode = mode === "full" ? "baseline" : mode;
+    const resultsFile = RESULTS_FILES[primaryMode];
+    const resultsIssues = checkResultsExist(ROOT, resultsFile);
+    const resultsErrors = resultsIssues.filter((i) => i.severity === "error");
+    if (resultsErrors.length > 0) {
+        return {
+            durationMs: Date.now() - start,
+            error: `Results missing: ${resultsErrors.map((e) => e.message).join("; ")}`,
+            status: "failed",
+        };
+    }
+    // Cache check
+    if (!noCache) {
+        const cacheResult = lookupCache(ROOT, "calculate-scores");
+        if (cacheResult.hit) {
+            return {
+                durationMs: Date.now() - start,
+                status: "success",
+                summary: `Skipped (cached) — ${cacheResult.entry.summary}`,
+            };
+        }
+    }
+    // Execute — note: calculate-scores exits 1 when areas are below critical,
+    // which is expected behavior, not an error
+    try {
+        const sourceArg = source ? ` --source ${source}` : "";
+        const resultsArg = primaryMode !== "baseline" ? ` ${resultsFile}` : "";
+        execSync(`tsx src/lib/calculate-scores.ts${resultsArg}${sourceArg}`, {
+            cwd: ROOT,
+            env: process.env,
+            stdio: "inherit",
+        });
+    }
+    catch (err) {
+        const code = err !== null && typeof err === "object" && "status" in err
+            ? err.status
+            : 1;
+        // Exit code 1 means "areas below critical" — that's expected
+        if (code !== 1) {
+            return {
+                durationMs: Date.now() - start,
+                error: `calculate-scores failed with exit code ${code}`,
+                status: "failed",
+            };
+        }
+    }
+    // Postcondition: score summary exists and is valid
+    const summaryIssues = checkScoreSummaryValid(ROOT);
+    const summaryErrors = summaryIssues.filter((i) => i.severity === "error");
+    if (summaryErrors.length > 0) {
+        return {
+            durationMs: Date.now() - start,
+            error: `Postcondition failed: ${summaryErrors.map((e) => e.message).join("; ")}`,
+            status: "failed",
+        };
+    }
+    const durationMs = Date.now() - start;
+    const summary = "Scores calculated and summary written";
+    // Record cache
+    if (!noCache) {
+        const inputPaths = getStepInputPaths(ROOT, "calculate-scores");
+        const inputHash = hashFiles(inputPaths);
+        recordCache(ROOT, "calculate-scores", inputHash, summary, durationMs, [
+            "results/latest/score-summary.json",
+        ]);
+    }
+    return { durationMs, status: "success", summary };
+}

package/dist/pipeline/steps/compare-step.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pipeline step: Compare current scores against a baseline.
+ *
+ * Preconditions: score-summary.json exists
+ * Postconditions: comparison-report.json written to results/latest/
+ *
+ * This step is optional — it only runs when --compare is passed
+ * (or a baseline exists and auto-compare is enabled).
+ */
+import type { CompareOptions, StepResult } from "../types.js";
+/**
+ * Run comparison against a baseline.
+ *
+ * @param rootDir Package root directory
+ * @param baselinePath Explicit baseline file path (optional — uses latest if omitted)
+ * @param options Compare options (noise threshold, etc.)
+ */
+export declare function runCompare(rootDir: string, baselinePath?: string, options?: CompareOptions): StepResult;

package/dist/pipeline/steps/compare-step.js

@@ -0,0 +1,90 @@
+/**
+ * Pipeline step: Compare current scores against a baseline.
+ *
+ * Preconditions: score-summary.json exists
+ * Postconditions: comparison-report.json written to results/latest/
+ *
+ * This step is optional — it only runs when --compare is passed
+ * (or a baseline exists and auto-compare is enabled).
+ */
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { compare } from "../compare.js";
+/**
+ * Run comparison against a baseline.
+ *
+ * @param rootDir Package root directory
+ * @param baselinePath Explicit baseline file path (optional — uses latest if omitted)
+ * @param options Compare options (noise threshold, etc.)
+ */
+export function runCompare(rootDir, baselinePath, options) {
+    const start = Date.now();
+    const scoreSummaryPath = resolve(rootDir, "results", "latest", "score-summary.json");
+    if (!existsSync(scoreSummaryPath)) {
+        return {
+            durationMs: Date.now() - start,
+            error: "score-summary.json not found. Run calculate-scores first.",
+            status: "failed",
+        };
+    }
+    // Load experiment (current run)
+    const experiment = JSON.parse(readFileSync(scoreSummaryPath, "utf-8"));
+    // Resolve baseline
+    let resolvedBaselinePath;
+    if (baselinePath) {
+        resolvedBaselinePath = resolve(baselinePath);
+    }
+    else {
+        const baselinesDir = resolve(rootDir, "results", "baselines");
+        if (!existsSync(baselinesDir)) {
+            return {
+                reason: "No baselines directory found. Run 'pnpm baseline:save' first.",
+                status: "skipped",
+            };
+        }
+        const files = readdirSync(baselinesDir)
+            .filter((f) => f.endsWith(".json"))
+            .sort()
+            .reverse();
+        if (files.length === 0) {
+            return {
+                reason: "No baseline files found. Run 'pnpm baseline:save' first.",
+                status: "skipped",
+            };
+        }
+        resolvedBaselinePath = join(baselinesDir, files[0]);
+    }
+    if (!existsSync(resolvedBaselinePath)) {
+        return {
+            durationMs: Date.now() - start,
+            error: `Baseline file not found: ${resolvedBaselinePath}`,
+            status: "failed",
+        };
+    }
+    const baseline = JSON.parse(readFileSync(resolvedBaselinePath, "utf-8"));
+    // Run comparison
+    const report = compare(baseline, experiment, options);
+    // Write report
+    const reportPath = resolve(rootDir, "results", "latest", "comparison-report.json");
+    writeFileSync(reportPath, JSON.stringify(report, null, 2));
+    // Build summary
+    const improved = report.improved.length;
+    const regressed = report.regressed.length;
+    const unchanged = report.unchanged.length;
+    const overallDelta = report.deltas.overall;
+    const deltaStr = overallDelta > 0
+        ? `+${Math.round(overallDelta)}`
+        : String(Math.round(overallDelta));
+    const parts = [`Overall: ${deltaStr}`];
+    if (improved > 0)
+        parts.push(`${improved} improved`);
+    if (regressed > 0)
+        parts.push(`${regressed} regressed`);
+    if (unchanged > 0)
+        parts.push(`${unchanged} unchanged`);
+    return {
+        durationMs: Date.now() - start,
+        status: "success",
+        summary: parts.join(", "),
+    };
+}