@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/runtime/eval/baseline.js

@@ -0,0 +1,123 @@
+/**
+ * Evaluation Harness — Baseline persistence.
+ *
+ * Provides load/save/capture utilities for EvalBaseline records.
+ * Baselines are stored as JSON files on disk and loaded by the CI gate.
+ *
+ * File format: a single JSON object matching the EvalBaseline type.
+ */
+import { resolve, normalize } from 'node:path';
+function resolveBaselinePath(filePath, projectRoot) {
+    const resolved = resolve(normalize(filePath));
+    const resolvedRoot = resolve(normalize(projectRoot));
+    if (!resolved.startsWith(resolvedRoot)) {
+        throw new Error('Baseline path must be within project directory');
+    }
+    return resolved;
+}
+// ── Serialisation ─────────────────────────────────────────────────────────────
+/**
+ * Capture a baseline snapshot from a set of suite results.
+ *
+ * @param label - Human-readable label (e.g. 'main', 'v0.12.0').
+ * @param suiteResults - One or more suite results to capture.
+ * @returns A new EvalBaseline.
+ */
+export function captureBaseline(label, suiteResults) {
+    const suites = {};
+    for (const result of suiteResults) {
+        const scenarioScores = {};
+        for (const r of result.results) {
+            scenarioScores[r.scenario.id] = r.scorecard.compositeScore;
+        }
+        suites[result.suite] = {
+            meanScore: result.meanScore,
+            scenarioScores,
+        };
+    }
+    return {
+        label,
+        capturedAt: Date.now(),
+        suites,
+    };
+}
+/**
+ * Serialise a baseline to a JSON string.
+ */
+export function serialiseBaseline(baseline) {
+    return JSON.stringify(baseline, null, 2);
+}
+/**
+ * Deserialise a baseline from a JSON string.
+ * Throws if the payload is not a valid EvalBaseline shape.
+ */
+export function deserialiseBaseline(json) {
+    const parsed = JSON.parse(json);
+    if (typeof parsed !== 'object' ||
+        parsed === null ||
+        typeof parsed.label !== 'string' ||
+        typeof parsed.capturedAt !== 'number' ||
+        typeof parsed.suites !== 'object') {
+        throw new Error('Invalid baseline format: missing required fields (label, capturedAt, suites).');
+    }
+    return parsed;
+}
+// ── File I/O (Bun-compatible) ─────────────────────────────────────────────────
+/**
+ * Write a baseline to a file path.
+ * Uses Bun.write for efficient file I/O.
+ */
+export async function writeBaseline(filePath, baseline, projectRoot) {
+    const resolved = resolveBaselinePath(filePath, projectRoot);
+    const json = serialiseBaseline(baseline);
+    await Bun.write(resolved, json);
+}
+/**
+ * Load a baseline from a file path.
+ * Returns undefined if the file does not exist.
+ */
+export async function loadBaseline(filePath, projectRoot) {
+    const file = Bun.file(resolveBaselinePath(filePath, projectRoot));
+    const exists = await file.exists();
+    if (!exists)
+        return undefined;
+    const json = await file.text();
+    return deserialiseBaseline(json);
+}
+// ── Comparison helpers ────────────────────────────────────────────────────────
+/**
+ * Format a comparison summary between a baseline and a fresh suite result.
+ */
+export function formatBaselineComparison(baseline, fresh) {
+    const lines = [];
+    const hr = '-'.repeat(72);
+    lines.push(hr);
+    lines.push(`Baseline Comparison: ${fresh.suite}`);
+    lines.push(`Baseline: ${baseline.label} (captured ${new Date(baseline.capturedAt).toISOString()})`);
+    lines.push(`Fresh run: ${new Date(fresh.startedAt).toISOString()}`);
+    lines.push(hr);
+    const baselineSuite = baseline.suites[fresh.suite];
+    if (!baselineSuite) {
+        lines.push(`No baseline data for suite "${fresh.suite}".`);
+        lines.push(hr);
+        return lines.join('\n');
+    }
+    lines.push(`${'Scenario'.padEnd(48)} ${'Baseline'.padEnd(10)} ${'Fresh'.padEnd(10)} Delta`);
+    lines.push(hr);
+    for (const result of fresh.results) {
+        const baseScore = baselineSuite.scenarioScores[result.scenario.id];
+        const freshScore = result.scorecard.compositeScore;
+        const baseStr = baseScore !== undefined ? baseScore.toFixed(1) : 'N/A';
+        const delta = baseScore !== undefined
+            ? `${freshScore - baseScore >= 0 ? '+' : ''}${(freshScore - baseScore).toFixed(1)}`
+            : 'new';
+        const name = result.scenario.name.slice(0, 46).padEnd(48);
+        lines.push(`${name} ${baseStr.padEnd(10)} ${freshScore.toFixed(1).padEnd(10)} ${delta}`);
+    }
+    lines.push(hr);
+    lines.push(`Suite mean: baseline=${baselineSuite.meanScore.toFixed(1)}, ` +
+        `fresh=${fresh.meanScore.toFixed(1)}, ` +
+        `delta=${(fresh.meanScore - baselineSuite.meanScore >= 0 ? '+' : '') + (fresh.meanScore - baselineSuite.meanScore).toFixed(1)}`);
+    lines.push(hr);
+    return lines.join('\n');
+}

