@mcoda/mswarm 0.1.57 → 0.1.60

package/dist/vendor/codali/eval/MetricTypes.d.ts

@@ -0,0 +1,28 @@
+export interface RateMetric {
+    numerator: number;
+    denominator: number;
+    missing: number;
+    value: number | null;
+}
+export interface PercentileMetric {
+    sample_size: number;
+    missing: number;
+    median: number | null;
+    p95: number | null;
+}
+export interface EvalMetrics {
+    schema_version: 1;
+    generated_at: string;
+    task_count: number;
+    m001_task_success_rate: RateMetric;
+    m002_first_pass_success_rate: RateMetric;
+    m003_patch_apply_success_rate: RateMetric;
+    m004_verification_pass_rate: RateMetric;
+    m005_hallucination_rate: RateMetric;
+    m006_scope_violation_rate: RateMetric;
+    m007_latency_ms: PercentileMetric;
+    m008_success_tokens: PercentileMetric;
+    m008_success_cost_usd: PercentileMetric;
+}
+export type EvalMetricKey = "m001_task_success_rate" | "m002_first_pass_success_rate" | "m003_patch_apply_success_rate" | "m004_verification_pass_rate" | "m005_hallucination_rate" | "m006_scope_violation_rate" | "m007_latency_ms.median" | "m007_latency_ms.p95" | "m008_success_tokens.median" | "m008_success_tokens.p95" | "m008_success_cost_usd.median" | "m008_success_cost_usd.p95";
+//# sourceMappingURL=MetricTypes.d.ts.map

package/dist/vendor/codali/eval/MetricTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricTypes.d.ts","sourceRoot":"","sources":["../../src/eval/MetricTypes.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,cAAc,EAAE,CAAC,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB,EAAE,UAAU,CAAC;IACnC,4BAA4B,EAAE,UAAU,CAAC;IACzC,6BAA6B,EAAE,UAAU,CAAC;IAC1C,2BAA2B,EAAE,UAAU,CAAC;IACxC,uBAAuB,EAAE,UAAU,CAAC;IACpC,yBAAyB,EAAE,UAAU,CAAC;IACtC,eAAe,EAAE,gBAAgB,CAAC;IAClC,mBAAmB,EAAE,gBAAgB,CAAC;IACtC,qBAAqB,EAAE,gBAAgB,CAAC;CACzC;AAED,MAAM,MAAM,aAAa,GACrB,wBAAwB,GACxB,8BAA8B,GAC9B,+BAA+B,GAC/B,6BAA6B,GAC7B,yBAAyB,GACzB,2BAA2B,GAC3B,wBAAwB,GACxB,qBAAqB,GACrB,4BAA4B,GAC5B,yBAAyB,GACzB,8BAA8B,GAC9B,2BAA2B,CAAC"}

package/dist/vendor/codali/eval/MetricTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/codali/eval/MetricsAggregator.d.ts

@@ -0,0 +1,4 @@
+import type { EvalMetrics } from "./MetricTypes.js";
+import type { EvalRunResult } from "./EvalRunner.js";
+export declare const aggregateMetrics: (run: EvalRunResult) => EvalMetrics;
+//# sourceMappingURL=MetricsAggregator.d.ts.map

package/dist/vendor/codali/eval/MetricsAggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricsAggregator.d.ts","sourceRoot":"","sources":["../../src/eval/MetricsAggregator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAgC,MAAM,kBAAkB,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA0ErD,eAAO,MAAM,gBAAgB,GAAI,KAAK,aAAa,KAAG,WA0BrD,CAAC"}

package/dist/vendor/codali/eval/MetricsAggregator.js

