@sanity/ailf 2.0.2 → 2.2.0

package/dist/scripts/validate-task-sources.js

@@ -1,210 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * Validation script: Compare YamlTaskSource vs ContentLakeTaskSource
- *
- * Loads tasks from both sources and compares them field-by-field to verify
- * that the Content Lake migration produced identical LiteracyTaskDefinition[] output.
- *
- * This is Phase 3b of the tasks-as-content exec plan — parallel validation
- * before deleting YAML files.
- *
- * Usage:
- *   cd packages/eval
- *   npx tsx src/scripts/validate-task-sources.ts
- *
- * Prerequisites:
- *   - Migration script has been run (ailf.task documents exist in CL)
- *   - SANITY_API_TOKEN configured for Content Lake reads
- *
- * @see docs/archive/exec-plans/tasks-as-content/phase-3-migration.md
- */
-import { config as dotenvConfig } from "dotenv";
-import { existsSync } from "fs";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-import { isSlugRef } from "../_vendor/ailf-core/index.js";
-import { ContentLakeTaskSource } from "../adapters/task-sources/content-lake-task-source.js";
-import { YamlTaskSource } from "../adapters/task-sources/yaml-task-source.js";
-import { getSanityClient } from "../sanity/client.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, "..", "..");
-// Load .env from repository root (same as CLI entry point)
-const envPath = resolve(ROOT, "..", "..", ".env");
-if (existsSync(envPath)) {
-    dotenvConfig({ override: true, path: envPath });
-}
-/**
- * Compare two LiteracyTaskDefinition arrays field-by-field.
- * Returns a list of differences.
- */
-function compareTasks(yamlTasks, clTasks) {
-    const yamlMap = new Map(yamlTasks.map((t) => [t.id, t]));
-    const clMap = new Map(clTasks.map((t) => [t.id, t]));
-    const missingInCl = yamlTasks.filter((t) => !clMap.has(t.id)).map((t) => t.id);
-    const missingInYaml = clTasks
-        .filter((t) => !yamlMap.has(t.id))
-        .map((t) => t.id);
-    const diffs = [];
-    for (const [id, yamlTask] of yamlMap) {
-        const clTask = clMap.get(id);
-        if (!clTask)
-            continue;
-        // Compare each field
-        compareField(diffs, id, "title", yamlTask.title, clTask.title);
-        compareField(diffs, id, "area", yamlTask.area, clTask.area);
-        compareField(diffs, id, "docCoverage", yamlTask.docCoverage, clTask.docCoverage);
-        // prompt.text — normalize whitespace for comparison (YAML multiline vs CL text)
-        const yamlPrompt = (yamlTask.prompt?.text ?? "").trim();
-        const clPrompt = (clTask.prompt?.text ?? "").trim();
-        if (yamlPrompt !== clPrompt) {
-            diffs.push({
-                clValue: truncate(clPrompt, 100),
-                field: "prompt.text",
-                taskId: id,
-                yamlValue: truncate(yamlPrompt, 100),
-            });
-        }
-        // context.docs — compare slug sets (slug refs only for comparison)
-        const yamlSlugs = (yamlTask.context?.docs ?? [])
-            .filter(isSlugRef)
-            .map((d) => d.slug)
-            .sort();
-        const clSlugs = (clTask.context?.docs ?? [])
-            .filter(isSlugRef)
-            .map((d) => d.slug)
-            .sort();
-        if (JSON.stringify(yamlSlugs) !== JSON.stringify(clSlugs)) {
-            diffs.push({
-                clValue: clSlugs,
-                field: "canonicalDocs.slugs",
-                taskId: id,
-                yamlValue: yamlSlugs,
-            });
-        }
-        // assertions — compare type + template arrays
-        const yamlAssertTypes = (yamlTask.assertions ?? [])
-            .map((a) => {
-            const base = a.type;
-            if ("template" in a)
-                return `${base}:${a.template}`;
-            return base;
-        })
-            .sort();
-        const clAssertTypes = (clTask.assertions ?? [])
-            .map((a) => {
-            const base = a.type;
-            if ("template" in a)
-                return `${base}:${a.template}`;
-            return base;
-        })
-            .sort();
-        if (JSON.stringify(yamlAssertTypes) !== JSON.stringify(clAssertTypes)) {
-            diffs.push({
-                clValue: clAssertTypes,
-                field: "assertions.types",
-                taskId: id,
-                yamlValue: yamlAssertTypes,
-            });
-        }
-        // referenceSolution — CL always returns "" since solution content is a
-        // separate document. YAML has a path. This is an intentional difference.
-        // We only flag it if YAML also has no solution and CL somehow does.
-        // (In practice, we expect all YAML tasks to have paths and CL to have "")
-    }
-    return { diffs, missingInCl, missingInYaml };
-}
-function compareField(diffs, taskId, field, yamlValue, clValue) {
-    if (JSON.stringify(yamlValue) !== JSON.stringify(clValue)) {
-        diffs.push({ clValue, field, taskId, yamlValue });
-    }
-}
-function truncate(s, maxLen) {
-    return s.length <= maxLen ? s : s.slice(0, maxLen) + "...";
-}
-// ---------------------------------------------------------------------------
-// Main validation
-// ---------------------------------------------------------------------------
-async function validate() {
-    console.log("\n🔍 Task Source Validation");
-    console.log("=".repeat(50));
-    // Load from YAML
-    console.log("\n1️⃣  Loading from YAML (tasks/*.yaml)...");
-    const yamlSource = new YamlTaskSource(ROOT);
-    const yamlTasks = (await yamlSource.loadTasks()).filter((t) => t.mode === "literacy");
-    console.log(`  Loaded ${yamlTasks.length} tasks`);
-    // Load from Content Lake (use write token since task docs may require it)
-    console.log("\n2️⃣  Loading from Content Lake (ailf.task)...");
-    const client = getSanityClient({
-        token: process.env.AILF_REPORT_SANITY_API_TOKEN ??
-            process.env.SANITY_API_TOKEN ??
-            undefined,
-    });
-    const clSource = new ContentLakeTaskSource(client);
-    const clTasks = (await clSource.loadTasks()).filter((t) => t.mode === "literacy");
-    console.log(`  Loaded ${clTasks.length} tasks`);
-    // Compare
-    console.log("\n3️⃣  Comparing...");
-    const { diffs, missingInCl, missingInYaml } = compareTasks(yamlTasks, clTasks);
-    // Report
-    console.log("\n" + "=".repeat(50));
-    console.log("📊 Validation Results");
-    console.log(`  YAML tasks:    ${yamlTasks.length}`);
-    console.log(`  CL tasks:      ${clTasks.length}`);
-    console.log(`  Missing in CL: ${missingInCl.length}`);
-    console.log(`  Missing in YAML: ${missingInYaml.length}`);
-    console.log(`  Field diffs:   ${diffs.length}`);
-    if (missingInCl.length > 0) {
-        console.log("\n  ❌ Tasks in YAML but missing from Content Lake:");
-        for (const id of missingInCl) {
-            console.log(`    - ${id}`);
-        }
-    }
-    if (missingInYaml.length > 0) {
-        console.log("\n  ℹ️  Tasks in Content Lake but not in YAML (expected for new CL tasks):");
-        for (const id of missingInYaml) {
-            console.log(`    - ${id}`);
-        }
-    }
-    if (diffs.length > 0) {
-        console.log("\n  ⚠️  Field differences:");
-        for (const d of diffs) {
-            console.log(`    ${d.taskId}.${d.field}:`);
-            console.log(`      YAML: ${JSON.stringify(d.yamlValue)}`);
-            console.log(`      CL:   ${JSON.stringify(d.clValue)}`);
-        }
-    }
-    // Known intentional differences:
-    // - referenceSolution: CL returns "" (content is a separate document)
-    // - canonicalDocs.slugs: CL may have fewer slugs if some didn't resolve
-    //   during migration (broken article references). This is actually an
-    //   improvement — broken refs are visible in Studio instead of silently
-    //   failing at fetch time.
-    const INTENTIONAL_FIELDS = new Set([
-        "referenceSolution",
-        "canonicalDocs.slugs",
-    ]);
-    const intentional = diffs.filter((d) => INTENTIONAL_FIELDS.has(d.field));
-    const unexpected = diffs.filter((d) => !INTENTIONAL_FIELDS.has(d.field));
-    if (unexpected.length === 0 && missingInCl.length === 0) {
-        console.log("\n  ✅ All tasks match (ignoring known intentional differences)");
-        if (intentional.length > 0) {
-            console.log(`     (${intentional.length} intentional diff(s):`);
-            for (const d of intentional) {
-                console.log(`      - ${d.taskId}.${d.field}`);
-            }
-            console.log("     )");
-        }
-    }
-    else {
-        console.log("\n  ❌ Validation FAILED — see differences above");
-        process.exit(1);
-    }
-    console.log("");
-}
-// ---------------------------------------------------------------------------
-// Run
-// ---------------------------------------------------------------------------
-validate().catch((err) => {
-    console.error("Validation failed:", err);
-    process.exit(1);
-});

