@sanity/ailf 0.5.0 → 1.0.0

package/dist/_vendor/ailf-core/ports/task-source.d.ts

@@ -7,150 +7,44 @@
  * - RepoTaskSource (tasks-as-content Phase 4) — reads .ailf/tasks/
  *
  * The key invariant: the pipeline orchestrator and all downstream steps
- * work with TaskDefinition[] regardless of where they came from.
+ * work with GeneralizedTaskDefinition[] regardless of where they came from.
  */
+import type { GeneralizedAssertionDefinition, GeneralizedDocRef, GeneralizedTaskDefinition, GeneralizedTemplatedAssertion, IdDocRef, PathDocRef, PerspectiveDocRef, SlugDocRef } from "../types/generalized-task.js";
 import type { FilterOptions } from "../types/index.js";
-/** A templated assertion referencing a rubric template from config/rubrics.yaml */
-export interface TemplatedAssertion {
-    type: "llm-rubric";
-    template: string;
-    criteria: string[];
-    weight?: number;
-}
-/** A value-based assertion (contains, javascript, etc.) */
-export interface ValueAssertion {
-    type: string;
-    value?: unknown;
-    weight?: number;
-    [key: string]: unknown;
-}
-/** Any assertion definition — either templated or value-based */
-export type AssertionDefinition = TemplatedAssertion | ValueAssertion;
-/** Baseline variant configuration */
-export interface BaselineConfig {
-    /** Whether to generate a baseline variant. Default: true */
-    enabled?: boolean;
-    /** Rubric mode for baseline. Default: "full" */
-    rubric?: "abbreviated" | "full" | "none";
-}
-/**
- * A canonical documentation reference. Each entry resolves docs through
- * one of four strategies, discriminated by key presence (no explicit
- * `type` field). All strategies carry an optional `reason` for context.
- *
- * Strategies:
- * - `slug`        — one article by slug field (legacy, may not be unique)
- * - `path`        — one article by URL path (unique across sections)
- * - `id`          — one document by Sanity `_id` (drafts, imports)
- * - `perspective` — all articles in a content release (one-to-many)
- *
- * @see docs/design-docs/canonical-doc-resolution.md
- */
-export type CanonicalDocRef = SlugDocRef | PathDocRef | IdDocRef | PerspectiveDocRef;
-/** Resolve by article slug field. Legacy — prefer `path` for uniqueness. */
-export interface SlugDocRef {
-    slug: string;
-    reason?: string;
-}
-/** Resolve by URL path (after /docs/). Unique across sections. */
-export interface PathDocRef {
-    path: string;
-    reason?: string;
-}
-/** Resolve by Sanity document `_id`. The primary resolution strategy.
- *
- * Optional `slug` and `path` provide human-readable context — they are
- * NOT used for resolution (the `_id` is authoritative) but help YAML
- * authors understand which document is being referenced. The Content Lake
- * adapter populates them from the dereferenced article.
- */
-export interface IdDocRef {
-    id: string;
-    reason?: string;
-    /** Human-readable slug (informational only — not used for resolution) */
-    slug?: string;
-    /** Human-readable path (informational only — not used for resolution) */
-    path?: string;
-}
-/** Resolve all articles in a content release. One-to-many. */
-export interface PerspectiveDocRef {
-    perspective: string;
-    reason?: string;
-}
-/**
- * A loaded, validated task definition ready for expansion.
- *
- * This is the canonical intermediate representation — adapters produce
- * this from YAML, Content Lake, or .ailf/ files. Downstream consumers
- * (expansion, doc fetching, validation) work exclusively with this type.
- *
- * Design notes:
- * - `taskPrompt` is extracted from `vars.task` in YAML format
- * - `docsPath` is NOT included — it's an infrastructure detail derived
- *   from convention (`file://contexts/canonical/${id}.md`)
- * - `featureArea` is derived by the adapter (filename stem, document
- *   field, directory structure — depends on the source)
- */
-export interface TaskDefinition {
-    /** Unique task identifier */
-    id: string;
-    /** Human-readable description */
-    description: string;
-    /** Feature area this task belongs to */
-    featureArea: string;
-    /** The implementation task prompt (the user-facing request) */
-    taskPrompt: string;
-    /** Canonical doc references with reasons */
-    canonicalDocs: CanonicalDocRef[];
-    /** Path to the reference solution (relative to eval package root) */
-    referenceSolution: string;
-    /** Whether doc coverage rubric should be auto-generated */
-    docCoverage: boolean;
-    /** Assertion definitions (rubric templates + value assertions) */
-    assertions: AssertionDefinition[];
-    /** Baseline variant configuration */
-    baseline?: BaselineConfig;
-    /** Additional template variables beyond task (e.g., custom vars) */
-    extraVars?: Record<string, unknown>;
-    /** Lifecycle status — controls pipeline inclusion. Absent = "active". */
-    status?: "active" | "archived" | "draft" | "paused";
-    /** Freeform labels for filtering and organization */
-    tags?: string[];
-}
-/** Check if a canonical doc ref resolves by slug.
+/** Check if a doc ref resolves by slug.
  *
  * Excludes IdDocRef (which may carry an optional `slug` for display).
  * When both `id` and `slug` are present, it's an IdDocRef, not a SlugDocRef.
  */
-export declare function isSlugRef(ref: CanonicalDocRef): ref is SlugDocRef;
-/** Check if a canonical doc ref resolves by path.
+export declare function isSlugRef(ref: GeneralizedDocRef): ref is SlugDocRef;
+/** Check if a doc ref resolves by path.
  *
  * Excludes IdDocRef (which may carry an optional `path` for display).
  * When both `id` and `path` are present, it's an IdDocRef, not a PathDocRef.
  */