@@ -0,0 +1,97 @@
+const computeRate = (samples) => {
+    let numerator = 0;
+    let denominator = 0;
+    let missing = 0;
+    for (const sample of samples) {
+        if (sample === null) {
+            missing += 1;
+            continue;
+        }
+        denominator += 1;
+        if (sample)
+            numerator += 1;
+    }
+    return {
+        numerator,
+        denominator,
+        missing,
+        value: denominator > 0 ? numerator / denominator : null,
+    };
+};
+const percentile = (values, fraction) => {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((left, right) => left - right);
+    if (sorted.length === 1)
+        return sorted[0];
+    const index = (sorted.length - 1) * fraction;
+    const lower = Math.floor(index);
+    const upper = Math.ceil(index);
+    const lowerValue = sorted[lower];
+    const upperValue = sorted[upper];
+    if (lower === upper)
+        return lowerValue;
+    const weight = index - lower;
+    return lowerValue + (upperValue - lowerValue) * weight;
+};
+const computePercentiles = (samples) => {
+    const values = samples.filter((entry) => entry !== null);
+    return {
+        sample_size: values.length,
+        missing: samples.length - values.length,
+        median: percentile(values, 0.5),
+        p95: percentile(values, 0.95),
+    };
+};
+const toFirstPassSample = (result) => {
+    if (!result.task_passed)
+        return false;
+    if (result.first_pass === null)
+        return null;
+    return result.first_pass;
+};
+const toPatchApplySample = (result) => {
+    if (result.patch_apply_success !== null)
+        return result.patch_apply_success;
+    const hasPatchExpectation = result.assertion_results.some((assertion) => assertion.code === "assert_expect_patch_apply");
+    if (!hasPatchExpectation)
+        return null;
+    return false;
+};
+const toVerificationSample = (result) => result.verification_passed;
+const toHallucinationSample = (result) => {
+    if (result.hallucination_detected === null)
+        return null;
+    return result.hallucination_detected;
+};
+const toScopeViolationSample = (result) => {
+    if (result.scope_violation_detected === null)
+        return null;
+    return result.scope_violation_detected;
+};
+export const aggregateMetrics = (run) => {
+    const taskSuccess = run.task_results.map((result) => result.task_passed);
+    const firstPass = run.task_results.map((result) => toFirstPassSample(result));
+    const patchApply = run.task_results.map((result) => toPatchApplySample(result));
+    const verificationPass = run.task_results.map((result) => toVerificationSample(result));
+    const hallucinationRate = run.task_results.map((result) => toHallucinationSample(result));
+    const scopeViolationRate = run.task_results.map((result) => toScopeViolationSample(result));
+    const latency = run.task_results.map((result) => result.latency_ms);
+    const successfulTasks = run.task_results.filter((result) => result.task_passed);
+    const successfulTokens = successfulTasks.map((result) => result.tokens_used);
+    const successfulCost = successfulTasks.map((result) => result.cost_usd);
+    return {
+        schema_version: 1,
+        generated_at: new Date().toISOString(),
+        task_count: run.summary.total,
+        m001_task_success_rate: computeRate(taskSuccess.map((value) => value)),
+        m002_first_pass_success_rate: computeRate(firstPass),
+        m003_patch_apply_success_rate: computeRate(patchApply),
+        m004_verification_pass_rate: computeRate(verificationPass),
+        m005_hallucination_rate: computeRate(hallucinationRate),
+        m006_scope_violation_rate: computeRate(scopeViolationRate),
+        m007_latency_ms: computePercentiles(latency),
+        m008_success_tokens: computePercentiles(successfulTokens),
+        m008_success_cost_usd: computePercentiles(successfulCost),
+    };
+};

package/dist/vendor/codali/eval/RegressionComparator.d.ts

@@ -0,0 +1,29 @@
+import type { EvalMetricKey, EvalMetrics } from "./MetricTypes.js";
+export interface EvalMetricDelta {
+    key: EvalMetricKey;
+    unit: "ratio" | "ms" | "tokens" | "usd";
+    higher_is_better: boolean;
+    baseline: number | null;
+    current: number | null;
+    delta: number | null;
+    direction: "up" | "down" | "flat" | "unknown";
+    regression: boolean;
+    improved: boolean;
+}
+export interface EvalRegressionComparison {
+    schema_version: 1;
+    status: "baseline_missing" | "compared";
+    baseline_report_id?: string;
+    baseline_created_at?: string;
+    deltas: EvalMetricDelta[];
+    regression_count: number;
+    improved_count: number;
+    unchanged_count: number;
+}
+export declare const compareAgainstBaseline: (params: {
+    current: EvalMetrics;
+    baseline?: EvalMetrics;
+    baseline_report_id?: string;
+    baseline_created_at?: string;
+}) => EvalRegressionComparison;
+//# sourceMappingURL=RegressionComparator.d.ts.map