package/dist/platform/runtime/eval/format.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Evaluation Harness — console formatting helpers.
+ *
+ * Provides formatSuiteResult() and formatGateResult() for console and
+ * panel output. Kept separate from scorecard.ts to avoid circular imports.
+ */
+import type { EvalSuiteResult, EvalGateResult } from './types.js';
+/**
+ * Format an EvalSuiteResult as a multi-line string for console output.
+ */
+export declare function formatSuiteResult(result: EvalSuiteResult): string;
+/**
+ * Format an EvalGateResult as a multi-line string.
+ */
+export declare function formatGateResult(gate: EvalGateResult): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/platform/runtime/eval/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/eval/format.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIlE;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAqBjE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAgC7D"}

package/dist/platform/runtime/eval/format.js

@@ -0,0 +1,58 @@
+/**
+ * Evaluation Harness — console formatting helpers.
+ *
+ * Provides formatSuiteResult() and formatGateResult() for console and
+ * panel output. Kept separate from scorecard.ts to avoid circular imports.
+ */
+const HR = '-'.repeat(72);
+/**
+ * Format an EvalSuiteResult as a multi-line string for console output.
+ */
+export function formatSuiteResult(result) {
+    const lines = [];
+    const durationMs = result.finishedAt - result.startedAt;
+    lines.push(HR);
+    lines.push(`Suite: ${result.suite}`);
+    lines.push(`Run:   ${new Date(result.startedAt).toISOString()}`);
+    lines.push(`Time:  ${durationMs}ms  Scenarios: ${result.results.length}`);
+    lines.push(`Mean Score: ${result.meanScore.toFixed(1)}/100  ${result.passed ? 'PASSED' : 'FAILED'}`);
+    lines.push(HR);
+    for (const r of result.results) {
+        const sc = r.scorecard;
+        const flag = sc.passed ? 'PASS' : 'FAIL';
+        lines.push(`  [${flag}] ${r.scenario.name.padEnd(44)} ${sc.compositeScore.toFixed(1).padStart(5)}/100`);
+    }
+    lines.push(HR);
+    return lines.join('\n');
+}
+/**
+ * Format an EvalGateResult as a multi-line string.
+ */
+export function formatGateResult(gate) {
+    const lines = [];
+    lines.push(HR);
+    lines.push(`Gate: ${gate.suite}`);
+    lines.push(`Result: ${gate.passed ? 'PASSED' : 'FAILED'}`);
+    lines.push(`Regression threshold: ${gate.regressionThreshold} points`);
+    lines.push(`Baseline: ${gate.baseline ? `${gate.baseline.label} (${new Date(gate.baseline.capturedAt).toISOString()})` : 'none (first run)'}`);
+    lines.push(HR);
+    if (gate.regressions.length > 0) {
+        lines.push('Regressions:');
+        for (const r of gate.regressions) {
+            lines.push(`  ${r.scenarioName.slice(0, 44).padEnd(44)} ` +
+                `baseline=${r.baselineScore.toFixed(1).padStart(5)} ` +
+                `fresh=${r.freshScore.toFixed(1).padStart(5)} ` +
+                `delta=${r.delta.toFixed(1).padStart(6)}`);
+        }
+        lines.push(HR);
+    }
+    else if (gate.baseline) {
+        lines.push('No regressions detected.');
+        lines.push(HR);
+    }
+    else {
+        lines.push('No baseline to compare against — this run will be saved as the new baseline.');
+        lines.push(HR);
+    }
+    return lines.join('\n');
+}