package/dist/scripts/validate.d.ts

@@ -1,13 +0,0 @@
-/**
- * validate.ts
- *
- * CLI script that validates pipeline configuration.
- * Checks that all YAML files are consistent, all task-to-mapping
- * cross-references are valid, and reference solutions exist.
- *
- * Usage:
- *   pnpm validate              # validate everything
- *   pnpm validate --strict     # treat warnings as errors
- *   pnpm validate --contexts   # also check that context files exist
- */
-export {};

package/dist/scripts/validate.js

@@ -1,79 +0,0 @@
-/**
- * validate.ts
- *
- * CLI script that validates pipeline configuration.
- * Checks that all YAML files are consistent, all task-to-mapping
- * cross-references are valid, and reference solutions exist.
- *
- * Usage:
- *   pnpm validate              # validate everything
- *   pnpm validate --strict     # treat warnings as errors
- *   pnpm validate --contexts   # also check that context files exist
- */
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-import { checkContextsExist, checkEnvironment } from "../pipeline/checks.js";
-import { validateConfiguration } from "../pipeline/validate.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, "..", "..");
-// ---------------------------------------------------------------------------
-// CLI argument parsing
-// ---------------------------------------------------------------------------
-const args = process.argv.slice(2);
-const strict = args.includes("--strict");
-const checkCtx = args.includes("--contexts");
-// ---------------------------------------------------------------------------
-// Run validation
-// ---------------------------------------------------------------------------
-console.log("=== ai-literacy-framework — Configuration Validator ===\n");
-const result = validateConfiguration(ROOT);
-// Optionally check contexts
-if (checkCtx) {
-    // Dynamically import to get feature areas
-    const { ALL_FEATURE_AREAS } = await import("../sanity/queries.js");
-    const contextIssues = checkContextsExist(ROOT, ALL_FEATURE_AREAS);
-    result.issues.push(...contextIssues);
-    result.valid =
-        result.valid && contextIssues.every((i) => i.severity !== "error");
-}
-// Check environment
-const envIssues = checkEnvironment(ROOT);
-result.issues.push(...envIssues);
-// ---------------------------------------------------------------------------
-// Report results
-// ---------------------------------------------------------------------------
-const errors = result.issues.filter((i) => i.severity === "error");
-const warnings = result.issues.filter((i) => i.severity === "warning");
-if (errors.length > 0) {
-    console.log(`❌ ${errors.length} error(s):\n`);
-    for (const issue of errors) {
-        console.log(`  ERROR [${issue.source}] ${issue.message}`);
-        if (issue.path)
-            console.log(`        at ${issue.path}`);
-    }
-    console.log();
-}
-if (warnings.length > 0) {
-    console.log(`⚠️  ${warnings.length} warning(s):\n`);
-    for (const issue of warnings) {
-        console.log(`  WARN  [${issue.source}] ${issue.message}`);
-        if (issue.path)
-            console.log(`        at ${issue.path}`);
-    }
-    console.log();
-}
-if (errors.length === 0 && warnings.length === 0) {
-    console.log("✅ All checks passed — configuration is valid.\n");
-}
-if (errors.length === 0 && warnings.length > 0) {
-    console.log(`✅ Configuration is valid (${warnings.length} warning(s)).\n`);
-}
-// In strict mode, warnings are treated as errors
-const exitCode = strict
-    ? result.issues.length > 0
-        ? 1
-        : 0
-    : errors.length > 0
-        ? 1
-        : 0;
-process.exit(exitCode);