package/dist/vendor/codali/eval/RegressionComparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegressionComparator.d.ts","sourceRoot":"","sources":["../../src/eval/RegressionComparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEnE,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,aAAa,CAAC;IACnB,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,QAAQ,GAAG,KAAK,CAAC;IACxC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC9C,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACvC,cAAc,EAAE,CAAC,CAAC;IAClB,MAAM,EAAE,kBAAkB,GAAG,UAAU,CAAC;IACxC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB;AA0HD,eAAO,MAAM,sBAAsB,GAAI,QAAQ;IAC7C,OAAO,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,KAAG,wBAiDH,CAAC"}

package/dist/vendor/codali/eval/RegressionComparator.js

@@ -0,0 +1,155 @@
+const EPSILON = 1e-12;
+const flattenMetrics = (metrics) => [
+    {
+        key: "m001_task_success_rate",
+        value: metrics.m001_task_success_rate.value,
+        unit: "ratio",
+        higher_is_better: true,
+    },
+    {
+        key: "m002_first_pass_success_rate",
+        value: metrics.m002_first_pass_success_rate.value,
+        unit: "ratio",
+        higher_is_better: true,
+    },
+    {
+        key: "m003_patch_apply_success_rate",
+        value: metrics.m003_patch_apply_success_rate.value,
+        unit: "ratio",
+        higher_is_better: true,
+    },
+    {
+        key: "m004_verification_pass_rate",
+        value: metrics.m004_verification_pass_rate.value,
+        unit: "ratio",
+        higher_is_better: true,
+    },
+    {
+        key: "m005_hallucination_rate",
+        value: metrics.m005_hallucination_rate.value,
+        unit: "ratio",
+        higher_is_better: false,
+    },
+    {
+        key: "m006_scope_violation_rate",
+        value: metrics.m006_scope_violation_rate.value,
+        unit: "ratio",
+        higher_is_better: false,
+    },
+    {
+        key: "m007_latency_ms.median",
+        value: metrics.m007_latency_ms.median,
+        unit: "ms",
+        higher_is_better: false,
+    },
+    {
+        key: "m007_latency_ms.p95",
+        value: metrics.m007_latency_ms.p95,
+        unit: "ms",
+        higher_is_better: false,
+    },
+    {
+        key: "m008_success_tokens.median",
+        value: metrics.m008_success_tokens.median,
+        unit: "tokens",
+        higher_is_better: false,
+    },
+    {
+        key: "m008_success_tokens.p95",
+        value: metrics.m008_success_tokens.p95,
+        unit: "tokens",
+        higher_is_better: false,
+    },
+    {
+        key: "m008_success_cost_usd.median",
+        value: metrics.m008_success_cost_usd.median,
+        unit: "usd",
+        higher_is_better: false,
+    },
+    {
+        key: "m008_success_cost_usd.p95",
+        value: metrics.m008_success_cost_usd.p95,
+        unit: "usd",
+        higher_is_better: false,
+    },
+];
+const compareMetric = (current, baseline) => {
+    if (current.value === null || baseline.value === null) {
+        return {
+            key: current.key,
+            unit: current.unit,
+            higher_is_better: current.higher_is_better,
+            baseline: baseline.value,
+            current: current.value,
+            delta: null,
+            direction: "unknown",
+            regression: false,
+            improved: false,
+        };
+    }
+    const delta = current.value - baseline.value;
+    const direction = Math.abs(delta) <= EPSILON ? "flat" : (delta > 0 ? "up" : "down");
+    const regression = current.higher_is_better ? delta < -EPSILON : delta > EPSILON;
+    const improved = current.higher_is_better ? delta > EPSILON : delta < -EPSILON;
+    return {
+        key: current.key,
+        unit: current.unit,
+        higher_is_better: current.higher_is_better,
+        baseline: baseline.value,
+        current: current.value,
+        delta: Math.abs(delta) <= EPSILON ? 0 : delta,
+        direction,
+        regression,
+        improved,
+    };
+};
+export const compareAgainstBaseline = (params) => {
+    const currentEntries = flattenMetrics(params.current);
+    if (!params.baseline) {
+        return {
+            schema_version: 1,
+            status: "baseline_missing",
+            baseline_report_id: params.baseline_report_id,
+            baseline_created_at: params.baseline_created_at,
+            deltas: currentEntries.map((entry) => ({
+                key: entry.key,
+                unit: entry.unit,
+                higher_is_better: entry.higher_is_better,
+                baseline: null,
+                current: entry.value,
+                delta: null,
+                direction: "unknown",
+                regression: false,
+                improved: false,
+            })),
+            regression_count: 0,
+            improved_count: 0,
+            unchanged_count: currentEntries.length,
+        };
+    }
+    const baselineEntries = flattenMetrics(params.baseline);
+    const baselineByKey = new Map();
+    for (const entry of baselineEntries) {
+        baselineByKey.set(entry.key, entry);
+    }
+    const deltas = [];
+    for (const entry of currentEntries) {
+        const baselineEntry = baselineByKey.get(entry.key);
+        if (!baselineEntry)
+            continue;
+        deltas.push(compareMetric(entry, baselineEntry));
+    }
+    const regressionCount = deltas.filter((entry) => entry.regression).length;
+    const improvedCount = deltas.filter((entry) => entry.improved).length;
+    const unchangedCount = deltas.length - regressionCount - improvedCount;
+    return {
+        schema_version: 1,
+        status: "compared",
+        baseline_report_id: params.baseline_report_id,
+        baseline_created_at: params.baseline_created_at,
+        deltas,
+        regression_count: regressionCount,
+        improved_count: improvedCount,
+        unchanged_count: unchangedCount,
+    };
+};