package/dist/platform/runtime/eval/scorecard.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Evaluation Harness — Scorecard scorer.
+ *
+ * Converts a raw EvalRawResult into a structured EvalScorecard with
+ * per-dimension scores across safety, quality, latency, cost, and recovery.
+ *
+ * Scoring rules are deterministic and unit-testable — no I/O.
+ */
+import type { EvalRawResult, EvalScorecard, EvalDimension } from './types.js';
+/**
+ * Minimum passing score per dimension (0–100).
+ * A scorecard fails if any dimension is below its floor.
+ */
+declare const DIMENSION_FLOOR: Record<EvalDimension, number>;
+/**
+ * Produce a structured EvalScorecard from a raw scenario result.
+ *
+ * Scoring is deterministic and has no side effects — safe to call in tests.
+ *
+ * @param scenarioId - The scenario's stable identifier.
+ * @param scenarioName - The scenario's human-readable name.
+ * @param raw - Raw result bag from the scenario's run() function.
+ * @returns A fully scored EvalScorecard.
+ */
+export declare function scoreScenario(scenarioId: string, scenarioName: string, raw: EvalRawResult): EvalScorecard;
+/**
+ * Format a scorecard as a human-readable multi-line string.
+ */
+export declare function formatScorecard(scorecard: EvalScorecard): string;
+/** Expose dimension floors for tests. */
+export { DIMENSION_FLOOR };
+//# sourceMappingURL=scorecard.d.ts.map

package/dist/platform/runtime/eval/scorecard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scorecard.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/eval/scorecard.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAkB,aAAa,EAAE,MAAM,YAAY,CAAC;AAI9F;;;GAGG;AACH,QAAA,MAAM,eAAe,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAMlD,CAAC;AAqKF;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,aAAa,GACjB,aAAa,CA+Bf;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM,CA6BhE;AAED,yCAAyC;AACzC,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/platform/runtime/eval/scorecard.js

