@sanity/ailf 0.1.0

package/dist/schedules/digest.js

@@ -0,0 +1,156 @@
+/**
+ * schedules/digest.ts
+ *
+ * Weekly digest engine — aggregates evaluation reports from a time window
+ * and computes trend summaries for notification delivery.
+ *
+ * The digest answers: "How did our AI literacy scores trend this week?"
+ *
+ * Data flow:
+ * 1. Query Sanity for all reports in the lookback window
+ * 2. Group by feature area
+ * 3. Compute trend direction and magnitude per area
+ * 4. Identify regressions, improvements, and stable areas
+ * 5. Return a structured DigestSummary for formatting
+ *
+ * @see docs/design-docs/report-store/notifications.md
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+import { NOISE_THRESHOLD } from "../_vendor/ailf-shared/index.js";
+import { getSanityClient } from "../sanity/client.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const REPORT_TYPE = "ailf.report";
+// ---------------------------------------------------------------------------
+// GROQ query
+// ---------------------------------------------------------------------------
+const DIGEST_QUERY = `*[_type == $type && completedAt >= $since] | order(completedAt asc) {
+  "reportId": reportId,
+  "completedAt": completedAt,
+  "mode": provenance.mode,
+  "sourceName": provenance.source.name,
+  "overallScore": summary.overall.avgScore,
+  "durationMs": durationMs,
+  "tag": tag,
+  "scores": summary.scores[] {
+    "feature": feature,
+    "totalScore": totalScore
+  }
+}`;
+/**
+ * Build a digest summary from a chronologically-ordered list of reports.
+ *
+ * Pure function — no I/O, fully testable.
+ */
+export function buildDigestSummary(reports, lookbackStart, lookbackEnd, noiseThreshold = NOISE_THRESHOLD) {
+    // Collect all unique areas across all reports
+    const areaSet = new Set();
+    for (const report of reports) {
+        for (const score of report.scores) {
+            areaSet.add(score.feature);
+        }
+    }
+    // Build per-area trends
+    const areaTrends = [];
+    for (const area of [...areaSet].sort()) {
+        const areaScores = reports
+            .map((r) => {
+            const s = r.scores.find((sc) => sc.feature === area);
+            return s ? s.totalScore : null;
+        })
+            .filter((s) => s !== null);
+        if (areaScores.length === 0)
+            continue;
+        const firstScore = areaScores[0];
+        const lastScore = areaScores[areaScores.length - 1];
+        const delta = lastScore - firstScore;
+        const trend = classifyTrend(delta, noiseThreshold);
+        areaTrends.push({
+            area,
+            firstScore,
+            lastScore,
+            reportCount: areaScores.length,
+            scoreDelta: delta,
+            trend,
+        });
+    }
+    // Overall trend from report-level overall scores
+    const firstOverall = reports[0].overallScore;
+    const lastOverall = reports[reports.length - 1].overallScore;
+    const overallDelta = lastOverall - firstOverall;
+    const overallTrend = classifyTrend(overallDelta, noiseThreshold);
+    // Classify areas
+    const improved = areaTrends
+        .filter((t) => t.trend === "improving")
+        .map((t) => t.area);
+    const regressed = areaTrends
+        .filter((t) => t.trend === "regressing")
+        .map((t) => t.area);
+    const stable = areaTrends
+        .filter((t) => t.trend === "stable")
+        .map((t) => t.area);
+    return {
+        areaTrends,
+        improved,
+        lookbackEnd: lookbackEnd.toISOString(),
+        lookbackStart: lookbackStart.toISOString(),
+        overallDelta,
+        overallLatest: lastOverall,
+        overallTrend,
+        regressed,
+        reportCount: reports.length,
+        stable,
+    };
+}
+// ---------------------------------------------------------------------------
+// Trend computation
+// ---------------------------------------------------------------------------
+/**
+ * Classify a score delta into a trend direction.
+ */
+export function classifyTrend(delta, threshold = NOISE_THRESHOLD) {
+    if (delta > threshold)
+        return "improving";
+    if (delta < -threshold)
+        return "regressing";
+    return "stable";
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Generate a digest summary from recent evaluation reports.
+ *
+ * Queries the Sanity Content Lake for all reports within the lookback
+ * window and computes trend analysis per area.
+ *
+ * @returns DigestSummary, or null if no reports found or on error
+ */
+export async function generateDigest(options = {}) {
+    const lookbackDays = options.lookbackDays ?? 7;
+    const threshold = options.noiseThreshold ?? NOISE_THRESHOLD;
+    const client = options.client ??
+        getSanityClient({
+            ...(options.dataset ? { dataset: options.dataset } : {}),
+            ...(options.projectId ? { projectId: options.projectId } : {}),
+            ...(options.token ? { token: options.token } : {}),
+        });
+    const now = new Date();
+    const since = new Date(now.getTime() - lookbackDays * 24 * 60 * 60 * 1000);
+    try {
+        const reports = await client.fetch(DIGEST_QUERY, {
+            since: since.toISOString(),
+            type: REPORT_TYPE,
+        });
+        if (!reports || reports.length === 0) {
+            console.log("  ℹ️  No reports found in the lookback window");
+            return null;
+        }
+        return buildDigestSummary(reports, since, now, threshold);
+    }
+    catch (error) {
+        console.warn("  ⚠️  Failed to fetch digest reports:", error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}

package/dist/schedules/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * schedules/index.ts
+ *
+ * Barrel exports for the scheduled evaluation module.
+ *
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+export { buildDigestSummary, classifyTrend, generateDigest } from "./digest.js";
+export type { AreaTrend, DigestOptions, DigestReportEntry, DigestSummary, TrendDirection, } from "./digest.js";
+export { findSchedule, getDigestConfig, getEnabledSchedules, loadSchedules, } from "./loader.js";
+export type { DigestConfig, ScheduleEntry, SchedulesFile } from "./schema.js";
+export { DigestConfigSchema, ScheduleEntrySchema, SchedulesFileSchema, } from "./schema.js";

package/dist/schedules/index.js

@@ -0,0 +1,10 @@
+/**
+ * schedules/index.ts
+ *
+ * Barrel exports for the scheduled evaluation module.
+ *
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+export { buildDigestSummary, classifyTrend, generateDigest } from "./digest.js";
+export { findSchedule, getDigestConfig, getEnabledSchedules, loadSchedules, } from "./loader.js";
+export { DigestConfigSchema, ScheduleEntrySchema, SchedulesFileSchema, } from "./schema.js";

package/dist/schedules/loader.d.ts

@@ -0,0 +1,31 @@
+/**
+ * schedules/loader.ts
+ *
+ * Loads and validates config/schedules.yaml.
+ *
+ * The schedule config drives both the GitHub Actions cron workflow
+ * (which reads enabled schedules to build a matrix) and the digest
+ * script (which reads the digest section for lookback and delivery).
+ *
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+import { type DigestConfig, type ScheduleEntry, type SchedulesFile } from "./schema.js";
+/**
+ * Find a schedule entry by name.
+ */
+export declare function findSchedule(name: string, configPath?: string): ScheduleEntry | undefined;
+/**
+ * Get the digest configuration, if enabled.
+ */
+export declare function getDigestConfig(configPath?: string): DigestConfig | null;
+/**
+ * Get all enabled schedule entries.
+ */
+export declare function getEnabledSchedules(configPath?: string): ScheduleEntry[];
+/**
+ * Load and validate the schedule configuration.
+ *
+ * @param configPath - Override the default config file location
+ * @returns Parsed and validated schedules file, or null if not found/invalid
+ */
+export declare function loadSchedules(configPath?: string): null | SchedulesFile;

package/dist/schedules/loader.js

@@ -0,0 +1,73 @@
+/**
+ * schedules/loader.ts
+ *
+ * Loads and validates config/schedules.yaml.
+ *
+ * The schedule config drives both the GitHub Actions cron workflow
+ * (which reads enabled schedules to build a matrix) and the digest
+ * script (which reads the digest section for lookback and delivery).
+ *
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { load } from "js-yaml";
+import { interpolate } from "../interpolate.js";
+import { SchedulesFileSchema, } from "./schema.js";
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_CONFIG_PATH = resolve(__dirname, "..", "..", "config", "schedules.yaml");
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Find a schedule entry by name.
+ */
+export function findSchedule(name, configPath) {
+    const config = loadSchedules(configPath);
+    if (!config)
+        return undefined;
+    return config.schedules.find((s) => s.name === name);
+}
+/**
+ * Get the digest configuration, if enabled.
+ */
+export function getDigestConfig(configPath) {
+    const config = loadSchedules(configPath);
+    if (!config?.digest?.enabled)
+        return null;
+    return config.digest;
+}
+/**
+ * Get all enabled schedule entries.
+ */
+export function getEnabledSchedules(configPath) {
+    const config = loadSchedules(configPath);
+    if (!config)
+        return [];
+    return config.schedules.filter((s) => s.enabled);
+}
+/**
+ * Load and validate the schedule configuration.
+ *
+ * @param configPath - Override the default config file location
+ * @returns Parsed and validated schedules file, or null if not found/invalid
+ */
+export function loadSchedules(configPath = DEFAULT_CONFIG_PATH) {
+    if (!existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = load(raw);
+        const interpolated = interpolate(parsed);
+        return SchedulesFileSchema.parse(interpolated);
+    }
+    catch (error) {
+        console.warn("Failed to load schedules config:", error instanceof Error ? error.message : error);
+        return null;
+    }
+}

package/dist/schedules/schema.d.ts

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

package/dist/schedules/schema.js

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

package/dist/scripts/agent-behavior-report.d.ts

@@ -0,0 +1,19 @@
+/**
+ * agent-behavior-report.ts
+ *
+ * Standalone script that reads Promptfoo evaluation results containing
+ * agent behavior observation data and generates a detailed report.
+ *
+ * This provides deeper analysis than the summary included in the main
+ * calculate-scores report, including:
+ *
+ *   - Per-task behavior breakdown (which specific pages each task visited)
+ *   - Canonical doc coverage (did the agent find the "right" docs?)
+ *   - Request timeline and latency analysis
+ *   - Search strategy analysis
+ *   - Cross-task navigation pattern detection
+ *
+ * Usage:
+ *   tsx src/scripts/agent-behavior-report.ts [results-path]
+ */
+import "dotenv/config";

package/dist/scripts/agent-behavior-report.js

@@ -0,0 +1,315 @@
+/**
+ * agent-behavior-report.ts
+ *
+ * Standalone script that reads Promptfoo evaluation results containing
+ * agent behavior observation data and generates a detailed report.
+ *
+ * This provides deeper analysis than the summary included in the main
+ * calculate-scores report, including:
+ *
+ *   - Per-task behavior breakdown (which specific pages each task visited)
+ *   - Canonical doc coverage (did the agent find the "right" docs?)
+ *   - Request timeline and latency analysis
+ *   - Search strategy analysis
+ *   - Cross-task navigation pattern detection
+ *
+ * Usage:
+ *   tsx src/scripts/agent-behavior-report.ts [results-path]
+ */
+// oxlint-disable-next-line import/no-unassigned-import -- side-effect: loads .env into process.env
+import "dotenv/config";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+// Canonical doc mapping: task description patterns -> expected doc slugs
+// This maps what docs a well-informed agent *should* visit for each task
+const CANONICAL_DOC_MAP = {
+    frameworks: [
+        "remix",
+        "nuxt",
+        "svelte",
+        "astro",
+        "gatsby",
+        "client-libraries",
+    ],
+    functions: [
+        "functions",
+        "webhooks",
+        "groq-powered-webhooks",
+        "event-driven",
+        "automations",
+    ],
+    "nextjs-live": [
+        "next-js",
+        "live-content-api",
+        "content-source-maps",
+        "app-router",
+        "groq",
+        "client-libraries",
+    ],
+    "studio-setup": [
+        "studio",
+        "schema-types",
+        "structure-builder",
+        "configuration",
+        "plugins",
+    ],
+    "visual-editing": [
+        "visual-editing",
+        "presentation",
+        "preview",
+        "overlays",
+        "loaders",
+    ],
+};
+function analyzeResults(resultsPath) {
+    const json = JSON.parse(readFileSync(resultsPath, "utf-8"));
+    // Support both the flat shape ({ results: TestResult[] }) and the full
+    // Promptfoo envelope shape ({ results: { results: TestResult[] } }).
+    const results = Array.isArray(json.results)
+        ? json.results
+        : json.results.results;
+    const tasks = [];
+    for (const result of results) {
+        const metadata = result.metadata;
+        if (!metadata?.agentBehaviorSummary)
+            continue;
+        const behavior = metadata.agentBehaviorSummary;
+        tasks.push({
+            behavior,
+            description: result.description,
+            feature: detectFeatureArea(result.description),
+            hasDocs: !!(result.vars.docs && result.vars.docs.trim().length > 0),
+        });
+    }
+    if (tasks.length === 0) {
+        return { features: [], hasData: false, tasks: [] };
+    }
+    // Group by feature
+    const byFeature = {};
+    for (const t of tasks) {
+        if (!byFeature[t.feature])
+            byFeature[t.feature] = [];
+        byFeature[t.feature].push(t);
+    }
+    const features = Object.entries(byFeature)
+        .map(([feature, featureTasks]) => {
+        const allDocSlugs = [
+            ...new Set(featureTasks.flatMap((t) => t.behavior.docSlugsVisited)),
+        ];
+        const allSearchQueries = [
+            ...new Set(featureTasks.flatMap((t) => t.behavior.uniqueSearchQueries)),
+        ];
+        const allExternalDomains = [
+            ...new Set(featureTasks.flatMap((t) => t.behavior.externalDomains)),
+        ];
+        const canonicalSlugs = CANONICAL_DOC_MAP[feature] || [];
+        const matchedCanonical = canonicalSlugs.filter((slug) => allDocSlugs.some((visited) => visited.includes(slug)));
+        const canonicalCoverage = canonicalSlugs.length > 0
+            ? matchedCanonical.length / canonicalSlugs.length
+            : 0;
+        const count = featureTasks.length || 1;
+        return {
+            allDocSlugs,
+            allExternalDomains,
+            allSearchQueries,
+            avgDocPages: featureTasks.reduce((s, t) => s + t.behavior.docPagesVisited, 0) /
+                count,
+            avgNetworkMs: featureTasks.reduce((s, t) => s + t.behavior.totalNetworkMs, 0) /
+                count,
+            avgSearches: featureTasks.reduce((s, t) => s + t.behavior.searchesPerformed, 0) /
+                count,
+            canonicalCoverage,
+            canonicalSlugs,
+            feature,
+            tasks: featureTasks,
+        };
+    })
+        .sort((a, b) => a.feature.localeCompare(b.feature));
+    return { features, hasData: true, tasks };
+}
+function detectFeatureArea(description) {
+    const desc = description.toLowerCase();
+    if (desc.includes("studio"))
+        return "studio-setup";
+    if (desc.includes("visual") ||
+        desc.includes("presentation") ||
+        desc.includes("live preview"))
+        return "visual-editing";
+    if (desc.includes("function") || desc.includes("webhook"))
+        return "functions";
+    if (desc.includes("next") || desc.includes("app router"))
+        return "nextjs-live";
+    if (desc.includes("remix") ||
+        desc.includes("nuxt") ||
+        desc.includes("svelte"))
+        return "frameworks";
+    return "other";
+}
+// ---------------------------------------------------------------------------
+// Report output
+// ---------------------------------------------------------------------------
+function main() {
+    const ROOT = join(dirname(new URL(import.meta.url).pathname), "..", "..");
+    const resultsPath = process.argv[2] || join(ROOT, "results", "latest", "eval-results.json");
+    if (!existsSync(resultsPath)) {
+        console.error(`Results file not found: ${resultsPath}`);
+        console.error("Run an evaluation first: pnpm eval:observed");
+        process.exit(1);
+    }
+    console.log(`Reading results from: ${resultsPath}`);
+    console.log();
+    const analysis = analyzeResults(resultsPath);
+    if (!analysis.hasData) {
+        console.log("No agent behavior data found in the results.");
+        console.log("Make sure you ran the evaluation with the observed config:");
+        console.log("  pnpm eval:observed");
+        process.exit(0);
+    }
+    printReport(analysis);
+    // Persist detailed report as JSON
+    const outDir = join(ROOT, "results", "latest");
+    mkdirSync(outDir, { recursive: true });
+    const reportData = {
+        features: analysis.features.map((f) => ({
+            avgDocPages: f.avgDocPages,
+            avgNetworkMs: f.avgNetworkMs,
+            avgSearches: f.avgSearches,
+            canonicalCoverage: f.canonicalCoverage,
+            canonicalSlugs: f.canonicalSlugs,
+            docSlugsVisited: f.allDocSlugs,
+            externalDomains: f.allExternalDomains,
+            feature: f.feature,
+            searchQueries: f.allSearchQueries,
+            taskCount: f.tasks.length,
+        })),
+        tasks: analysis.tasks.map((t) => ({
+            behavior: t.behavior,
+            description: t.description,
+            feature: t.feature,
+            hasDocs: t.hasDocs,
+        })),
+        timestamp: new Date().toISOString(),
+        totalTasks: analysis.tasks.length,
+    };
+    writeFileSync(join(outDir, "agent-behavior-report.json"), JSON.stringify(reportData, null, 2));
+    console.log("Agent behavior report written to results/latest/agent-behavior-report.json");
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function printReport(analysis) {
+    console.log("=".repeat(80));
+    console.log("            AGENT BEHAVIOR OBSERVATION REPORT");
+    console.log("=".repeat(80));
+    console.log();
+    // ---- Overview table ----
+    console.log("OVERVIEW BY FEATURE AREA");
+    console.log("-".repeat(80));
+    const h = "| Feature Area        | Tasks | Avg Docs | Avg Search | Avg Net(ms) | Canon% |";
+    const sep = "|---------------------|-------|----------|------------|-------------|--------|";
+    console.log(h);
+    console.log(sep);
+    for (const f of analysis.features) {
+        console.log(`| ${f.feature.padEnd(19)} | ` +
+            `${f.tasks.length.toString().padStart(5)} | ` +
+            `${f.avgDocPages.toFixed(1).padStart(8)} | ` +
+            `${f.avgSearches.toFixed(1).padStart(10)} | ` +
+            `${Math.round(f.avgNetworkMs).toString().padStart(11)} | ` +
+            `${(f.canonicalCoverage * 100).toFixed(0).padStart(5)}% |`);
+    }
+    console.log();
+    // ---- Canonical coverage breakdown ----
+    console.log("CANONICAL DOCUMENTATION COVERAGE");
+    console.log("-".repeat(80));
+    console.log();
+    for (const f of analysis.features) {
+        console.log(`  ${f.feature} (${(f.canonicalCoverage * 100).toFixed(0)}% canonical coverage):`);
+        if (f.canonicalSlugs.length === 0) {
+            console.log("    (no canonical docs defined)");
+        }
+        else {
+            for (const slug of f.canonicalSlugs) {
+                const found = f.allDocSlugs.some((visited) => visited.includes(slug));
+                const marker = found ? "[x]" : "[ ]";
+                console.log(`    ${marker} ${slug}`);
+            }
+        }
+        if (f.allDocSlugs.length > 0) {
+            const nonCanonical = f.allDocSlugs.filter((slug) => !f.canonicalSlugs.some((c) => slug.includes(c)));
+            if (nonCanonical.length > 0) {
+                console.log("    Additional docs visited:");
+                for (const slug of nonCanonical) {
+                    console.log(`      + ${slug}`);
+                }
+            }
+        }
+        console.log();
+    }
+    // ---- Search strategy ----
+    const allSearches = analysis.features.flatMap((f) => f.allSearchQueries);
+    if (allSearches.length > 0) {
+        console.log("SEARCH STRATEGY");
+        console.log("-".repeat(80));
+        console.log();
+        for (const f of analysis.features) {
+            if (f.allSearchQueries.length === 0)
+                continue;
+            console.log(`  ${f.feature}:`);
+            for (const q of f.allSearchQueries) {
+                console.log(`    -> "${q}"`);
+            }
+        }
+        console.log();
+    }
+    // ---- Per-task detail ----
+    console.log("PER-TASK DETAIL");
+    console.log("-".repeat(80));
+    console.log();
+    for (const f of analysis.features) {
+        console.log(`  ## ${f.feature}`);
+        console.log();
+        for (const t of f.tasks) {
+            const variant = t.hasDocs ? "[gold]" : "[baseline]";
+            console.log(`  ${variant} ${t.description}`);
+            console.log(`    Requests: ${t.behavior.totalRequests} | ` +
+                `Doc pages: ${t.behavior.docPagesVisited} | ` +
+                `Searches: ${t.behavior.searchesPerformed} | ` +
+                `External: ${t.behavior.externalRequestCount}`);
+            if (t.behavior.docSlugsVisited.length > 0) {
+                console.log(`    Docs: ${t.behavior.docSlugsVisited.join(", ")}`);
+            }
+            if (t.behavior.uniqueSearchQueries.length > 0) {
+                console.log(`    Queries: ${t.behavior.uniqueSearchQueries.map((q) => `"${q}"`).join(", ")}`);
+            }
+            console.log();
+        }
+    }
+    // ---- External domains ----
+    const allDomains = [
+        ...new Set(analysis.features.flatMap((f) => f.allExternalDomains)),
+    ];
+    if (allDomains.length > 0) {
+        console.log("EXTERNAL DOMAINS");
+        console.log("-".repeat(80));
+        console.log();
+        for (const d of allDomains) {
+            console.log(`  - ${d}`);
+        }
+        console.log();
+    }
+    // ---- Summary stats ----
+    console.log("OVERALL STATISTICS");
+    console.log("-".repeat(80));
+    console.log();
+    const totalTasks = analysis.tasks.length;
+    const tasksUsingDocs = analysis.tasks.filter((t) => t.behavior.usedDocs).length;
+    const tasksUsingSearch = analysis.tasks.filter((t) => t.behavior.usedSearch).length;
+    const avgCanonical = analysis.features.reduce((s, f) => s + f.canonicalCoverage, 0) /
+        (analysis.features.length || 1);
+    console.log(`  Total tasks observed:    ${totalTasks}`);
+    console.log(`  Tasks that used docs:    ${tasksUsingDocs}/${totalTasks} (${((tasksUsingDocs / totalTasks) * 100).toFixed(0)}%)`);
+    console.log(`  Tasks that used search:  ${tasksUsingSearch}/${totalTasks} (${((tasksUsingSearch / totalTasks) * 100).toFixed(0)}%)`);
+    console.log(`  Avg canonical coverage:  ${(avgCanonical * 100).toFixed(1)}%`);
+    console.log();
+}
+main();

package/dist/scripts/baseline.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Baseline.ts
+ *
+ * Manages historical baseline snapshots of evaluation scores.
+ * Allows saving, comparing, and listing score baselines over time.
+ *
+ * Usage:
+ *   pnpm baseline:save                    # save current scores as baseline
+ *   pnpm baseline:save --tag "pre-groq"   # save with a descriptive tag
+ *   pnpm baseline:compare                 # compare current vs latest baseline
+ *   pnpm baseline:history                 # list all saved baselines
+ */
+interface BaselineMetadata {
+    areaCount: number;
+    avgScore: number;
+    filename: string;
+    graderCost?: number;
+    tag?: string;
+    timestamp: string;
+    totalCost?: number;
+}
+interface CompareResult {
+    comparisons?: ScoreComparison[];
+    message: string;
+    overallDelta?: number;
+    success: boolean;
+}
+interface ScoreComparison {
+    baseline: number;
+    costBaseline?: number;
+    costCurrent?: number;
+    costDelta?: number;
+    current: number;
+    delta: number;
+    feature: string;
+}
+export declare function compareBaseline(baselineFile?: string): CompareResult;
+export declare function listBaselines(): BaselineMetadata[];
+export declare function saveBaseline(tag?: string): {
+    success: boolean;
+    message: string;
+};
+export {};