package/dist/scripts/webhook-server.d.ts

@@ -1,26 +0,0 @@
-/**
- * webhook-server.ts
- *
- * Local development server for testing the webhook handler.
- *
- * Starts an HTTP server that receives Sanity webhook payloads, processes
- * them through the WebhookHandler, and logs results. Useful for local
- * development and testing the full event-driven trigger flow.
- *
- * Usage:
- *   pnpm webhook-server                    # start on port 3333
- *   WEBHOOK_PORT=8080 pnpm webhook-server  # custom port
- *
- * Test with curl:
- *   curl -X POST http://localhost:3333/webhook \
- *     -H "Content-Type: application/json" \
- *     -d '{"operation":"update","result":{"_id":"abc","_type":"article","slug":{"current":"groq-introduction"}}}'
- *
- * Endpoints:
- *   POST /webhook    — handle a Sanity webhook payload
- *   GET  /health     — handler diagnostics (budget, pending, tracked slugs)
- *   GET  /mappings   — list all tracked document slugs and their areas
- *
- * @see docs/design-docs/report-store/visibility-workflows.md
- */
-export {};

package/dist/scripts/webhook-server.js

@@ -1,147 +0,0 @@
-/**
- * webhook-server.ts
- *
- * Local development server for testing the webhook handler.
- *
- * Starts an HTTP server that receives Sanity webhook payloads, processes
- * them through the WebhookHandler, and logs results. Useful for local
- * development and testing the full event-driven trigger flow.
- *
- * Usage:
- *   pnpm webhook-server                    # start on port 3333
- *   WEBHOOK_PORT=8080 pnpm webhook-server  # custom port
- *
- * Test with curl:
- *   curl -X POST http://localhost:3333/webhook \
- *     -H "Content-Type: application/json" \
- *     -d '{"operation":"update","result":{"_id":"abc","_type":"article","slug":{"current":"groq-introduction"}}}'
- *
- * Endpoints:
- *   POST /webhook    — handle a Sanity webhook payload
- *   GET  /health     — handler diagnostics (budget, pending, tracked slugs)
- *   GET  /mappings   — list all tracked document slugs and their areas
- *
- * @see docs/design-docs/report-store/visibility-workflows.md
- */
-import { createServer } from "http";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-import { allTrackedSlugs, buildReverseMapping, } from "../pipeline/reverse-mapping.js";
-import { WebhookHandler } from "../webhook/handler.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, "..", "..");
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-const PORT = parseInt(process.env.WEBHOOK_PORT ?? "3333", 10);
-const GITHUB_TOKEN = process.env.GITHUB_TOKEN ?? "";
-const DRY_RUN = !GITHUB_TOKEN;
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-const handler = new WebhookHandler({
-    dailyBudget: parseInt(process.env.WEBHOOK_DAILY_BUDGET ?? "20", 10),
-    debounceMs: parseInt(process.env.WEBHOOK_DEBOUNCE_MS ?? "10000", 10), // 10s for local dev
-    githubToken: GITHUB_TOKEN,
-    rootDir: ROOT,
-});
-// ---------------------------------------------------------------------------
-// HTTP Server
-// ---------------------------------------------------------------------------
-const server = createServer((req, res) => {
-    void handleRequest(req, res);
-});
-async function handleRequest(req, res) {
-    const url = new URL(req.url ?? "/", `http://localhost:${PORT}`);
-    // CORS headers for local dev
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-        res.writeHead(200);
-        res.end();
-        return;
-    }
-    // Health check
-    if (url.pathname === "/health" && req.method === "GET") {
-        const diagnostics = handler.diagnostics();
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ dryRun: DRY_RUN, ...diagnostics }, null, 2));
-        return;
-    }
-    // Mappings
-    if (url.pathname === "/mappings" && req.method === "GET") {
-        const reverseMapping = buildReverseMapping(ROOT);
-        const slugs = allTrackedSlugs(reverseMapping);
-        const mappings = Object.fromEntries(slugs.map((slug) => [slug, reverseMapping.get(slug)]));
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ mappings, slugCount: slugs.length }, null, 2));
-        return;
-    }
-    // Webhook handler
-    if (url.pathname === "/webhook" && req.method === "POST") {
-        const body = await readBody(req);
-        let payload;
-        try {
-            payload = JSON.parse(body);
-        }
-        catch {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Invalid JSON" }));
-            return;
-        }
-        if (DRY_RUN) {
-            console.log("\n  🔶 DRY RUN — would dispatch (no GITHUB_TOKEN set)");
-        }
-        const result = handler.handle(payload);
-        console.log(`  → ${result.status}:`, JSON.stringify(result));
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(result, null, 2));
-        return;
-    }
-    // 404
-    res.writeHead(404, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({
-        endpoints: ["POST /webhook", "GET /health", "GET /mappings"],
-        error: "Not found",
-    }));
-}
-// ---------------------------------------------------------------------------
-// Start
-// ---------------------------------------------------------------------------
-server.listen(PORT, () => {
-    const reverseMapping = buildReverseMapping(ROOT);
-    const slugCount = allTrackedSlugs(reverseMapping).length;
-    console.log();
-    console.log("=== AILF Webhook Server ===");
-    console.log();
-    console.log(`  Port:           ${PORT}`);
-    console.log(`  Mode:           ${DRY_RUN ? "DRY RUN (set GITHUB_TOKEN to dispatch)" : "LIVE"}`);
-    console.log(`  Tracked slugs:  ${slugCount}`);
-    console.log(`  Debounce:       ${handler.diagnostics().pendingSlugs}`);
-    console.log();
-    console.log("  Endpoints:");
-    console.log(`    POST http://localhost:${PORT}/webhook   — handle webhook`);
-    console.log(`    GET  http://localhost:${PORT}/health    — diagnostics`);
-    console.log(`    GET  http://localhost:${PORT}/mappings  — slug → area map`);
-    console.log();
-});
-// Graceful shutdown
-process.on("SIGINT", () => {
-    console.log("\n  Shutting down — flushing debounce window...");
-    void handler.shutdown().then(() => {
-        server.close();
-        process.exit(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        req.on("data", (chunk) => chunks.push(chunk));
-        req.on("end", () => resolve(Buffer.concat(chunks).toString()));
-        req.on("error", reject);
-    });
-}

package/dist/scripts/weekly-digest.d.ts

@@ -1,24 +0,0 @@
-/**
- * weekly-digest.ts
- *
- * CLI script to generate and deliver a weekly evaluation digest.
- *
- * Queries the Sanity Content Lake for all reports within the configured
- * lookback window, computes trend analysis, and delivers the digest
- * via configured channels (Slack, stdout, or both).
- *
- * Usage:
- *   pnpm weekly-digest                    # send to configured Slack webhook
- *   pnpm weekly-digest --dry-run          # print to stdout only
- *   pnpm weekly-digest --lookback 14      # 14-day lookback window
- *   pnpm weekly-digest --json             # output raw JSON
- *
- * Environment variables:
- *   SLACK_WEBHOOK_URL     — Slack incoming webhook URL
- *   SANITY_API_TOKEN      — Sanity read token
- *   AILF_TRIGGER_TYPE     — set to "scheduled" by the cron workflow
- *   AILF_SCHEDULE         — the schedule name (e.g., "weekly-digest")
- *
- * @see docs/design-docs/report-store/implementation.md — Phase 5
- */
-export {};

package/dist/scripts/weekly-digest.js

@@ -1,144 +0,0 @@
-/**
- * weekly-digest.ts
- *
- * CLI script to generate and deliver a weekly evaluation digest.
- *
- * Queries the Sanity Content Lake for all reports within the configured
- * lookback window, computes trend analysis, and delivers the digest
- * via configured channels (Slack, stdout, or both).
- *
- * Usage:
- *   pnpm weekly-digest                    # send to configured Slack webhook
- *   pnpm weekly-digest --dry-run          # print to stdout only
- *   pnpm weekly-digest --lookback 14      # 14-day lookback window
- *   pnpm weekly-digest --json             # output raw JSON
- *
- * Environment variables:
- *   SLACK_WEBHOOK_URL     — Slack incoming webhook URL
- *   SANITY_API_TOKEN      — Sanity read token
- *   AILF_TRIGGER_TYPE     — set to "scheduled" by the cron workflow
- *   AILF_SCHEDULE         — the schedule name (e.g., "weekly-digest")
- *
- * @see docs/design-docs/report-store/implementation.md — Phase 5
- */
-import { config as dotenvConfig } from "dotenv";
-import { existsSync } from "fs";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-import { generateDigest } from "../schedules/digest.js";
-import { getDigestConfig } from "../schedules/loader.js";
-import { formatWeeklyDigest } from "../sinks/slack/format.js";
-// Load root .env (same override behavior as pipeline.ts)
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const envPath = resolve(__dirname, "..", "..", "..", "..", ".env");
-if (existsSync(envPath)) {
-    dotenvConfig({ override: true, path: envPath });
-}
-// ---------------------------------------------------------------------------
-// CLI argument parsing
-// ---------------------------------------------------------------------------
-const args = process.argv.slice(2);
-function getOption(name) {
-    const idx = args.indexOf(`--${name}`);
-    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : undefined;
-}
-function hasFlag(name) {
-    return args.includes(`--${name}`);
-}
-const DRY_RUN = hasFlag("dry-run");
-const JSON_OUTPUT = hasFlag("json");
-const lookbackOverride = getOption("lookback");
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-async function main() {
-    console.log();
-    console.log("=== AI Literacy Weekly Digest ===");
-    console.log();
-    // Load digest config
-    const digestConfig = getDigestConfig();
-    const lookbackDays = lookbackOverride
-        ? parseInt(lookbackOverride, 10)
-        : (digestConfig?.lookbackDays ?? 7);
-    console.log(`  Lookback: ${lookbackDays} days`);
-    console.log(`  Mode: ${DRY_RUN ? "dry run (stdout only)" : "live"}`);
-    console.log();
-    // Generate digest — uses AILF_REPORT_* env vars for report store access,
-    // independent of SANITY_DATASET/SANITY_PROJECT_ID (which control doc evaluation)
-    const digest = await generateDigest({
-        dataset: process.env.AILF_REPORT_DATASET,
-        lookbackDays,
-        projectId: process.env.AILF_REPORT_PROJECT_ID,
-        token: process.env.AILF_REPORT_SANITY_API_TOKEN ?? process.env.SANITY_API_TOKEN,
-    });
-    if (!digest) {
-        console.log("  No reports found in the lookback window. Nothing to send.");
-        process.exit(0);
-    }
-    // Output
-    console.log(`  Reports found: ${digest.reportCount}`);
-    console.log(`  Overall: ${Math.round(digest.overallLatest)} (${digest.overallTrend})`);
-    console.log(`  Improved: ${digest.improved.join(", ") || "none"}`);
-    console.log(`  Regressed: ${digest.regressed.join(", ") || "none"}`);
-    console.log(`  Stable: ${digest.stable.join(", ") || "none"}`);
-    console.log();
-    if (JSON_OUTPUT) {
-        console.log(JSON.stringify(digest, null, 2));
-        return;
-    }
-    // Format for Slack
-    const message = formatWeeklyDigest(digest);
-    if (DRY_RUN) {
-        console.log("  --- Slack Message Preview ---");
-        console.log(`  Text: ${message.text}`);
-        console.log();
-        for (const block of message.blocks) {
-            if (block.text) {
-                console.log(`  [${block.type}] ${block.text.text}`);
-            }
-            if (block.fields) {
-                for (const field of block.fields) {
-                    console.log(`    [field] ${field.text}`);
-                }
-            }
-            if (block.elements) {
-                for (const el of block.elements) {
-                    console.log(`    [element] ${el.text}`);
-                }
-            }
-        }
-        console.log();
-        return;
-    }
-    // Deliver via Slack
-    const webhookUrl = digestConfig?.slackWebhookUrl ?? process.env.SLACK_WEBHOOK_URL;
-    if (!webhookUrl) {
-        console.warn("  ⚠️  No Slack webhook URL configured. Set SLACK_WEBHOOK_URL or configure in schedules.yaml");
-        console.log("  Printing digest to stdout instead:");
-        console.log();
-        console.log(`  ${message.text}`);
-        return;
-    }
-    console.log("  Sending to Slack...");
-    try {
-        const response = await fetch(webhookUrl, {
-            body: JSON.stringify(message),
-            headers: { "Content-Type": "application/json" },
-            method: "POST",
-        });
-        if (response.ok) {
-            console.log("  ✅ Digest sent successfully");
-        }
-        else {
-            const text = await response.text();
-            console.warn(`  ⚠️  Slack delivery failed: ${response.status} ${text}`);
-        }
-    }
-    catch (error) {
-        console.warn(`  ⚠️  Slack delivery error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-main().catch((error) => {
-    console.error("Fatal error:", error);
-    process.exit(1);
-});