-export declare function isPathRef(ref: CanonicalDocRef): ref is PathDocRef;
-/** Check if a canonical doc ref resolves by document ID.
+export declare function isPathRef(ref: GeneralizedDocRef): ref is PathDocRef;
+/** Check if a doc ref resolves by document ID.
  *
  * Uses `"id" in ref` as the primary discriminator. IdDocRef may also carry
  * optional `slug` and `path` for display purposes, so we cannot exclude
  * on those keys. When both `id` and `slug` are present, `id` wins.
  */
-export declare function isIdRef(ref: CanonicalDocRef): ref is IdDocRef;
-/** Check if a canonical doc ref resolves by content release perspective */
-export declare function isPerspectiveRef(ref: CanonicalDocRef): ref is PerspectiveDocRef;
+export declare function isIdRef(ref: GeneralizedDocRef): ref is IdDocRef;
+/** Check if a doc ref resolves by content release perspective */
+export declare function isPerspectiveRef(ref: GeneralizedDocRef): ref is PerspectiveDocRef;
 /**
- * Extract a display identifier from any canonical doc ref.
+ * Extract a display identifier from any doc ref.
  * Useful for logging, error messages, and retrieval metrics.
  */
-export declare function canonicalDocRefLabel(ref: CanonicalDocRef): string;
+export declare function canonicalDocRefLabel(ref: GeneralizedDocRef): string;
 /** Check if an assertion uses the templated format (template + criteria) */
-export declare function isTemplatedAssertion(entry: AssertionDefinition): entry is TemplatedAssertion;
+export declare function isTemplatedAssertion(entry: GeneralizedAssertionDefinition): entry is GeneralizedTemplatedAssertion;
 /**
  * Port: Where task definitions come from.
  *
  * The pipeline never knows HOW tasks are loaded — it only sees
- * TaskDefinition[]. The adapter handles YAML parsing, GROQ queries,
- * filesystem scanning, etc.
+ * GeneralizedTaskDefinition[]. The adapter handles YAML parsing, GROQ
+ * queries, filesystem scanning, etc.
  */
 export interface TaskSource {
     /**
@@ -159,5 +53,5 @@ export interface TaskSource {
      * @param filter — Area, task ID, or changed-doc filters
      * @returns Validated task definitions ready for expansion
      */
-    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+    loadTasks(filter?: FilterOptions): Promise<GeneralizedTaskDefinition[]>;
 }

package/dist/_vendor/ailf-core/ports/task-source.js

@@ -7,12 +7,12 @@
  * - RepoTaskSource (tasks-as-content Phase 4) — reads .ailf/tasks/
  *
  * The key invariant: the pipeline orchestrator and all downstream steps
- * work with TaskDefinition[] regardless of where they came from.
+ * work with GeneralizedTaskDefinition[] regardless of where they came from.
  */
 // ---------------------------------------------------------------------------
-// Type guards — canonical doc refs
+// Type guards — doc refs
 // ---------------------------------------------------------------------------
-/** Check if a canonical doc ref resolves by slug.
+/** Check if a doc ref resolves by slug.
  *
  * Excludes IdDocRef (which may carry an optional `slug` for display).
  * When both `id` and `slug` are present, it's an IdDocRef, not a SlugDocRef.
@@ -20,7 +20,7 @@
 export function isSlugRef(ref) {
     return "slug" in ref && !("id" in ref);
 }
-/** Check if a canonical doc ref resolves by path.
+/** Check if a doc ref resolves by path.
  *
  * Excludes IdDocRef (which may carry an optional `path` for display).
  * When both `id` and `path` are present, it's an IdDocRef, not a PathDocRef.
@@ -28,7 +28,7 @@ export function isSlugRef(ref) {
 export function isPathRef(ref) {
     return "path" in ref && !("id" in ref);
 }
-/** Check if a canonical doc ref resolves by document ID.
+/** Check if a doc ref resolves by document ID.
  *
  * Uses `"id" in ref` as the primary discriminator. IdDocRef may also carry
  * optional `slug` and `path` for display purposes, so we cannot exclude
@@ -37,12 +37,12 @@ export function isPathRef(ref) {
 export function isIdRef(ref) {
     return "id" in ref;
 }
-/** Check if a canonical doc ref resolves by content release perspective */
+/** Check if a doc ref resolves by content release perspective */
 export function isPerspectiveRef(ref) {
     return "perspective" in ref;
 }
 /**
- * Extract a display identifier from any canonical doc ref.
+ * Extract a display identifier from any doc ref.
  * Useful for logging, error messages, and retrieval metrics.
  */
 export function canonicalDocRefLabel(ref) {

package/dist/_vendor/ailf-core/schemas/eval-config.d.ts

@@ -29,10 +29,15 @@ export declare const EvalConfigSchema: z.ZodObject<{
     graderReplications: z.ZodOptional<z.ZodNumber>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, 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>;

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

@@ -47,7 +47,7 @@ export type WeightProfile = z.infer<typeof WeightProfileSchema>;
  */
 export declare const RubricConfigSchema: z.ZodObject<{
     footer: z.ZodString;
-    "mode-profiles": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, 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>>;
@@ -67,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>;
@@ -92,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>>;
@@ -440,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>;
 /**
@@ -457,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. */
@@ -501,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

@@ -43,10 +43,22 @@ const WeightProfileSchema = z
     return Math.abs(sum - 1.0) < 0.001;
 }, { message: "profile weights must sum to 1.0" });
 /**
- * Mode-to-profile bindings — maps (mode, variant) pairs to profile names.
- * Example: { baseline: { gold: "default", baseline: "output-only" } }
+ * 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 ModeProfilesSchema = z.record(z.string(), z.record(z.string(), z.string()));
+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.
  *
@@ -277,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(" ");
+}