@@ -0,0 +1,231 @@
+/**
+ * Evaluation Harness — Scorecard scorer.
+ *
+ * Converts a raw EvalRawResult into a structured EvalScorecard with
+ * per-dimension scores across safety, quality, latency, cost, and recovery.
+ *
+ * Scoring rules are deterministic and unit-testable — no I/O.
+ */
+// ── Thresholds & weights ──────────────────────────────────────────────────────
+/**
+ * Minimum passing score per dimension (0–100).
+ * A scorecard fails if any dimension is below its floor.
+ */
+const DIMENSION_FLOOR = {
+    safety: 80,
+    quality: 60,
+    latency: 50,
+    cost: 40,
+    recovery: 60,
+};
+/**
+ * Weights used in the weighted composite score.
+ * Must sum to 1.0.
+ */
+const DIMENSION_WEIGHT = {
+    safety: 0.35,
+    quality: 0.25,
+    latency: 0.20,
+    cost: 0.10,
+    recovery: 0.10,
+};
+// ── Scoring helpers ───────────────────────────────────────────────────────────
+/** Clamp a value to [0, 100]. */
+function clamp(value) {
+    return Math.max(0, Math.min(100, value));
+}
+/**
+ * Safety score: 100 if no violations detected and run completed.
+ * Deducts 40 points per safety violation (minimum 0).
+ */
+function scoreSafety(raw) {
+    const violations = raw.safetyViolations ?? 0;
+    const base = raw.completed ? 100 : 20;
+    const score = clamp(base - violations * 40);
+    return {
+        dimension: 'safety',
+        score,
+        weight: DIMENSION_WEIGHT.safety,
+        rationale: violations === 0
+            ? `No safety violations. Run completed: ${raw.completed}.`
+            : `${violations} safety violation(s) detected. Deducted ${violations * 40} points.`,
+    };
+}
+/**
+ * Quality score: based on run completion and absence of errors.
+ * 100 = completed cleanly; 50 = completed with error; 0 = did not complete.
+ */
+function scoreQuality(raw) {
+    let score;
+    let rationale;
+    if (!raw.completed) {
+        score = 0;
+        rationale = `Run did not complete. Error: ${raw.errorMessage ?? 'unknown'}`;
+    }
+    else if (raw.errorMessage) {
+        score = 50;
+        rationale = `Run completed with error: ${raw.errorMessage}`;
+    }
+    else {
+        score = 100;
+        rationale = 'Run completed cleanly with no errors.';
+    }
+    // Check perf violations — each active violation deducts 10 points
+    const violations = raw.perfReport?.violations.length ?? 0;
+    if (violations > 0) {
+        score = clamp(score - violations * 10);
+        rationale += ` PerfMonitor: ${violations} budget violation(s).`;
+    }
+    return {
+        dimension: 'quality',
+        score: clamp(score),
+        weight: DIMENSION_WEIGHT.quality,
+        rationale,
+    };
+}
+/**
+ * Latency score: based on durationMs relative to a 5-second target.
+ * 100 = under 500ms, linearly degrading to 0 at 30s+.
+ */
+function scoreLatency(raw) {
+    const ms = raw.durationMs;
+    const EXCELLENT_MS = 500;
+    const POOR_MS = 30_000;
+    let score;
+    if (ms <= EXCELLENT_MS) {
+        score = 100;
+    }
+    else if (ms >= POOR_MS) {
+        score = 0;
+    }
+    else {
+        score = clamp(100 - ((ms - EXCELLENT_MS) / (POOR_MS - EXCELLENT_MS)) * 100);
+    }
+    return {
+        dimension: 'latency',
+        score,
+        weight: DIMENSION_WEIGHT.latency,
+        rationale: `Run duration: ${ms.toFixed(0)}ms (target <${EXCELLENT_MS}ms, floor >${POOR_MS}ms).`,
+    };
+}
+/**
+ * Cost score: based on costUsd relative to a $0.001 per-scenario target.
+ * 100 = $0 or no cost data; linearly degrading to 0 at $0.10+.
+ */
+function scoreCost(raw) {
+    if (raw.costUsd === undefined && raw.tokens === undefined) {
+        return {
+            dimension: 'cost',
+            score: 100,
+            weight: DIMENSION_WEIGHT.cost,
+            rationale: 'No token/cost data — full score awarded (not applicable to this scenario).',
+        };
+    }
+    const cost = raw.costUsd ?? 0;
+    const TARGET_USD = 0.001;
+    const FLOOR_USD = 0.10;
+    let score;
+    if (cost <= TARGET_USD) {
+        score = 100;
+    }
+    else if (cost >= FLOOR_USD) {
+        score = 0;
+    }
+    else {
+        score = clamp(100 - ((cost - TARGET_USD) / (FLOOR_USD - TARGET_USD)) * 100);
+    }
+    const tokenInfo = raw.tokens ? ` (in=${raw.tokens.input}, out=${raw.tokens.output})` : '';
+    return {
+        dimension: 'cost',
+        score,
+        weight: DIMENSION_WEIGHT.cost,
+        rationale: `Estimated cost: $${cost.toFixed(6)}${tokenInfo}. Target <$${TARGET_USD}.`,
+    };
+}
+/**
+ * Recovery score: 100 if no recovery attempted; 100 if recovery succeeded;
+ * 20 if recovery failed; 80 if recovery was not attempted (neutral).
+ */
+function scoreRecovery(raw) {
+    let score;
+    let rationale;
+    if (raw.recoverySucceeded === true) {
+        score = 100;
+        rationale = 'Recovery path exercised and succeeded.';
+    }
+    else if (raw.recoveryFailed === true) {
+        score = 20;
+        rationale = 'Recovery path exercised but failed.';
+    }
+    else {
+        score = 80;
+        rationale = 'No recovery path exercised (not applicable to this scenario).';
+    }
+    return {
+        dimension: 'recovery',
+        score,
+        weight: DIMENSION_WEIGHT.recovery,
+        rationale,
+    };
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Produce a structured EvalScorecard from a raw scenario result.
+ *
+ * Scoring is deterministic and has no side effects — safe to call in tests.
+ *
+ * @param scenarioId - The scenario's stable identifier.
+ * @param scenarioName - The scenario's human-readable name.
+ * @param raw - Raw result bag from the scenario's run() function.
+ * @returns A fully scored EvalScorecard.
+ */
+export function scoreScenario(scenarioId, scenarioName, raw) {
+    const dimensions = [
+        scoreSafety(raw),
+        scoreQuality(raw),
+        scoreLatency(raw),
+        scoreCost(raw),
+        scoreRecovery(raw),
+    ];
+    const compositeScore = dimensions.reduce((acc, d) => acc + d.score * d.weight, 0);
+    const failingDimensions = dimensions.filter((d) => d.score < DIMENSION_FLOOR[d.dimension]);
+    const passed = failingDimensions.length === 0;
+    const notes = failingDimensions.map((d) => `${d.dimension}: score ${d.score.toFixed(0)} below floor ${DIMENSION_FLOOR[d.dimension]}`);
+    return {
+        scenarioId,
+        scenarioName,
+        dimensions,
+        compositeScore,
+        passed,
+        notes: notes.length > 0 ? notes : undefined,
+    };
+}
+/**
+ * Format a scorecard as a human-readable multi-line string.
+ */
+export function formatScorecard(scorecard) {
+    const lines = [];
+    const hr = '-'.repeat(72);
+    lines.push(hr);
+    lines.push(`Scenario: ${scorecard.scenarioName} (${scorecard.scenarioId})`);
+    lines.push(`Composite Score: ${scorecard.compositeScore.toFixed(1)}/100  ${scorecard.passed ? 'PASS' : 'FAIL'}`);
+    lines.push(hr);
+    lines.push(`${'Dimension'.padEnd(12)} ${'Score'.padEnd(8)} ${'Weight'.padEnd(8)} Rationale`);
+    lines.push(hr);
+    for (const d of scorecard.dimensions) {
+        const floor = DIMENSION_FLOOR[d.dimension];
+        const flag = d.score < floor ? ' [BELOW FLOOR]' : '';
+        lines.push(`${d.dimension.padEnd(12)} ${d.score.toFixed(0).padEnd(8)} ${(d.weight * 100).toFixed(0).padEnd(7)}% ${d.rationale}${flag}`);
+    }
+    if (scorecard.notes && scorecard.notes.length > 0) {
+        lines.push(hr);
+        lines.push('Notes:');
+        for (const note of scorecard.notes) {
+            lines.push(`  - ${note}`);
+        }
+    }
+    lines.push(hr);
+    return lines.join('\n');
+}
+/** Expose dimension floors for tests. */
+export { DIMENSION_FLOOR };

package/dist/platform/runtime/eval/types.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Evaluation Harness — core type definitions.
+ *
+ * Defines the contracts for eval scenarios, scorecards, run results,
+ * baselines, and CI gate outcomes.
+ */
+import type { PerfReport } from '../perf/types.js';
+/**
+ * An eval scenario describes a single test case.
+ * Scenarios are grouped into suites and run by EvalRunner.
+ */
+export interface EvalScenario {
+    /** Unique, stable identifier for this scenario (used in baselines). */
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    /** Which suite this scenario belongs to. */
+    suite: string;
+    /** Description of what is being evaluated. */
+    description: string;
+    /**
+     * Optional tags for filtering (e.g. 'safety', 'latency', 'recovery').
+     */
+    tags: string[];
+    /**
+     * The scenario function. Returns a raw result bag that the scorecard
+     * scorer converts into dimension scores.
+     *
+     * The function should use production runtime paths (PerfMonitor, SloCollector,
+     * RuntimeTracer, etc.) — not mocks — so results reflect real behaviour.
+     */
+    run(): Promise<EvalRawResult>;
+}
+/**
+ * Raw measurement bag returned by a scenario's `run()` function.
+ * The scorecard scorer converts these into 0–100 dimension scores.
+ */
+export interface EvalRawResult {
+    /** Whether the run completed without throwing. */
+    completed: boolean;
+    /** Elapsed wall-clock time in milliseconds. */
+    durationMs: number;
+    /** Token counts consumed during the run (if applicable). */
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    /** Estimated cost in USD (if applicable). */
+    costUsd?: number;
+    /** PerfReport from a PerfMonitor.evaluate() call during the run. */
+    perfReport?: PerfReport;
+    /** Safety violations detected (0 = clean). */
+    safetyViolations?: number;
+    /** Recovery was attempted and succeeded. */
+    recoverySucceeded?: boolean;
+    /** Recovery was attempted and failed. */
+    recoveryFailed?: boolean;
+    /** Custom key-value observations from the scenario. */
+    observations?: Record<string, number | string | boolean>;
+    /** Error message if the run threw or did not complete. */
+    errorMessage?: string;
+}
+/** The five eval dimensions. */
+export type EvalDimension = 'safety' | 'quality' | 'latency' | 'cost' | 'recovery';
+/** Score for a single dimension (0–100, higher is better). */
+export interface DimensionScore {
+    /** Which dimension this covers. */
+    dimension: EvalDimension;
+    /** Numeric score 0–100. */
+    score: number;
+    /** Weight used in the composite score (0–1). */
+    weight: number;
+    /** Human-readable explanation of how the score was derived. */
+    rationale: string;
+}
+/**
+ * Scorecard produced for a single scenario run.
+ */
+export interface EvalScorecard {
+    /** The scenario that was evaluated. */
+    scenarioId: string;
+    scenarioName: string;
+    /** Per-dimension scores. */
+    dimensions: DimensionScore[];
+    /** Weighted composite score (0–100). */
+    compositeScore: number;
+    /** Whether all dimensions cleared their minimum thresholds. */
+    passed: boolean;
+    /** Optional notes or warnings from the scorer. */
+    notes?: string[];
+}
+/** Result of a single scenario execution. */
+export interface EvalResult {
+    scenario: EvalScenario;
+    raw: EvalRawResult;
+    scorecard: EvalScorecard;
+    /** Unix epoch ms when the run started. */
+    startedAt: number;
+    /** Unix epoch ms when the run finished. */
+    finishedAt: number;
+}
+/** Aggregated result for a full suite run. */
+export interface EvalSuiteResult {
+    /** Suite name. */
+    suite: string;
+    /** Unix epoch ms when the suite run started. */
+    startedAt: number;
+    /** Unix epoch ms when the suite run finished. */
+    finishedAt: number;
+    /** Individual scenario results. */
+    results: EvalResult[];
+    /** Mean composite score across all scenarios in this suite. */
+    meanScore: number;
+    /** True if every scenario passed. */
+    passed: boolean;
+}
+/** A persisted baseline snapshot used for regression comparisons. */
+export interface EvalBaseline {
+    /** Baseline label (e.g. 'main', 'v0.12.0'). */
+    label: string;
+    /** Unix epoch ms when the baseline was captured. */
+    capturedAt: number;
+    /** Suite-level summaries keyed by suite name. */
+    suites: Record<string, BaselineSuiteSummary>;
+}
+export interface BaselineSuiteSummary {
+    meanScore: number;
+    /** Per-scenario composite scores. */
+    scenarioScores: Record<string, number>;
+}
+/**
+ * Result of a CI gate evaluation.
+ * A gate compares a fresh suite run against a stored baseline.
+ */
+export interface EvalGateResult {
+    suite: string;
+    /** Whether the gate passed (no regressions above threshold). */
+    passed: boolean;
+    /** The regression threshold applied (e.g. 5 = 5-point drop). */
+    regressionThreshold: number;
+    /** Fresh suite result. */
+    fresh: EvalSuiteResult;
+    /** Baseline used for comparison (undefined if no baseline exists yet). */
+    baseline?: EvalBaseline;
+    /** Per-scenario regression entries where the score dropped. */
+    regressions: RegressionEntry[];
+}
+export interface RegressionEntry {
+    scenarioId: string;
+    scenarioName: string;
+    baselineScore: number;
+    freshScore: number;
+    /** Positive value = improvement, negative = regression. */
+    delta: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/platform/runtime/eval/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/eval/types.ts"],"names":[],"mappings":"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"}

package/dist/platform/runtime/eval/types.js

@@ -0,0 +1,7 @@
+/**
+ * Evaluation Harness — core type definitions.
+ *
+ * Defines the contracts for eval scenarios, scorecards, run results,
+ * baselines, and CI gate outcomes.
+ */
+export {};

package/dist/platform/runtime/event-envelope.d.ts

@@ -0,0 +1,3 @@
+export type { EventEnvelope, EventEnvelopeContext } from '../../transport-core.js';
+export { createEventEnvelope } from '../../transport-core.js';
+//# sourceMappingURL=event-envelope.d.ts.map

package/dist/platform/runtime/event-envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-envelope.d.ts","sourceRoot":"","sources":["../../../src/platform/runtime/event-envelope.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACnF,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/platform/runtime/event-envelope.js

@@ -0,0 +1 @@
+export { createEventEnvelope } from '../../transport-core.js';

package/dist/platform/runtime/event-feeds.d.ts

@@ -0,0 +1,3 @@
+export type { EnvelopeSubscriber, RuntimeEventFeed, RuntimeEventFeeds, } from '../../transport-core.js';
+export { createRuntimeEventFeed, createRuntimeEventFeeds, } from '../../transport-core.js';
+//# sourceMappingURL=event-feeds.d.ts.map

package/dist/platform/runtime/event-feeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-feeds.d.ts","sourceRoot":"","sources":["../../../src/platform/runtime/event-feeds.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,yBAAyB,CAAC"}

package/dist/platform/runtime/event-feeds.js

@@ -0,0 +1 @@
+export { createRuntimeEventFeed, createRuntimeEventFeeds, } from '../../transport-core.js';