package/dist/vendor/codali/eval/ReportInputAdapter.d.ts

@@ -0,0 +1,52 @@
+import type { VerificationOutcome } from "../cognitive/Types.js";
+export type NormalizedRunStatus = "pass" | "fail" | "degraded" | "unknown";
+export type NormalizedPhaseStatus = "available" | "missing" | "degraded";
+export interface NormalizedArtifactReference {
+    phase: string;
+    kind: string;
+    status: "present" | "missing";
+    path: string | null;
+    reason_code: string | null;
+}
+export interface NormalizedPhaseOutcome {
+    phase: string;
+    status: NormalizedPhaseStatus;
+    duration_ms: number | null;
+    provider: string | null;
+    model: string | null;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    total_tokens: number | null;
+    cost_usd: number | null;
+    cost_source: string | null;
+    missing_usage_reason: string | null;
+    missing_cost_reason: string | null;
+}
+export interface NormalizedRunRecord {
+    schema_version: 1;
+    run_id: string | null;
+    task_id: string | null;
+    fingerprint: string | null;
+    duration_ms: number | null;
+    final_status: NormalizedRunStatus;
+    failure_class: string | null;
+    reason_codes: string[];
+    retryable: boolean | null;
+    verification_outcome: VerificationOutcome | null;
+    touched_files: string[];
+    artifact_references: NormalizedArtifactReference[];
+    missing_artifacts: string[];
+    phase_outcomes: NormalizedPhaseOutcome[];
+    usage_tokens_total: number | null;
+    cost_usd: number | null;
+    missing_data_markers: string[];
+}
+export interface AdaptRunSummaryInput {
+    runSummary?: unknown;
+    runId?: string;
+    taskId?: string;
+    verificationOutcome?: VerificationOutcome | null;
+    touchedFiles?: string[];
+}
+export declare const adaptRunSummaryForReport: (input?: AdaptRunSummaryInput) => NormalizedRunRecord;
+//# sourceMappingURL=ReportInputAdapter.d.ts.map

