@sanity/ailf 0.1.0

package/dist/pipeline/release-report.js

@@ -0,0 +1,222 @@
+/**
+ * pipeline/release-report.ts
+ *
+ * Cross-area release impact reports.
+ *
+ * Phase 4c of the Scenario Matrix implementation.
+ *
+ * Consolidates impact data from multi-area content releases into a single
+ * report that combines document classification (4a), before/after deltas (2b),
+ * attribution (2c), and probe results (4b) into the document × area × task
+ * impact matrix specified by Scenario 2.4.
+ *
+ * @see docs/exec-plans/completed/scenario-matrix-implementation/phase-4-content-release-integration.md
+ */
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Build a cross-area release impact report.
+ *
+ * Combines classification, comparison, attribution, and probe data into
+ * a single consolidated report.
+ *
+ * @param classification - Document classification from Phase 4a
+ * @param comparison - Before/after comparison (if available)
+ * @param attribution - Per-document attribution (if available)
+ * @param probes - Tier B probe results (if any)
+ * @param noiseThreshold - Threshold for "unchanged" classification
+ * @returns Consolidated release impact report
+ */
+export function buildReleaseImpactReport(classification, comparison, attribution, probes, noiseThreshold) {
+    const threshold = noiseThreshold ?? comparison?.noiseThreshold ?? 2;
+    // Build per-area impact from comparison data
+    const areas = [];
+    const regressions = [];
+    const confirmedUnchanged = [];
+    if (comparison) {
+        for (const areaDelta of comparison.areas) {
+            const regressed = areaDelta.delta < -threshold;
+            // Find tasks and their attributed documents for this area
+            const areaTasks = [];
+            if (attribution) {
+                const areaAttrs = attribution.attributions.filter((a) => a.area === areaDelta.area);
+                for (const attr of areaAttrs) {
+                    areaTasks.push({
+                        attributedDocs: attr.attributedDocs,
+                        delta: attr.delta,
+                        taskId: attr.taskId,
+                    });
+                }
+            }
+            // If no attribution data, create a single task entry per area
+            if (areaTasks.length === 0) {
+                areaTasks.push({
+                    attributedDocs: [],
+                    delta: areaDelta.delta,
+                    taskId: `${areaDelta.area} (area-level)`,
+                });
+            }
+            areas.push({
+                area: areaDelta.area,
+                delta: areaDelta.delta,
+                regressed,
+                tasks: areaTasks,
+            });
+            if (regressed) {
+                regressions.push(areaDelta.area);
+            }
+            if (Math.abs(areaDelta.delta) <= threshold) {
+                confirmedUnchanged.push(areaDelta.area);
+            }
+        }
+    }
+    // Determine which areas were not evaluated
+    const evaluatedAreas = new Set(areas.map((a) => a.area));
+    const allAffectedAreas = new Set(classification.documents.flatMap((d) => d.affectedAreas));
+    const notEvaluated = [...allAffectedAreas]
+        .filter((a) => !evaluatedAreas.has(a))
+        .sort();
+    // Calculate overall delta
+    const overallDelta = comparison ? comparison.deltas.overall : 0;
+    return {
+        areas,
+        confirmedUnchanged,
+        documents: classification.documents,
+        generatedAt: new Date().toISOString(),
+        notEvaluated,
+        overallDelta,
+        probes: probes ?? [],
+        regressions,
+    };
+}
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+/**
+ * Format a release impact report for console output.
+ */
+export function formatReleaseImpactConsole(report) {
+    const lines = [];
+    lines.push("═══════════════════════════════════════════════════════════════");
+    lines.push(" CONTENT RELEASE IMPACT REPORT");
+    lines.push("═══════════════════════════════════════════════════════════════");
+    lines.push("");
+    const deltaStr = report.overallDelta >= 0
+        ? `+${report.overallDelta.toFixed(1)}`
+        : report.overallDelta.toFixed(1);
+    lines.push(`  Overall impact: ${deltaStr} points`);
+    lines.push(`  Documents: ${report.documents.length}`);
+    lines.push(`  Areas affected: ${report.areas.length}`);
+    lines.push("");
+    // Regressions
+    if (report.regressions.length > 0) {
+        lines.push("  ⚠️  REGRESSIONS DETECTED:");
+        for (const area of report.regressions) {
+            const areaData = report.areas.find((a) => a.area === area);
+            if (areaData) {
+                lines.push(`    ${area}: ${areaData.delta.toFixed(1)}`);
+            }
+        }
+        lines.push("");
+    }
+    // Impact matrix
+    if (report.areas.length > 0) {
+        lines.push("  Document                        | Area             | Task                    | Delta");
+        lines.push("  ────────────────────────────────┼──────────────────┼─────────────────────────┼──────");
+        for (const area of report.areas) {
+            for (const task of area.tasks) {
+                const docs = task.attributedDocs.length > 0
+                    ? task.attributedDocs.join(", ")
+                    : "(unattributed)";
+                const deltaStr = task.delta >= 0 ? `+${task.delta.toFixed(1)}` : task.delta.toFixed(1);
+                lines.push(`  ${docs.padEnd(32)} | ${area.area.padEnd(16)} | ${task.taskId.padEnd(23)} | ${deltaStr}`);
+            }
+        }
+        lines.push("");
+    }
+    // Probe results
+    if (report.probes.length > 0) {
+        lines.push("  TIER B PROBES (directional only):");
+        for (const probe of report.probes) {
+            lines.push(`    ${probe.documentSlugs.join(", ")}: ${probe.usability}`);
+        }
+        lines.push("");
+    }
+    // Unchanged and not-evaluated areas
+    if (report.confirmedUnchanged.length > 0) {
+        lines.push(`  Areas with no score change: ${report.confirmedUnchanged.join(", ")}`);
+    }
+    if (report.notEvaluated.length > 0) {
+        lines.push(`  Areas not evaluated: ${report.notEvaluated.join(", ")}`);
+    }
+    if (report.confirmedUnchanged.length > 0 || report.notEvaluated.length > 0) {
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a release impact report as markdown.
+ */
+export function formatReleaseImpactMarkdown(report) {
+    const lines = [];
+    lines.push("### 📋 Content Release Impact Report");
+    lines.push("");
+    const deltaStr = report.overallDelta >= 0
+        ? `+${report.overallDelta.toFixed(1)}`
+        : report.overallDelta.toFixed(1);
+    lines.push(`**Overall impact: ${deltaStr} points** · ${report.documents.length} documents · ${report.areas.length} areas`);
+    lines.push("");
+    // Regressions
+    if (report.regressions.length > 0) {
+        lines.push("#### ⚠️ Regressions");
+        lines.push("");
+        for (const area of report.regressions) {
+            const areaData = report.areas.find((a) => a.area === area);
+            if (areaData) {
+                lines.push(`- **${area}**: ${areaData.delta.toFixed(1)}`);
+            }
+        }
+        lines.push("");
+    }
+    // Impact table
+    if (report.areas.length > 0) {
+        lines.push("#### Impact Matrix");
+        lines.push("");
+        lines.push("| Document | Area | Task | Delta |");
+        lines.push("|----------|------|------|-------|");
+        for (const area of report.areas) {
+            for (const task of area.tasks) {
+                const docs = task.attributedDocs.length > 0
+                    ? task.attributedDocs.map((d) => `\`${d}\``).join(", ")
+                    : "—";
+                const deltaStr = task.delta >= 0 ? `+${task.delta.toFixed(1)}` : task.delta.toFixed(1);
+                const regressIcon = area.regressed ? " ⚠️" : "";
+                lines.push(`| ${docs} | ${area.area} | ${task.taskId} | ${deltaStr}${regressIcon} |`);
+            }
+        }
+        lines.push("");
+    }
+    // Probes
+    if (report.probes.length > 0) {
+        lines.push("#### 🔍 Tier B Probes (directional only)");
+        lines.push("");
+        for (const probe of report.probes) {
+            lines.push(`- **${probe.documentSlugs.join(", ")}**: ${probe.usability}`);
+        }
+        lines.push("");
+    }
+    // Status areas
+    const statusParts = [];
+    if (report.confirmedUnchanged.length > 0) {
+        statusParts.push(`**Unchanged:** ${report.confirmedUnchanged.join(", ")}`);
+    }
+    if (report.notEvaluated.length > 0) {
+        statusParts.push(`**Not evaluated:** ${report.notEvaluated.join(", ")}`);
+    }
+    if (statusParts.length > 0) {
+        lines.push(statusParts.join(" · "));
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/pipeline/repo-eval-comment.d.ts

@@ -0,0 +1,37 @@
+/**
+ * pipeline/repo-eval-comment.ts
+ *
+ * Generates markdown PR comments for repo-based AILF evaluations.
+ *
+ * This is separate from the main pr-comment.ts (which generates the
+ * internal AILF repo's PR comment). Repo eval comments are designed
+ * for external teams and emphasize:
+ *
+ * - Documentation quality (not code quality)
+ * - Per-task threshold pass/fail status
+ * - Clear "what does this mean?" context
+ * - skip-ailf bypass instructions
+ *
+ * @see docs/exec-plans/completed/tasks-as-content/phase-6-pr-quality-gates.md
+ * @see packages/eval/src/pipeline/repo-threshold-evaluator.ts
+ */
+import type { ComparisonReport, ScoreSummary } from "./types.js";
+import type { RepoThresholdEvaluation } from "./repo-threshold-evaluator.js";
+export interface RepoCommentOptions {
+    /** Threshold evaluation results */
+    thresholdEval: RepoThresholdEvaluation;
+    /** Score summary from the pipeline */
+    scoreSummary: ScoreSummary;
+    /** Comparison report (if baseline exists) */
+    comparison?: ComparisonReport;
+    /** Link to the full report in Studio */
+    reportUrl?: string;
+    /** Link to the Promptfoo results */
+    promptfooUrl?: string;
+    /** Whether this is the first run (no baseline to compare against) */
+    firstRun?: boolean;
+}
+/**
+ * Generate a markdown PR comment for a repo-based evaluation.
+ */
+export declare function generateRepoEvalComment(options: RepoCommentOptions): string;

package/dist/pipeline/repo-eval-comment.js

@@ -0,0 +1,165 @@
+/**
+ * pipeline/repo-eval-comment.ts
+ *
+ * Generates markdown PR comments for repo-based AILF evaluations.
+ *
+ * This is separate from the main pr-comment.ts (which generates the
+ * internal AILF repo's PR comment). Repo eval comments are designed
+ * for external teams and emphasize:
+ *
+ * - Documentation quality (not code quality)
+ * - Per-task threshold pass/fail status
+ * - Clear "what does this mean?" context
+ * - skip-ailf bypass instructions
+ *
+ * @see docs/exec-plans/completed/tasks-as-content/phase-6-pr-quality-gates.md
+ * @see packages/eval/src/pipeline/repo-threshold-evaluator.ts
+ */
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Generate a markdown PR comment for a repo-based evaluation.
+ */
+export function generateRepoEvalComment(options) {
+    const { thresholdEval, scoreSummary, comparison, reportUrl, promptfooUrl, firstRun, } = options;
+    const lines = [];
+    // Comment marker for update-in-place
+    lines.push("<!-- ailf-repo-eval-report -->");
+    // Header
+    const statusEmoji = thresholdEval.checkPassed ? "✅" : "⚠️";
+    lines.push(`## 📊 AI Literacy Evaluation`);
+    lines.push("");
+    // Summary line
+    lines.push(`${statusEmoji} Your team's documentation quality score is **${thresholdEval.overallScore}/100**` +
+        (thresholdEval.defaultThreshold > 0
+            ? ` (threshold: ${thresholdEval.defaultThreshold})`
+            : "") +
+        ". " +
+        contextMessage(thresholdEval, comparison, firstRun));
+    lines.push("");
+    // Cost info
+    const totalCost = scoreSummary.scores.reduce((sum, s) => sum + (s.totalCost ?? 0), 0);
+    const graderCost = scoreSummary.overall.cost?.graderTotal ?? 0;
+    const combinedCost = totalCost + graderCost;
+    const testCount = scoreSummary.scores.reduce((sum, s) => sum + s.testCount, 0);
+    const costStr = combinedCost > 0 ? ` · Cost: ${formatCost(combinedCost)}` : "";
+    lines.push(`**Overall:** ${thresholdEval.overallScore}/100 · ` +
+        `**Doc lift:** +${Math.round(scoreSummary.overall.avgDocLift)} points · ` +
+        `${testCount} tests${costStr}`);
+    lines.push("");
+    // Per-task threshold table
+    if (thresholdEval.results.length > 0) {
+        lines.push("### Per-Task Results");
+        lines.push("");
+        lines.push("| Task | Score | Threshold | Status |");
+        lines.push("|------|-------|-----------|--------|");
+        for (const result of thresholdEval.results) {
+            lines.push(`| ${result.taskId} | ${result.actualScore} | ${result.threshold} | ${statusIcon(result)} |`);
+        }
+        lines.push("");
+    }
+    // Dimension details (collapsible)
+    const withDimensions = thresholdEval.results.filter((r) => r.dimensionResults && r.dimensionResults.length > 0);
+    if (withDimensions.length > 0) {
+        lines.push("<details>");
+        lines.push("<summary>📊 Per-dimension breakdown</summary>");
+        lines.push("");
+        lines.push("| Task | Dimension | Score | Threshold | Status |");
+        lines.push("|------|-----------|-------|-----------|--------|");
+        for (const result of withDimensions) {
+            for (const dim of result.dimensionResults) {
+                lines.push(`| ${result.taskId} | ${dim.dimension} | ${dim.actual} | ${dim.threshold} | ${dim.passed ? "✅" : "❌"} |`);
+            }
+        }
+        lines.push("");
+        lines.push("</details>");
+        lines.push("");
+    }
+    // Comparison section (when baseline exists)
+    if (comparison && !firstRun) {
+        const delta = comparison.deltas.overall;
+        const direction = delta > 0 ? "up" : delta < 0 ? "down" : "unchanged";
+        const arrow = delta > 0 ? "📈" : delta < 0 ? "📉" : "➡️";
+        lines.push(`${arrow} Compared to last run: overall **${delta > 0 ? "+" : ""}${Math.round(delta)}** points (${direction}).`);
+        lines.push("");
+        if (comparison.regressed.length > 0) {
+            lines.push(`> ⚠️ **Regressions detected:** ${comparison.regressed.map((a) => `\`${a}\``).join(", ")}`);
+            lines.push("");
+        }
+    }
+    // Score breakdown (collapsible)
+    if (scoreSummary.scores.length > 0) {
+        lines.push("<details>");
+        lines.push("<summary>📋 Full score breakdown</summary>");
+        lines.push("");
+        lines.push("| Feature Area | Score | Task Completion | Code Correctness | Doc Coverage | Doc Lift |");
+        lines.push("|-------------|-------|-----------------|------------------|-------------|----------|");
+        const sorted = [...scoreSummary.scores].sort((a, b) => b.totalScore - a.totalScore);
+        for (const s of sorted) {
+            lines.push(`| ${s.feature} | **${Math.round(s.totalScore)}** | ${Math.round(s.taskCompletion)} | ${Math.round(s.codeCorrectness)} | ${Math.round(s.docCoverage)} | ${liftArrow(s.docLift)} |`);
+        }
+        lines.push("");
+        lines.push("</details>");
+        lines.push("");
+    }
+    // Footer with links and bypass instructions
+    const links = [];
+    if (reportUrl)
+        links.push(`[View full report in Studio](${reportUrl})`);
+    if (promptfooUrl)
+        links.push(`[Detailed results](${promptfooUrl})`);
+    if (links.length > 0) {
+        lines.push(links.join(" · "));
+        lines.push("");
+    }
+    lines.push(`> 💡 This check evaluates **documentation quality**, not code correctness. ` +
+        `Add the \`skip-ailf\` label to bypass.`);
+    lines.push("");
+    // Timestamp
+    const now = new Date();
+    lines.push(`*Generated by [AI Literacy Framework](https://github.com/sanity-labs/ai-literacy-framework) · ${now.toUTCString()}*`);
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function contextMessage(eval_, comparison, firstRun) {
+    if (firstRun) {
+        return "This is the first evaluation for this task set. Future runs will show trends.";
+    }
+    if (eval_.checkPassed) {
+        return "Documentation quality meets your team's bar.";
+    }
+    if (comparison) {
+        return ("This reflects the current state of your product's documentation, " +
+            "not changes in this PR.");
+    }
+    return ("Some tasks are below their configured thresholds. " +
+        "Review the documentation for the affected areas.");
+}
+function statusIcon(result) {
+    switch (result.status) {
+        case "passed":
+            return "✅ Pass";
+        case "warning":
+            return "⚠️ Below threshold";
+        case "failed":
+            return "❌ Blocked";
+    }
+}
+function formatCost(cost) {
+    if (cost === 0)
+        return "$0.00";
+    if (cost < 0.01)
+        return `$${cost.toFixed(4)}`;
+    return `$${cost.toFixed(2)}`;
+}
+function liftArrow(lift) {
+    const rounded = Math.round(lift);
+    if (rounded > 0)
+        return `↑ +${rounded}`;
+    if (rounded < 0)
+        return `↓ ${rounded}`;
+    return "→ 0";
+}

package/dist/pipeline/repo-threshold-evaluator.d.ts

@@ -0,0 +1,89 @@
+/**
+ * pipeline/repo-threshold-evaluator.ts
+ *
+ * Evaluates per-task scores against thresholds configured in repo task
+ * definitions (`.ailf/tasks/*.yaml` → `execution.threshold`).
+ *
+ * This is distinct from the readiness-gate threshold system in
+ * `config/thresholds.yaml`. Repo thresholds are per-task, defined by
+ * the product team, and drive PR check pass/fail status. Framework
+ * thresholds are per-area, defined by the AILF team, and drive
+ * readiness reports.
+ *
+ * @see docs/exec-plans/completed/tasks-as-content/phase-6-pr-quality-gates.md
+ * @see packages/eval/src/adapters/task-sources/repo-schemas.ts
+ */
+import type { ScoreSummary } from "./types.js";
+/** Threshold configuration from a repo task's execution block */
+export interface TaskThresholdConfig {
+    /** Task ID */
+    taskId: string;
+    /** Whether failing this threshold should block the PR */
+    blocking: boolean;
+    /** Minimum overall score (0–100) */
+    score?: number;
+    /** Per-dimension minimums */
+    dimensions?: {
+        taskCompletion?: number;
+        codeCorrectness?: number;
+        docCoverage?: number;
+    };
+}
+/** Result of evaluating a single task against its threshold */
+export interface TaskThresholdResult {
+    /** Task ID */
+    taskId: string;
+    /** Feature area */
+    area: string;
+    /** Actual overall score */
+    actualScore: number;
+    /** Configured threshold (or framework default) */
+    threshold: number;
+    /** Whether the score meets or exceeds the threshold */
+    passed: boolean;
+    /** Whether this result blocks the PR */
+    blocking: boolean;
+    /** Per-dimension results (when dimension thresholds are configured) */
+    dimensionResults?: DimensionThresholdResult[];
+    /** Status classification */
+    status: "passed" | "warning" | "failed";
+}
+/** Result of evaluating a single dimension against its threshold */
+export interface DimensionThresholdResult {
+    dimension: string;
+    actual: number;
+    threshold: number;
+    passed: boolean;
+}
+/** Aggregate result of evaluating all tasks */
+export interface RepoThresholdEvaluation {
+    /** Whether the overall check passes (no blocking failures) */
+    checkPassed: boolean;
+    /** Individual task results */
+    results: TaskThresholdResult[];
+    /** Summary counts */
+    summary: {
+        total: number;
+        passed: number;
+        warnings: number;
+        failed: number;
+    };
+    /** Overall score (average across all evaluated tasks) */
+    overallScore: number;
+    /** Default threshold used when tasks don't specify one */
+    defaultThreshold: number;
+}
+/**
+ * Evaluate task scores against repo-configured thresholds.
+ *
+ * For each task with a threshold configured in its `execution` block,
+ * compare the actual score against the threshold and determine pass/fail.
+ *
+ * Tasks without explicit thresholds use the `configDefaultThreshold`
+ * (from `.ailf/config.yaml`) or the framework default (0 = no gate).
+ *
+ * @param scoreSummary - The evaluation score summary
+ * @param thresholds - Per-task threshold configs (from repo task definitions)
+ * @param configDefaultThreshold - Default threshold from .ailf/config.yaml
+ */
+export declare function evaluateRepoThresholds(scoreSummary: ScoreSummary, thresholds: TaskThresholdConfig[], configDefaultThreshold?: number): RepoThresholdEvaluation;

package/dist/pipeline/repo-threshold-evaluator.js

@@ -0,0 +1,162 @@
+/**
+ * pipeline/repo-threshold-evaluator.ts
+ *
+ * Evaluates per-task scores against thresholds configured in repo task
+ * definitions (`.ailf/tasks/*.yaml` → `execution.threshold`).
+ *
+ * This is distinct from the readiness-gate threshold system in
+ * `config/thresholds.yaml`. Repo thresholds are per-task, defined by
+ * the product team, and drive PR check pass/fail status. Framework
+ * thresholds are per-area, defined by the AILF team, and drive
+ * readiness reports.
+ *
+ * @see docs/exec-plans/completed/tasks-as-content/phase-6-pr-quality-gates.md
+ * @see packages/eval/src/adapters/task-sources/repo-schemas.ts
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Framework default threshold when neither task nor config specifies one */
+const FRAMEWORK_DEFAULT_THRESHOLD = 0;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate task scores against repo-configured thresholds.
+ *
+ * For each task with a threshold configured in its `execution` block,
+ * compare the actual score against the threshold and determine pass/fail.
+ *
+ * Tasks without explicit thresholds use the `configDefaultThreshold`
+ * (from `.ailf/config.yaml`) or the framework default (0 = no gate).
+ *
+ * @param scoreSummary - The evaluation score summary
+ * @param thresholds - Per-task threshold configs (from repo task definitions)
+ * @param configDefaultThreshold - Default threshold from .ailf/config.yaml
+ */
+export function evaluateRepoThresholds(scoreSummary, thresholds, configDefaultThreshold = FRAMEWORK_DEFAULT_THRESHOLD) {
+    const thresholdMap = new Map(thresholds.map((t) => [t.taskId, t]));
+    // Build a task-to-area mapping from the score summary
+    const taskScoreMap = buildTaskScoreMap(scoreSummary);
+    const results = [];
+    // Evaluate each task that has scores
+    for (const [taskId, taskScore] of taskScoreMap) {
+        const config = thresholdMap.get(taskId);
+        const threshold = config?.score ?? configDefaultThreshold;
+        const blocking = config?.blocking ?? false;
+        const actualScore = Math.round(taskScore.score);
+        const passed = actualScore >= threshold;
+        // Evaluate dimension thresholds
+        let dimensionResults;
+        if (config?.dimensions) {
+            dimensionResults = evaluateDimensions(taskScore, config.dimensions);
+        }
+        const dimensionsFailed = dimensionResults?.some((d) => !d.passed) ?? false;
+        const overallPassed = passed && !dimensionsFailed;
+        results.push({
+            taskId,
+            area: taskScore.area,
+            actualScore,
+            threshold,
+            passed: overallPassed,
+            blocking,
+            dimensionResults,
+            status: overallPassed ? "passed" : blocking ? "failed" : "warning",
+        });
+    }
+    // Also add entries for threshold-configured tasks that weren't evaluated
+    for (const config of thresholds) {
+        if (!taskScoreMap.has(config.taskId)) {
+            results.push({
+                taskId: config.taskId,
+                area: "unknown",
+                actualScore: 0,
+                threshold: config.score ?? configDefaultThreshold,
+                passed: false,
+                blocking: config.blocking,
+                status: config.blocking ? "failed" : "warning",
+            });
+        }
+    }
+    // Sort: failed first, then warnings, then passed
+    results.sort((a, b) => {
+        const order = { failed: 0, warning: 1, passed: 2 };
+        return order[a.status] - order[b.status];
+    });
+    const passed = results.filter((r) => r.status === "passed").length;
+    const warnings = results.filter((r) => r.status === "warning").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    // Check passes if no blocking failures
+    const checkPassed = failed === 0;
+    // Overall score
+    const evaluatedResults = results.filter((r) => r.actualScore > 0);
+    const overallScore = evaluatedResults.length > 0
+        ? Math.round(evaluatedResults.reduce((sum, r) => sum + r.actualScore, 0) /
+            evaluatedResults.length)
+        : 0;
+    return {
+        checkPassed,
+        results,
+        summary: {
+            total: results.length,
+            passed,
+            warnings,
+            failed,
+        },
+        overallScore,
+        defaultThreshold: configDefaultThreshold,
+    };
+}
+/**
+ * Build a map of task ID → score from the ScoreSummary.
+ *
+ * ScoreSummary groups scores by feature area, not by task. We derive
+ * per-task scores from the area scores. When multiple tasks share an
+ * area, they share the area's composite score (this is a simplification;
+ * per-task scoring requires individual test results not available in
+ * ScoreSummary).
+ */
+function buildTaskScoreMap(summary) {
+    const map = new Map();
+    for (const areaScore of summary.scores) {
+        // Use the feature area name as a proxy task ID if we don't have
+        // per-task granularity. In practice, repo tasks map 1:1 to areas
+        // in most cases (each .ailf/tasks/*.yaml file is one area).
+        map.set(areaScore.feature, {
+            area: areaScore.feature,
+            score: areaScore.totalScore,
+            taskCompletion: areaScore.taskCompletion,
+            codeCorrectness: areaScore.codeCorrectness,
+            docCoverage: areaScore.docCoverage,
+        });
+    }
+    return map;
+}
+function evaluateDimensions(score, thresholds) {
+    const results = [];
+    if (thresholds.taskCompletion !== undefined) {
+        results.push({
+            dimension: "task-completion",
+            actual: Math.round(score.taskCompletion),
+            threshold: thresholds.taskCompletion,
+            passed: Math.round(score.taskCompletion) >= thresholds.taskCompletion,
+        });
+    }
+    if (thresholds.codeCorrectness !== undefined) {
+        results.push({
+            dimension: "code-correctness",
+            actual: Math.round(score.codeCorrectness),
+            threshold: thresholds.codeCorrectness,
+            passed: Math.round(score.codeCorrectness) >= thresholds.codeCorrectness,
+        });
+    }
+    if (thresholds.docCoverage !== undefined) {
+        results.push({
+            dimension: "doc-coverage",
+            actual: Math.round(score.docCoverage),
+            threshold: thresholds.docCoverage,
+            passed: Math.round(score.docCoverage) >= thresholds.docCoverage,
+        });
+    }
+    return results;
+}