@sanity/ailf 0.4.1 → 1.0.0

package/dist/_vendor/ailf-core/schemas/eval-config.js

@@ -10,6 +10,7 @@
  * (studio-eval-config) so Content Lake documents validate identically.
  */
 import { z } from "zod";
+import { RAW_EVAL_MODES } from "../../ailf-shared/index.js";
 export const EvalConfigSchema = z
     .object({
     /** Allowed origins for agentic mode */
@@ -46,8 +47,12 @@ export const EvalConfigSchema = z
     graderReplications: z.number().int().positive().optional(),
     /** Custom headers for doc fetching */
     headers: z.record(z.string(), z.string()).optional(),
-    /** Evaluation mode */
-    mode: z.enum(["baseline", "agentic", "observed", "full"]).optional(),
+    /**
+     * Evaluation mode — accepts both canonical and legacy names.
+     * Legacy names ("baseline", "agentic", "observed", "full") must pass
+     * through normalizeMode() before entering typed pipeline code.
+     */
+    mode: z.enum(RAW_EVAL_MODES).optional(),
     /** Disable release-aware auto-scoping */
     noAutoScope: z.boolean().optional(),
     /** Disable local cache */

package/dist/_vendor/ailf-core/schemas/pipeline-request.d.ts

@@ -49,10 +49,15 @@ export declare const PipelineRequestSchema: z.ZodObject<{
     inlineTasks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     jobId: z.ZodOptional<z.ZodString>;
     mode: z.ZodOptional<z.ZodEnum<{
-        agentic: "agentic";
+        custom: "custom";
+        literacy: "literacy";
+        "mcp-server": "mcp-server";
+        "agent-harness": "agent-harness";
+        "knowledge-probe": "knowledge-probe";
         baseline: "baseline";
-        full: "full";
+        agentic: "agentic";
         observed: "observed";
+        full: "full";
     }>>;
     noAutoScope: z.ZodOptional<z.ZodBoolean>;
     noCache: z.ZodOptional<z.ZodBoolean>;
@@ -70,9 +75,9 @@ export declare const PipelineRequestSchema: z.ZodObject<{
     source: z.ZodOptional<z.ZodString>;
     sourceReportId: z.ZodOptional<z.ZodString>;
     taskMode: z.ZodOptional<z.ZodEnum<{
+        inline: "inline";
         "content-lake": "content-lake";
         yaml: "yaml";
-        inline: "inline";
     }>>;
     tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     urls: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/_vendor/ailf-core/schemas/pipeline-request.js

@@ -13,6 +13,7 @@
  * @see packages/eval/src/pipeline/map-request-to-config.ts — maps to ResolvedConfig
  */
 import { z } from "zod";
+import { RAW_EVAL_MODES } from "../../ailf-shared/index.js";
 // ---------------------------------------------------------------------------
 // Debug options — boolean shorthand or structured object
 // ---------------------------------------------------------------------------
@@ -69,7 +70,11 @@ export const PipelineRequestSchema = z.object({
     headers: z.record(z.string(), z.string()).optional(),
     inlineTasks: z.array(z.record(z.string(), z.unknown())).optional(),
     jobId: z.string().optional(),
-    mode: z.enum(["baseline", "agentic", "observed", "full"]).optional(),
+    /**
+     * Evaluation mode — accepts both canonical and legacy names.
+     * Legacy names must pass through normalizeMode() before entering typed pipeline code.
+     */
+    mode: z.enum(RAW_EVAL_MODES).optional(),
     noAutoScope: z.boolean().optional(),
     noCache: z.boolean().optional(),
     noRemoteCache: z.boolean().optional(),

package/dist/_vendor/ailf-core/schemas/pipeline.d.ts

@@ -25,21 +25,37 @@ export declare const RubricTemplateSchema: z.ZodObject<{
 }, z.core.$strip>;
 /** Inferred TypeScript type for a rubric template. */
 export type RubricTemplate = z.infer<typeof RubricTemplateSchema>;
+/**
+ * A named weight profile — maps dimension names to weights (must sum to 1.0).
+ * Each profile is a self-contained scoring formula used for a specific
+ * (mode, variant) pair.
+ */
+declare const WeightProfileSchema: z.ZodRecord<z.ZodString, z.ZodNumber>;
+/** Inferred type for a single weight profile. */
+export type WeightProfile = z.infer<typeof WeightProfileSchema>;
 /**
  * Schema for the full config/rubrics.yaml config file.
  *
- * Each dimension is scored on a uniform 0–100 scale. The `weights` section
- * defines how dimensions are combined into a composite score (must sum to 1.0).
+ * Each dimension is scored on a uniform 0–100 scale. Named scoring profiles
+ * define how dimensions are combined into composite scores. Mode-profile
+ * bindings declare which profile to use for each (mode, variant) pair.
+ *
+ * Supports both the new `profiles` format and the legacy flat `weights`
+ * format for backward compatibility.
+ *
+ * @see docs/design-docs/named-scoring-profiles.md
  */
 export declare const RubricConfigSchema: z.ZodObject<{
     footer: z.ZodString;
+    "mode-profiles": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+    profiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
     templates: z.ZodRecord<z.ZodString, z.ZodObject<{
         criteria_label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         dimension: z.ZodOptional<z.ZodString>;
         header: z.ZodString;
         scale: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
-    weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
 }, z.core.$strip>;
 /** Inferred TypeScript type for the rubrics config. */
 export type RubricConfig = z.infer<typeof RubricConfigSchema>;
@@ -51,17 +67,17 @@ export declare const FeatureSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     priority: z.ZodEnum<{
+        critical: "critical";
         high: "high";
-        low: "low";
         medium: "medium";
-        critical: "critical";
+        low: "low";
     }>;
     sections: z.ZodArray<z.ZodString>;
     status: z.ZodEnum<{
         covered: "covered";
-        "out-of-scope": "out-of-scope";
-        planned: "planned";
         uncovered: "uncovered";
+        planned: "planned";
+        "out-of-scope": "out-of-scope";
     }>;
     taskCount: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -76,17 +92,17 @@ export declare const FeatureRegistrySchema: z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
         priority: z.ZodEnum<{
+            critical: "critical";
             high: "high";
-            low: "low";
             medium: "medium";
-            critical: "critical";
+            low: "low";
         }>;
         sections: z.ZodArray<z.ZodString>;
         status: z.ZodEnum<{
             covered: "covered";
-            "out-of-scope": "out-of-scope";
-            planned: "planned";
             uncovered: "uncovered";
+            planned: "planned";
+            "out-of-scope": "out-of-scope";
         }>;
         taskCount: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
@@ -424,14 +440,11 @@ export declare const TaskFileSchema: z.ZodArray<z.ZodUnion<readonly [z.ZodObject
 export type TaskFile = z.infer<typeof TaskFileSchema>;
 /**
  * Schema for per-dimension threshold values.
+ * Uses a dynamic record to support all evaluation modes, not just literacy.
  * Keys use kebab-case to match YAML convention; the threshold engine
  * normalizes to camelCase for comparison against FeatureScore fields.
  */
-export declare const ThresholdDimensionsSchema: z.ZodObject<{
-    "code-correctness": z.ZodOptional<z.ZodNumber>;
-    "doc-coverage": z.ZodOptional<z.ZodNumber>;
-    "task-completion": z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+export declare const ThresholdDimensionsSchema: z.ZodRecord<z.ZodString, z.ZodNumber>;
 /** Inferred TypeScript type for threshold dimension overrides. */
 export type ThresholdDimensions = z.infer<typeof ThresholdDimensionsSchema>;
 /**
@@ -441,11 +454,7 @@ export type ThresholdDimensions = z.infer<typeof ThresholdDimensionsSchema>;
 export declare const ThresholdDefaultsSchema: z.ZodObject<{
     ceiling: z.ZodOptional<z.ZodNumber>;
     composite: z.ZodNumber;
-    dimensions: z.ZodOptional<z.ZodObject<{
-        "code-correctness": z.ZodOptional<z.ZodNumber>;
-        "doc-coverage": z.ZodOptional<z.ZodNumber>;
-        "task-completion": z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     "doc-lift": z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /** Inferred TypeScript type for threshold defaults. */
@@ -485,21 +494,13 @@ export declare const ThresholdConfigSchema: z.ZodObject<{
     areas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         ceiling: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
         composite: z.ZodOptional<z.ZodNumber>;
-        dimensions: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-            "code-correctness": z.ZodOptional<z.ZodNumber>;
-            "doc-coverage": z.ZodOptional<z.ZodNumber>;
-            "task-completion": z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>>;
+        dimensions: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>>;
         "doc-lift": z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>>;
     defaults: z.ZodObject<{
         ceiling: z.ZodOptional<z.ZodNumber>;
         composite: z.ZodNumber;
-        dimensions: z.ZodOptional<z.ZodObject<{
-            "code-correctness": z.ZodOptional<z.ZodNumber>;
-            "doc-coverage": z.ZodOptional<z.ZodNumber>;
-            "task-completion": z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
+        dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         "doc-lift": z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     regression: z.ZodOptional<z.ZodObject<{

package/dist/_vendor/ailf-core/schemas/pipeline.js

@@ -31,23 +31,66 @@ export const RubricTemplateSchema = z.object({
         .array(z.string().min(1))
         .min(1, "scale must have at least one entry"),
 });
+/**
+ * A named weight profile — maps dimension names to weights (must sum to 1.0).
+ * Each profile is a self-contained scoring formula used for a specific
+ * (mode, variant) pair.
+ */
+const WeightProfileSchema = z
+    .record(z.string(), z.number().min(0).max(1))
+    .refine((w) => {
+    const sum = Object.values(w).reduce((s, v) => s + v, 0);
+    return Math.abs(sum - 1.0) < 0.001;
+}, { message: "profile weights must sum to 1.0" });
+/**
+ * Mode-to-profile bindings — maps (mode, perspective) pairs to profile names.
+ *
+ * Flat form (most modes):
+ *   { "mcp-server": { gold: "mcp-behavior" } }
+ *
+ * Nested form (literacy mode with variant sub-keys):
+ *   { literacy: { baseline: { gold: "default", baseline: "output-only" }, agentic: { gold: "default" } } }
+ *
+ * The nested form adds a variant level between mode and perspective,
+ * allowing a single canonical mode to host multiple scoring variants.
+ */
+const ModeProfileEntrySchema = z.union([
+    z.string(),
+    z.record(z.string(), z.string()),
+]);
+const ModeProfilesSchema = z.record(z.string(), z.record(z.string(), ModeProfileEntrySchema));
 /**
  * Schema for the full config/rubrics.yaml config file.
  *
- * Each dimension is scored on a uniform 0–100 scale. The `weights` section
- * defines how dimensions are combined into a composite score (must sum to 1.0).
+ * Each dimension is scored on a uniform 0–100 scale. Named scoring profiles
+ * define how dimensions are combined into composite scores. Mode-profile
+ * bindings declare which profile to use for each (mode, variant) pair.
+ *
+ * Supports both the new `profiles` format and the legacy flat `weights`
+ * format for backward compatibility.
+ *
+ * @see docs/design-docs/named-scoring-profiles.md
  */
-export const RubricConfigSchema = z.object({
+export const RubricConfigSchema = z
+    .object({
     footer: z.string().min(1, "footer must be a non-empty string"),
+    "mode-profiles": ModeProfilesSchema.optional(),
+    profiles: z
+        .record(z.string(), WeightProfileSchema)
+        .refine((p) => "default" in p, {
+        message: "profiles must include a 'default' profile",
+    })
+        .optional(),
     templates: z
         .record(z.string(), RubricTemplateSchema)
         .refine((t) => Object.keys(t).length > 0, {
         message: "templates must have at least one entry",
     }),
-    weights: z.record(z.string(), z.number().min(0).max(1)).refine((w) => {
-        const sum = Object.values(w).reduce((s, v) => s + v, 0);
-        return Math.abs(sum - 1.0) < 0.001;
-    }, { message: "weights must sum to 1.0" }),
+    // Legacy: flat weight map. Treated as a single profile named "default".
+    weights: WeightProfileSchema.optional(),
+})
+    .refine((c) => c.profiles !== undefined || c.weights !== undefined, {
+    message: "rubrics.yaml must have either 'profiles' or 'weights'",
 });
 // ---------------------------------------------------------------------------
 // Feature registry schema — validates config/features.yaml (Phase 3c)
@@ -246,14 +289,11 @@ export const TaskFileSchema = z
 // ---------------------------------------------------------------------------
 /**
  * Schema for per-dimension threshold values.
+ * Uses a dynamic record to support all evaluation modes, not just literacy.
  * Keys use kebab-case to match YAML convention; the threshold engine
  * normalizes to camelCase for comparison against FeatureScore fields.
  */
-export const ThresholdDimensionsSchema = z.object({
-    "code-correctness": z.number().min(0).max(100).optional(),
-    "doc-coverage": z.number().min(0).max(100).optional(),
-    "task-completion": z.number().min(0).max(100).optional(),
-});
+export const ThresholdDimensionsSchema = z.record(z.string(), z.number().min(0).max(100));
 /**
  * Schema for threshold defaults (and per-area overrides).
  * All fields are optional in per-area overrides; defaults must have composite.

package/dist/_vendor/ailf-core/schemas/schedules.d.ts

@@ -18,10 +18,15 @@ export declare const ScheduleEntrySchema: z.ZodObject<{
     cron: z.ZodString;
     enabled: z.ZodDefault<z.ZodBoolean>;
     mode: z.ZodDefault<z.ZodEnum<{
-        agentic: "agentic";
+        custom: "custom";
+        literacy: "literacy";
+        "mcp-server": "mcp-server";
+        "agent-harness": "agent-harness";
+        "knowledge-probe": "knowledge-probe";
         baseline: "baseline";
-        full: "full";
+        agentic: "agentic";
         observed: "observed";
+        full: "full";
     }>>;
     name: z.ZodString;
     publish: z.ZodDefault<z.ZodBoolean>;
@@ -53,10 +58,15 @@ export declare const SchedulesFileSchema: z.ZodObject<{
         cron: z.ZodString;
         enabled: z.ZodDefault<z.ZodBoolean>;
         mode: z.ZodDefault<z.ZodEnum<{
-            agentic: "agentic";
+            custom: "custom";
+            literacy: "literacy";
+            "mcp-server": "mcp-server";
+            "agent-harness": "agent-harness";
+            "knowledge-probe": "knowledge-probe";
             baseline: "baseline";
-            full: "full";
+            agentic: "agentic";
             observed: "observed";
+            full: "full";
         }>>;
         name: z.ZodString;
         publish: z.ZodDefault<z.ZodBoolean>;

package/dist/_vendor/ailf-core/schemas/schedules.js

@@ -11,6 +11,7 @@
  * @see docs/design-docs/report-store/implementation.md — Phase 5
  */
 import { z } from "zod";
+import { RAW_EVAL_MODES } from "../../ailf-shared/index.js";
 // ---------------------------------------------------------------------------
 // Cron expression validation
 // ---------------------------------------------------------------------------
@@ -34,8 +35,11 @@ export const ScheduleEntrySchema = z.object({
     cron: CronSchema,
     /** Whether this schedule is active */
     enabled: z.boolean().default(true),
-    /** Evaluation mode */
-    mode: z.enum(["agentic", "baseline", "full", "observed"]).default("baseline"),
+    /**
+     * Evaluation mode — accepts both canonical and legacy names.
+     * Legacy names must pass through normalizeMode() before entering typed pipeline code.
+     */
+    mode: z.enum(RAW_EVAL_MODES).default("baseline"),
     /** Human-readable schedule name (used as report tag) */
     name: z
         .string()

package/dist/_vendor/ailf-core/schemas/sinks.d.ts

@@ -17,10 +17,10 @@
 import { z } from "zod";
 /** All supported sink types as a Zod union. */
 export declare const SinkTypeSchema: z.ZodEnum<{
-    webhook: "webhook";
     bigquery: "bigquery";
     "github-comment": "github-comment";
     slack: "slack";
+    webhook: "webhook";
 }>;
 /** Supported sink type string literal union. */
 export type SinkType = z.infer<typeof SinkTypeSchema>;

package/dist/_vendor/ailf-core/services/comparison-formatters.js

@@ -25,12 +25,21 @@ export function formatComparisonMarkdown(report) {
     lines.push("");
     lines.push(`**Overall: ${Math.round(report.baseline.overall.avgScore)} → ${Math.round(report.experiment.overall.avgScore)}** (${overallIcon} ${deltaStr(overall)})`);
     lines.push("");
-    // Per-area table
-    lines.push("| Feature | Baseline | Current | Delta | Task | Code | Docs |");
-    lines.push("|---------|----------|---------|-------|------|------|------|");
+    // Derive dimension columns from the first area's keys (all areas share the
+    // same scoring profile, so the key set is uniform).
+    const dimKeys = report.areas.length > 0
+        ? Object.keys(report.areas[0].dimensions)
+        : Object.keys(report.deltas.perDimension);
+    // Per-area table — columns are dynamic
+    const dimHeaders = dimKeys.map(kebabToTitleCase);
+    const headerRow = ["Feature", "Baseline", "Current", "Delta", ...dimHeaders];
+    const separatorRow = headerRow.map(() => "------");
+    lines.push(`| ${headerRow.join(" | ")} |`);
+    lines.push(`|${separatorRow.join("|")}|`);
     for (const a of report.areas) {
         const icon = changeIcon(a.change);
-        lines.push(`| ${a.area} | ${a.baseline} | ${a.experiment} | ${icon} ${deltaStr(a.delta)} | ${deltaStr(a.dimensions.taskCompletion.delta)} | ${deltaStr(a.dimensions.codeCorrectness.delta)} | ${deltaStr(a.dimensions.docCoverage.delta)} |`);
+        const dimCells = dimKeys.map((k) => deltaStr(a.dimensions[k]?.delta ?? 0));
+        lines.push(`| ${a.area} | ${a.baseline} | ${a.experiment} | ${icon} ${deltaStr(a.delta)} | ${dimCells.join(" | ")} |`);
     }
     lines.push("");
     // Summary
@@ -55,9 +64,9 @@ export function formatComparisonMarkdown(report) {
     const dim = report.deltas.perDimension;
     lines.push("| Dimension | Delta |");
     lines.push("|-----------|-------|");
-    lines.push(`| Task Completion | ${deltaStr(dim.taskCompletion)} |`);
-    lines.push(`| Code Correctness | ${deltaStr(dim.codeCorrectness)} |`);
-    lines.push(`| Doc Coverage | ${deltaStr(dim.docCoverage)} |`);
+    for (const k of Object.keys(dim)) {
+        lines.push(`| ${kebabToTitleCase(k)} | ${deltaStr(dim[k])} |`);
+    }
     lines.push(`| Doc Lift | ${deltaStr(report.deltas.docLift)} |`);
     if (report.deltas.cost !== undefined) {
         const costStr = report.deltas.cost > 0
@@ -91,29 +100,51 @@ export function formatComparisonTable(report) {
             : "unchanged");
     lines.push(`  Overall: ${Math.round(report.baseline.overall.avgScore)} → ${Math.round(report.experiment.overall.avgScore)} (${overallIcon} ${deltaStr(overall)})`);
     lines.push("");
-    // Per-dimension averages
+    // Per-dimension averages — derived dynamically from the report
     const dim = report.deltas.perDimension;
+    const dimKeys = report.areas.length > 0
+        ? Object.keys(report.areas[0].dimensions)
+        : Object.keys(dim);
     lines.push("  Dimension averages:");
-    lines.push(`    Task Completion:  ${deltaStr(dim.taskCompletion)}`);
-    lines.push(`    Code Correctness: ${deltaStr(dim.codeCorrectness)}`);
-    lines.push(`    Doc Coverage:     ${deltaStr(dim.docCoverage)}`);
-    lines.push(`    Doc Lift:         ${deltaStr(report.deltas.docLift)}`);
+    // Pad labels to the longest dimension label for alignment
+    const dimLabels = dimKeys.map(kebabToTitleCase);
+    // +1 for the colon appended to each label
+    const maxLabelLen = Math.max(...dimLabels.map((l) => l.length + 1), "Doc Lift:".length);
+    for (let i = 0; i < dimKeys.length; i++) {
+        lines.push(`    ${(dimLabels[i] + ":").padEnd(maxLabelLen)} ${deltaStr(dim[dimKeys[i]] ?? 0)}`);
+    }
+    lines.push(`    ${"Doc Lift:".padEnd(maxLabelLen)} ${deltaStr(report.deltas.docLift)}`);
     if (report.deltas.cost !== undefined) {
-        lines.push(`    Cost:             ${report.deltas.cost > 0 ? "+" : ""}$${report.deltas.cost.toFixed(4)}`);
+        lines.push(`    ${"Cost:".padEnd(maxLabelLen)} ${report.deltas.cost > 0 ? "+" : ""}$${report.deltas.cost.toFixed(4)}`);
     }
     lines.push("");
-    // Per-area table
+    // Per-area table — columns are dynamic
     lines.push("-".repeat(80));
     lines.push("PER-AREA BREAKDOWN");
     lines.push("-".repeat(80));
     lines.push("");
-    const h = "| Feature Area        | Baseline | Experiment | Delta | Task | Code | Docs |";
-    const sep = "|---------------------|----------|------------|-------|------|------|------|";
-    lines.push(h);
-    lines.push(sep);
+    const dimHeaders = dimKeys.map(kebabToTitleCase);
+    const colWidths = dimHeaders.map((h) => Math.max(h.length, 4));
+    const hCols = [
+        "Feature Area".padEnd(19),
+        "Baseline".padStart(8),
+        "Experiment".padStart(10),
+        "Delta".padStart(5),
+        ...dimHeaders.map((h, i) => h.padStart(colWidths[i])),
+    ];
+    const sepCols = [
+        "-".repeat(21),
+        "-".repeat(10),
+        "-".repeat(12),
+        "-".repeat(7),
+        ...colWidths.map((w) => "-".repeat(w + 2)),
+    ];
+    lines.push(`| ${hCols.join(" | ")} |`);
+    lines.push(`|${sepCols.join("|")}|`);
     for (const a of report.areas) {
         const icon = changeIcon(a.change);
-        lines.push(`| ${icon} ${a.area.padEnd(17)} | ${String(a.baseline).padStart(8)} | ${String(a.experiment).padStart(10)} | ${deltaStr(a.delta).padStart(5)} | ${deltaStr(a.dimensions.taskCompletion.delta).padStart(4)} | ${deltaStr(a.dimensions.codeCorrectness.delta).padStart(4)} | ${deltaStr(a.dimensions.docCoverage.delta).padStart(4)} |`);
+        const dimCells = dimKeys.map((k, i) => deltaStr(a.dimensions[k]?.delta ?? 0).padStart(colWidths[i]));
+        lines.push(`| ${icon} ${a.area.padEnd(17)} | ${String(a.baseline).padStart(8)} | ${String(a.experiment).padStart(10)} | ${deltaStr(a.delta).padStart(5)} | ${dimCells.join(" | ")} |`);
     }
     lines.push("");
     // Classification summary
@@ -187,3 +218,10 @@ function deltaStr(d) {
         return `${Math.round(d)}`;
     return "0";
 }
+/** Convert kebab-case dimension name to title case (e.g. 'task-completion' → 'Task Completion') */
+function kebabToTitleCase(name) {
+    return name
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+}

package/dist/_vendor/ailf-core/services/index.d.ts

@@ -7,6 +7,7 @@
  * Extracted from packages/eval/src/lib/ during the Ports & Adapters
  * migration (Phase 4e).
  */
-export { classifyRubric, detectFeatureArea, extractUrlMetadata, mergeScores, parseRubricScore, } from "./scoring.js";
+export { classifyRubric, detectFeatureArea, extractDimensions, extractUrlMetadata, mergeScores, parseRubricScore, } from "./scoring.js";
 export { formatComparisonMarkdown, formatComparisonTable, } from "./comparison-formatters.js";
+export { aggregateAreas, aggregateDimensions, computeEnsembleScore, computeTaskScore, normalizeScore, type AggregationStrategy, type AreaScore, type AssertionScore, type DimensionScore, type EnsembleGradingConfig, type GraderTransitionConfig, type TaskScore, type TaskScoreOptions, } from "./scoring-engine.js";
 export { extractModelName, extractProvider, mergeConfig, modelMatchesMode, } from "./config-helpers.js";

package/dist/_vendor/ailf-core/services/index.js

@@ -7,6 +7,7 @@
  * Extracted from packages/eval/src/lib/ during the Ports & Adapters
  * migration (Phase 4e).
  */
-export { classifyRubric, detectFeatureArea, extractUrlMetadata, mergeScores, parseRubricScore, } from "./scoring.js";
+export { classifyRubric, detectFeatureArea, extractDimensions, extractUrlMetadata, mergeScores, parseRubricScore, } from "./scoring.js";
 export { formatComparisonMarkdown, formatComparisonTable, } from "./comparison-formatters.js";
+export { aggregateAreas, aggregateDimensions, computeEnsembleScore, computeTaskScore, normalizeScore, } from "./scoring-engine.js";
 export { extractModelName, extractProvider, mergeConfig, modelMatchesMode, } from "./config-helpers.js";