package/dist/vendor/codali/eval/ReportInputAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReportInputAdapter.d.ts","sourceRoot":"","sources":["../../src/eval/ReportInputAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAC3E,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC;AAEzE,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,qBAAqB,CAAC;IAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,CAAC,CAAC;IAClB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,mBAAmB,CAAC;IAClC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,oBAAoB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACjD,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,mBAAmB,EAAE,2BAA2B,EAAE,CAAC;IACnD,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,oBAAoB,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACjD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAmMD,eAAO,MAAM,wBAAwB,GAAI,QAAO,oBAAyB,KAAG,mBAsE3E,CAAC"}

package/dist/vendor/codali/eval/ReportInputAdapter.js

@@ -0,0 +1,229 @@
+const asRecord = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+};
+const asString = (value) => {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+};
+const asBoolean = (value) => {
+    if (typeof value === "boolean")
+        return value;
+    if (value === null)
+        return null;
+    return null;
+};
+const asNumber = (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    return value;
+};
+const uniqueSortedStrings = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    return Array.from(new Set(value
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0))).sort((left, right) => left.localeCompare(right));
+};
+const normalizeRunStatus = (value) => {
+    if (value === "pass" || value === "fail" || value === "degraded")
+        return value;
+    return "unknown";
+};
+const normalizePhaseStatus = (value) => {
+    if (value === "available" || value === "missing" || value === "degraded")
+        return value;
+    return "missing";
+};
+const normalizeVerificationOutcome = (value) => {
+    if (value === "verified_passed"
+        || value === "verified_failed"
+        || value === "unverified_with_reason") {
+        return value;
+    }
+    return null;
+};
+const normalizeArtifactReferences = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    const results = [];
+    for (const entry of value) {
+        const record = asRecord(entry);
+        if (!record)
+            continue;
+        const phase = asString(record.phase);
+        const kind = asString(record.kind);
+        if (!phase || !kind)
+            continue;
+        results.push({
+            phase,
+            kind,
+            status: record.status === "missing" ? "missing" : "present",
+            path: asString(record.path) ?? null,
+            reason_code: asString(record.reason_code) ?? null,
+        });
+    }
+    return results.sort((left, right) => `${left.phase}:${left.kind}:${left.path ?? ""}`.localeCompare(`${right.phase}:${right.kind}:${right.path ?? ""}`));
+};
+const normalizePhaseTelemetry = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    const sources = [];
+    for (const entry of value) {
+        const record = asRecord(entry);
+        if (!record)
+            continue;
+        const phase = asString(record.phase);
+        if (!phase)
+            continue;
+        const usage = asRecord(record.usage);
+        const cost = asRecord(record.cost);
+        const inputTokens = asNumber(usage?.input_tokens);
+        const outputTokens = asNumber(usage?.output_tokens);
+        const totalTokens = asNumber(usage?.total_tokens)
+            ?? (inputTokens !== null || outputTokens !== null
+                ? (inputTokens ?? 0) + (outputTokens ?? 0)
+                : null);
+        sources.push({
+            phase,
+            duration_ms: asNumber(record.duration_ms),
+            provider: asString(record.provider) ?? null,
+            model: asString(record.model) ?? null,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            total_tokens: totalTokens,
+            cost_usd: asNumber(cost?.usd),
+            cost_source: asString(cost?.source) ?? null,
+            missing_usage_reason: asString(record.missing_usage_reason) ?? null,
+            missing_cost_reason: asString(record.missing_cost_reason) ?? null,
+        });
+    }
+    return sources.sort((left, right) => left.phase.localeCompare(right.phase));
+};
+const phaseKeyToSummaryPhase = (key) => {
+    if (key === "plan")
+        return "plan";
+    if (key === "retrieval")
+        return "retrieve";
+    if (key === "patch")
+        return "act";
+    if (key === "verification")
+        return "verify";
+    return undefined;
+};
+const buildPhaseOutcomes = (runSummary, telemetry) => {
+    const quality = asRecord(runSummary.quality_dimensions);
+    const phaseStatus = new Map();
+    if (quality) {
+        for (const [key, rawValue] of Object.entries(quality)) {
+            const phase = phaseKeyToSummaryPhase(key);
+            if (!phase)
+                continue;
+            phaseStatus.set(phase, normalizePhaseStatus(rawValue));
+        }
+    }
+    for (const entry of telemetry) {
+        if (!phaseStatus.has(entry.phase)) {
+            phaseStatus.set(entry.phase, "missing");
+        }
+    }
+    if (phaseStatus.size === 0) {
+        for (const phase of ["plan", "retrieve", "act", "verify"]) {
+            phaseStatus.set(phase, "missing");
+        }
+    }
+    const telemetryByPhase = new Map();
+    for (const entry of telemetry) {
+        telemetryByPhase.set(entry.phase, entry);
+    }
+    const outcomes = [];
+    for (const [phase, status] of phaseStatus.entries()) {
+        const source = telemetryByPhase.get(phase);
+        outcomes.push({
+            phase,
+            status,
+            duration_ms: source?.duration_ms ?? null,
+            provider: source?.provider ?? null,
+            model: source?.model ?? null,
+            input_tokens: source?.input_tokens ?? null,
+            output_tokens: source?.output_tokens ?? null,
+            total_tokens: source?.total_tokens ?? null,
+            cost_usd: source?.cost_usd ?? null,
+            cost_source: source?.cost_source ?? null,
+            missing_usage_reason: source?.missing_usage_reason ?? null,
+            missing_cost_reason: source?.missing_cost_reason ?? null,
+        });
+    }
+    return outcomes.sort((left, right) => left.phase.localeCompare(right.phase));
+};
+const sumNullable = (values) => {
+    const present = values.filter((entry) => entry !== null);
+    if (!present.length)
+        return null;
+    return present.reduce((sum, value) => sum + value, 0);
+};
+export const adaptRunSummaryForReport = (input = {}) => {
+    const runSummary = asRecord(input.runSummary);
+    const finalDisposition = asRecord(runSummary?.final_disposition);
+    const artifactReferences = normalizeArtifactReferences(runSummary?.artifact_references);
+    const phaseTelemetry = normalizePhaseTelemetry(runSummary?.phase_telemetry);
+    const phaseOutcomes = buildPhaseOutcomes(runSummary ?? {}, phaseTelemetry);
+    const topLevelUsage = asRecord(runSummary?.usage);
+    const topLevelTotalTokens = asNumber(topLevelUsage?.totalTokens)
+        ?? (asNumber(topLevelUsage?.inputTokens) !== null || asNumber(topLevelUsage?.outputTokens) !== null
+            ? (asNumber(topLevelUsage?.inputTokens) ?? 0) + (asNumber(topLevelUsage?.outputTokens) ?? 0)
+            : null);
+    const usageTokensTotal = topLevelTotalTokens ?? sumNullable(phaseOutcomes.map((phase) => phase.total_tokens));
+    const topLevelCost = asNumber(runSummary?.actualCost);
+    const phaseCost = sumNullable(phaseOutcomes.map((phase) => phase.cost_usd));
+    const costUsd = topLevelCost ?? phaseCost;
+    const missingArtifacts = uniqueSortedStrings(runSummary?.missing_artifacts
+        ?? artifactReferences
+            .filter((entry) => entry.status === "missing")
+            .map((entry) => `${entry.phase}:${entry.kind}`));
+    const verificationRecord = asRecord(runSummary?.verification);
+    const verificationOutcome = normalizeVerificationOutcome(input.verificationOutcome)
+        ?? normalizeVerificationOutcome(verificationRecord?.outcome);
+    const markers = new Set();
+    if (!runSummary)
+        markers.add("run_summary_missing");
+    if (!asString(runSummary?.run_id ?? runSummary?.runId ?? input.runId))
+        markers.add("run_id_missing");
+    if (!finalDisposition)
+        markers.add("final_disposition_missing");
+    if (!phaseTelemetry.length)
+        markers.add("phase_telemetry_missing");
+    if (verificationOutcome === null)
+        markers.add("verification_outcome_missing");
+    if (usageTokensTotal === null)
+        markers.add("usage_tokens_missing");
+    if (costUsd === null)
+        markers.add("cost_missing");
+    const touchedFiles = Array.from(new Set([
+        ...uniqueSortedStrings(runSummary?.touchedFiles),
+        ...(Array.isArray(input.touchedFiles) ? input.touchedFiles : []),
+    ])).sort((left, right) => left.localeCompare(right));
+    return {
+        schema_version: 1,
+        run_id: asString(runSummary?.run_id ?? runSummary?.runId ?? input.runId) ?? null,
+        task_id: asString(runSummary?.task_id ?? runSummary?.taskId ?? input.taskId) ?? null,
+        fingerprint: asString(runSummary?.fingerprint) ?? null,
+        duration_ms: asNumber(runSummary?.durationMs),
+        final_status: normalizeRunStatus(finalDisposition?.status),
+        failure_class: asString(finalDisposition?.failure_class ?? finalDisposition?.failureClass) ?? null,
+        reason_codes: uniqueSortedStrings(finalDisposition?.reason_codes ?? finalDisposition?.reasons),
+        retryable: asBoolean(finalDisposition?.retryable),
+        verification_outcome: verificationOutcome,
+        touched_files: touchedFiles,
+        artifact_references: artifactReferences,
+        missing_artifacts: missingArtifacts,
+        phase_outcomes: phaseOutcomes,
+        usage_tokens_total: usageTokensTotal,
+        cost_usd: costUsd,
+        missing_data_markers: Array.from(markers).sort((left, right) => left.localeCompare(right)),
+    };
+};

package/dist/vendor/codali/eval/ReportSerializer.d.ts

@@ -0,0 +1,32 @@
+import type { EvalGateResult } from "./GateEvaluator.js";
+import type { EvalMetrics } from "./MetricTypes.js";
+import type { EvalRegressionComparison } from "./RegressionComparator.js";
+import type { EvalRunResult } from "./EvalRunner.js";
+export interface EvalReport {
+    schema_version: 1;
+    report_id: string;
+    created_at: string;
+    suite: {
+        suite_id: string;
+        suite_name: string;
+        suite_path: string;
+        suite_fingerprint: string;
+        task_count: number;
+    };
+    summary: {
+        exit_code: number;
+        passed: boolean;
+        gate_passed: boolean;
+        task_total: number;
+        task_passed: number;
+        task_failed: number;
+        execution_errors: number;
+    };
+    run: EvalRunResult;
+    metrics: EvalMetrics;
+    regression: EvalRegressionComparison;
+    gates: EvalGateResult;
+}
+export declare const serializeEvalReport: (report: EvalReport, pretty?: boolean) => string;
+export declare const parseEvalReport: (content: string) => EvalReport;
+//# sourceMappingURL=ReportSerializer.d.ts.map

package/dist/vendor/codali/eval/ReportSerializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReportSerializer.d.ts","sourceRoot":"","sources":["../../src/eval/ReportSerializer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,WAAW,UAAU;IACzB,cAAc,EAAE,CAAC,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,OAAO,CAAC;QAChB,WAAW,EAAE,OAAO,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,GAAG,EAAE,aAAa,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC;IACrB,UAAU,EAAE,wBAAwB,CAAC;IACrC,KAAK,EAAE,cAAc,CAAC;CACvB;AAOD,eAAO,MAAM,mBAAmB,GAAI,QAAQ,UAAU,EAAE,gBAAa,KAAG,MAKvE,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,UAkBjD,CAAC"}