@prismatic-io/lux 0.0.2-preview.32 → 0.0.2-preview.35

package/src/orchestrator/compare.ts

@@ -20,6 +20,7 @@ import {
 import { hasAgentUsage } from "../core/usage.js";
 import { stableDriverIdentity } from "./comparison-identity.js";
 import { safeReadJson, walkFiles } from "./fs-read.js";
+import { gradingScoreBasis } from "./grading.js";
 
 export type ComparisonInput = {
   pathA: string;
@@ -39,9 +40,9 @@ export type GradingDelta = {
   id: string;
   type: string;
   name: string;
-  before: { passed: boolean | null; score: number } | null;
-  after: { passed: boolean | null; score: number } | null;
-  status: "added" | "removed" | "improved" | "regressed" | "unchanged";
+  before: { passed: boolean | null; score: number | null } | null;
+  after: { passed: boolean | null; score: number | null } | null;
+  status: "added" | "removed" | "improved" | "regressed" | "unchanged" | "unavailable";
 };
 
 export type RunComparison = {
@@ -67,6 +68,7 @@ export type RunComparison = {
     casePassedB: boolean | null;
     caseScoreA: number | null;
     caseScoreB: number | null;
+    caseScoreComparable: boolean;
     deltas: GradingDelta[];
     improvements: number;
     regressions: number;
@@ -156,6 +158,9 @@ const assertionsByIdentity = (
   return out;
 };
 
+const measuredScore = (entry: GradingReport["assertions"][number]): number | null =>
+  entry.errorMessage !== undefined || entry.abstention !== undefined ? null : entry.score;
+
 const computeGradingDeltas = (
   a: GradingReport | null,
   b: GradingReport | null,
@@ -174,7 +179,8 @@ const computeGradingDeltas = (
     if (!ax && bx) status = "added";
     else if (ax && !bx) status = "removed";
     else if (ax && bx) {
-      if (ax.passed === bx.passed && ax.score === bx.score) status = "unchanged";
+      if (measuredScore(ax) === null || measuredScore(bx) === null) status = "unavailable";
+      else if (ax.passed === bx.passed && ax.score === bx.score) status = "unchanged";
       // A pass/fail flip dominates any score movement.
       else if (ax.passed !== bx.passed) status = bx.passed ? "improved" : "regressed";
       else status = ax.score < bx.score ? "improved" : "regressed";
@@ -189,8 +195,8 @@ const computeGradingDeltas = (
       id: name,
       type: ax?.type ?? bx?.type ?? "unknown",
       name: ax?.id || bx?.id ? (ax?.name ?? bx?.name ?? name) : name,
-      before: ax ? { passed: ax.passed, score: ax.score } : null,
-      after: bx ? { passed: bx.passed, score: bx.score } : null,
+      before: ax ? { passed: ax.passed, score: measuredScore(ax) } : null,
+      after: bx ? { passed: bx.passed, score: measuredScore(bx) } : null,
       status,
     });
   }
@@ -314,6 +320,9 @@ export const compareRuns = async (input: ComparisonInput): Promise<RunComparison
       casePassedB: b.grading?.casePassed ?? null,
       caseScoreA: a.grading?.caseScore ?? null,
       caseScoreB: b.grading?.caseScore ?? null,
+      caseScoreComparable:
+        gradingScoreBasis(a.grading) !== null &&
+        gradingScoreBasis(a.grading) === gradingScoreBasis(b.grading),
       ...grading,
     },
     artifactsDelta: computeFileDelta(a.fileTree, b.fileTree),
@@ -327,6 +336,7 @@ export const compareRuns = async (input: ComparisonInput): Promise<RunComparison
 export const hasRegression = (cmp: RunComparison): boolean =>
   cmp.caseMismatch.length > 0 ||
   cmp.grading.regressions > 0 ||
+  cmp.grading.deltas.some((delta) => delta.after?.score === null && delta.after.passed !== null) ||
   cmp.grading.deltas.some((delta) => delta.status === "removed" && delta.before?.passed !== null) ||
   (cmp.grading.casePassedA === true && cmp.grading.casePassedB !== true);
 
@@ -376,13 +386,17 @@ export const formatComparisonText = (cmp: RunComparison): string => {
   lines.push("Grading:");
   lines.push(
     `  passed: ${String(cmp.grading.casePassedA)} → ${String(cmp.grading.casePassedB)}; ` +
-      `score: ${cmp.grading.caseScoreA ?? "?"} → ${cmp.grading.caseScoreB ?? "?"}`,
+      `score: ${cmp.grading.caseScoreA ?? "?"} → ${cmp.grading.caseScoreB ?? "?"}${cmp.grading.caseScoreComparable ? "" : " (change unavailable: scoring basis differs or is unknown)"}`,
   );
   lines.push(`  ${cmp.grading.improvements} improved, ${cmp.grading.regressions} regressed`);
   for (const d of cmp.grading.deltas) {
     if (d.status === "unchanged") continue;
-    const arrow = { added: "+", removed: "-", improved: "↑", regressed: "↓" }[d.status];
-    lines.push(`    ${arrow} ${d.name}`);
+    const arrow = { added: "+", removed: "-", improved: "↑", regressed: "↓", unavailable: "?" }[
+      d.status
+    ];
+    lines.push(
+      `    ${arrow} ${d.name}: ${d.before?.score ?? "unavailable"} → ${d.after?.score ?? "unavailable"}`,
+    );
   }
   lines.push("");
   lines.push("Artifacts:");

package/src/orchestrator/experiment-effects.ts

@@ -23,7 +23,7 @@ export const experimentEffects = (
   const metrics = new Set([
     "quality.passRate",
     experiment.evaluationKind === "grader" ? "harness.total" : "agent.total",
-    ...(experiment.evaluationKind === "agent" ? ["interrupts.ask", "toolCalls"] : []),
+    ...(experiment.evaluationKind === "agent" ? ["score", "interrupts.ask", "toolCalls"] : []),
     ...experiment.campaignSnapshot.objectives.constraints
       .filter((constraint) => constraint.relativeTo)
       .map((constraint) => constraint.metric),
@@ -46,7 +46,9 @@ export const experimentEffects = (
           const confidence =
             constraint?.confidence ??
             ConfidenceConfigSchema.parse({
-              method: metric === "quality.passRate" ? "hoeffding" : "percentile-bootstrap",
+              method: ["quality.passRate", "score"].includes(metric)
+                ? "hoeffding"
+                : "percentile-bootstrap",
             });
           return {
             candidateId,

package/src/orchestrator/experiment-evaluation.ts

@@ -44,6 +44,7 @@ const gradingFailureMessage = (results: readonly SuiteCaseResult[]): string | un
     }
     const report = result.result?.grading;
     const failedAssertion = report.assertions.find((assertion) => {
+      if (assertion.passed === null) return false;
       if (assertion.errorMessage) return true;
       const detail =
         assertion.detail && typeof assertion.detail === "object"
@@ -299,10 +300,12 @@ const agentEvaluationFromSuite = (input: {
       return {
         [sample.canonicalCaseId]: {
           identityHash,
+          scoreBasis: sample.scoreBasis ?? null,
           ...(input.clusterId ? { clusterId: input.clusterId } : {}),
           metrics: Object.fromEntries(
             Object.entries({
               ...sample.metrics,
+              ...(sample.score !== undefined ? { score: sample.score } : {}),
               "quality.passRate": sample.passed === true ? 1 : 0,
             }).map(([name, value]) => [name, { mean: value, n: 1 }]),
           ),
@@ -322,7 +325,10 @@ const agentEvaluationFromSuite = (input: {
       summary.cases.map((entry) => [entry.canonicalCaseId, entry.passRate]),
     ),
     metrics: evaluationMetrics(summary, candidate),
-    metricDefinitions: evaluationMetricDefinitions(summary),
+    metricDefinitions: {
+      score: { unit: "score", better: "higher", label: "Quality score" },
+      ...evaluationMetricDefinitions(summary),
+    },
     samples: evaluationSamples(summary),
     ...(caseSamples ? { caseSamples } : {}),
     metricCalls: summary.samples.length,
@@ -406,6 +412,12 @@ const aggregateAgentUnits = (
   const caseSamples = clusterCaseSamples(units.map((unit) => unit.evaluation.caseSamples));
   const grouped = groupedCaseMetricSamples(caseSamples, repetitions);
   const samples = grouped ?? ungroupedSamples;
+  const completeScore =
+    caseSamples &&
+    Object.values(caseSamples).every(
+      (sample) => sample.metrics.score?.n === repetitions && Boolean(sample.scoreBasis),
+    );
+  if (!completeScore) delete samples.score;
   return {
     candidateId: candidate.id,
     profileId,
@@ -417,7 +429,11 @@ const aggregateAgentUnits = (
     ),
     metrics: Object.fromEntries(
       [...metricValues]
-        .filter(([name]) => !grouped || name === "subject.bytes" || Object.hasOwn(grouped, name))
+        .filter(([name]) =>
+          name === "score"
+            ? completeScore
+            : !grouped || name === "subject.bytes" || Object.hasOwn(grouped, name),
+        )
         .map(([name, values]) => [
           name,
           name === "subject.bytes" ? candidate.sourceBytes : average(grouped?.[name] ?? values),

package/src/orchestrator/experiment-selection.ts

@@ -252,13 +252,65 @@ const normalizedConstraintViolation = (
   return worst;
 };
 
+const hasScoreEvidence = (
+  experiment: OpenedExperimentRun["manifest"],
+  split: ExperimentSplit,
+): boolean =>
+  [...new Set(experiment.evaluations.map((entry) => entry.candidateId))]
+    .flatMap((id) => candidateEvaluations(experiment, id))
+    .some(
+      (entry) =>
+        entry.split === split &&
+        (entry.metricDefinitions?.score !== undefined ||
+          entry.metrics.score !== undefined ||
+          Object.values(entry.caseSamples ?? {}).some(
+            (sample) => sample.metrics.score !== undefined,
+          )),
+    );
+
+const completeScoreEvidence = (entry: ExperimentEvaluation): boolean =>
+  entry.metrics.score !== undefined &&
+  (!entry.caseSamples ||
+    Object.keys(entry.casePassRates).every((id) => {
+      const sample = entry.caseSamples?.[id];
+      return sample?.metrics.score?.n === entry.repetitions && Boolean(sample.scoreBasis);
+    }));
+
+const comparableScoreBasis = (
+  entry: ExperimentEvaluation,
+  reference: ExperimentEvaluation | undefined,
+): boolean => {
+  if (!reference || !completeScoreEvidence(reference)) return false;
+  if (!entry.caseSamples || !reference.caseSamples)
+    return !entry.caseSamples && !reference.caseSamples;
+  const ids = new Set([
+    ...Object.keys(entry.casePassRates),
+    ...Object.keys(reference.casePassRates),
+  ]);
+  return [...ids].every((id) => {
+    const basis = entry.caseSamples?.[id]?.scoreBasis;
+    return Boolean(basis) && basis === reference.caseSamples?.[id]?.scoreBasis;
+  });
+};
+
 export const rankCandidates = <T extends ExperimentDecisionCandidate>(
   campaign: ExperimentCampaign,
   candidates: readonly T[],
   experiment: OpenedExperimentRun["manifest"],
   constraintSplits: readonly ExperimentSplit[] = ["train", "validation", "test"],
-): T[] =>
-  [...candidates].sort((a, b) => {
+): T[] => {
+  const validationEvaluations = (id: string): ExperimentEvaluation[] =>
+    candidateEvaluations(experiment, id).filter((entry) => entry.split === "validation");
+  const referenceId = ["baseline", ...candidates.map((candidate) => candidate.id).sort()].find(
+    (id) => {
+      const entries = validationEvaluations(id);
+      return campaign.profiles.every((profile) =>
+        entries.some((entry) => entry.profileId === profile && completeScoreEvidence(entry)),
+      );
+    },
+  );
+  const reference = referenceId ? validationEvaluations(referenceId) : [];
+  return [...candidates].sort((a, b) => {
     const activeConstraints = campaign.objectives.constraints.filter((constraint) =>
       constraintSplits.includes(constraint.split),
     );
@@ -310,20 +362,40 @@ export const rankCandidates = <T extends ExperimentDecisionCandidate>(
       }
     }
     const quality = (candidate: ExperimentDecisionCandidate): number => {
-      const values = metricValues(
-        candidate,
-        "quality.passRate",
-        undefined,
-        "validation",
-        experiment,
-      );
-      return values.length > 0 ? Math.min(...values) : -1;
+      if (!hasScoreEvidence(experiment, "validation")) {
+        const values = metricValues(
+          candidate,
+          "quality.passRate",
+          undefined,
+          "validation",
+          experiment,
+        );
+        return values.length > 0 ? Math.min(...values) : -1;
+      }
+      const evaluations = candidateEvaluations(experiment, candidate.id);
+      const scores = campaign.profiles.map((profile) => {
+        const entry = evaluations.find(
+          (value) => value.profileId === profile && value.split === "validation",
+        );
+        if (
+          !entry ||
+          !completeScoreEvidence(entry) ||
+          !comparableScoreBasis(
+            entry,
+            reference.find((value) => value.profileId === profile),
+          )
+        )
+          return -1;
+        return entry.metrics.score ?? -1;
+      });
+      return scores.length > 0 ? Math.min(...scores) : -1;
     };
     const qualityDelta = quality(b) - quality(a);
     if (qualityDelta !== 0) return qualityDelta;
     if (a.sourceBytes !== b.sourceBytes) return a.sourceBytes - b.sourceBytes;
     return a.id.localeCompare(b.id);
   });
+};
 
 const candidateCaseVector = (
   candidate: Candidate,
@@ -338,10 +410,15 @@ const candidateCaseVector = (
     evaluations
       .filter((entry) => entry.split === split)
       .flatMap((entry) =>
-        Object.entries(entry.casePassRates).map(([caseId, passRate]) => [
-          `${entry.profileId}:${caseId}`,
-          passRate,
-        ]),
+        Object.entries(entry.casePassRates).flatMap(([caseId, passRate]) => {
+          if (!hasScoreEvidence(experiment, split))
+            return [[`${entry.profileId}:${caseId}`, passRate]];
+          const sample = entry.caseSamples?.[caseId];
+          const score = sample?.metrics.score;
+          return score?.n === entry.repetitions && sample?.scoreBasis
+            ? [[JSON.stringify([entry.profileId, caseId, sample.scoreBasis]), score.mean]]
+            : [];
+        }),
       ),
   );
 };
@@ -351,8 +428,9 @@ const dominates = (a: Record<string, number>, b: Record<string, number>): boolea
   if (keys.size === 0) return false;
   let strictlyBetter = false;
   for (const key of keys) {
-    const av = a[key] ?? 0;
-    const bv = b[key] ?? 0;
+    const av = a[key];
+    const bv = b[key];
+    if (av === undefined || bv === undefined) return false;
     if (av < bv) return false;
     if (av > bv) strictlyBetter = true;
   }
@@ -404,8 +482,13 @@ const frontierCoverage = (
   const candidateVector = candidateCaseVector(candidate, experiment, "train");
   const keys = new Set(vectors.flatMap((vector) => Object.keys(vector)));
   return [...keys].filter((key) => {
-    const best = Math.max(...vectors.map((vector) => vector[key] ?? 0));
-    return (candidateVector[key] ?? 0) === best;
+    const values = vectors.flatMap((vector) => (vector[key] === undefined ? [] : [vector[key]]));
+    const best = Math.max(...values);
+    return (
+      (frontier.length === 1 || values.length > 1) &&
+      candidateVector[key] !== undefined &&
+      candidateVector[key] === best
+    );
   }).length;
 };
 

package/src/orchestrator/grading.ts

@@ -131,6 +131,17 @@ const assertionPassed = (result: AssertionResult, threshold: number): boolean =>
   result.passed &&
   result.score >= threshold;
 
+export const gradingScoreBasis = (report: GradingReport | null): string | null =>
+  report?.caseScore === null || !report
+    ? null
+    : valueHash(
+        report.assertions
+          .map((entry, index) => ({ entry, id: entry.id ?? `${entry.type}:${index + 1}` }))
+          .filter(({ entry }) => entry.errorMessage === undefined && entry.abstention === undefined)
+          .map(({ entry, id }) => ({ id, weight: entry.weight }))
+          .sort((a, b) => a.id.localeCompare(b.id)),
+      );
+
 const aggregateGrading = (
   entries: GradingAssertionEntry[],
   skippedAssertions: NonNullable<GradingReport["skippedAssertions"]>,

package/src/orchestrator/list-runs.ts

@@ -162,9 +162,7 @@ export const formatRunsTable = (runs: ListedRun[]): string => {
       else if (r.casePassed === true) status = "PASS";
       else if (r.casePassed === false) status = "FAIL";
       const score =
-        r.caseScore !== null
-          ? `${(r.caseScore * 100).toFixed(0)}% (${r.assertionPassed}/${r.assertionTotal})`
-          : "—";
+        r.caseScore !== null ? `${r.caseScore} (${r.assertionPassed}/${r.assertionTotal})` : "—";
       const duration = r.durationMs !== null ? `${(r.durationMs / 1000).toFixed(1)}s` : "—";
       const agents = r.subagentCount > 0 ? `1+${r.subagentCount}` : "1";
       return [status, r.caseSlug, r.driverName, agents, r.ts, r.exitReason ?? "?", score, duration];
@@ -362,8 +360,7 @@ const appendGradingDetail = (lines: string[], detail: RunDetail): void => {
     let status = "ungraded";
     if (detail.grading.casePassed === true) status = "PASS";
     else if (detail.grading.casePassed === false) status = "FAIL";
-    const score =
-      detail.grading.caseScore !== null ? `${(detail.grading.caseScore * 100).toFixed(0)}%` : "—";
+    const score = detail.grading.caseScore !== null ? String(detail.grading.caseScore) : "—";
     lines.push(
       `grading: ${status} (${score}, ${detail.grading.assertions.filter((a) => a.passed).length}/${detail.grading.assertions.filter((a) => a.passed !== null).length})`,
     );
@@ -373,7 +370,9 @@ const appendGradingDetail = (lines: string[], detail: RunDetail): void => {
       if (a.abstention) mark = "?";
       const took = ` (${(a.durationMs / 1000).toFixed(1)}s)`;
       const abstention = a.abstention ? " — insufficient evidence" : "";
-      lines.push(`  ${mark} ${a.name}${took}${abstention}${a.comment ? ` — ${a.comment}` : ""}`);
+      lines.push(
+        `  ${mark} ${a.name} [score ${a.errorMessage !== undefined || a.abstention ? "unavailable" : a.score}]${took}${abstention}${a.comment ? ` — ${a.comment}` : ""}`,
+      );
     }
   }
 };

package/src/orchestrator/paired-effects.ts

@@ -24,6 +24,7 @@ export const clusterCaseSamples = (
       }
       if (current.identityHash !== sample.identityHash) current.identityHash = null;
       if (current.clusterId !== sample.clusterId) current.identityHash = null;
+      if (current.scoreBasis !== sample.scoreBasis) current.scoreBasis = null;
       const metrics = new Map(Object.entries(current.metrics));
       for (const [metric, value] of Object.entries(sample.metrics)) {
         const before = metrics.get(metric);
@@ -65,7 +66,9 @@ export const groupedCaseMetricSamples = (
       if (
         Object.values(samples).some(
           (sample) =>
-            !Object.hasOwn(sample.metrics, metric) || sample.metrics[metric]?.n !== repetitions,
+            !Object.hasOwn(sample.metrics, metric) ||
+            sample.metrics[metric]?.n !== repetitions ||
+            (metric === "score" && !sample.scoreBasis),
         )
       )
         return [];
@@ -132,6 +135,8 @@ const pairedDeltas = (
     const b = after.caseSamples?.[id];
     if (!a?.identityHash || a.identityHash !== b?.identityHash)
       throw new Error(`paired case '${id}' has incompatible evaluation identity`);
+    if (metric === "score" && (!a.scoreBasis || a.scoreBasis !== b.scoreBasis))
+      throw new Error(`paired score for case '${id}' has different or unavailable scoring basis`);
     if (a.clusterId !== b.clusterId)
       throw new Error(`paired case '${id}' has incompatible cluster membership`);
     const av = Object.hasOwn(a.metrics, metric) ? a.metrics[metric] : undefined;

package/src/orchestrator/suite-compare.ts

@@ -74,10 +74,19 @@ const pairedMetricDeltas = (
     const a = before[index];
     const b = after[index];
     if (!a || !b) continue;
-    const names = new Set([...Object.keys(a.metrics), ...Object.keys(b.metrics)]);
+    const am: Record<string, number> = {
+      ...a.metrics,
+      ...(a.score !== undefined ? { score: a.score } : {}),
+    };
+    const bm: Record<string, number> = {
+      ...b.metrics,
+      ...(b.score !== undefined ? { score: b.score } : {}),
+    };
+    const names = new Set([...Object.keys(am), ...Object.keys(bm)]);
     for (const name of names) {
-      const av = a.metrics[name];
-      const bv = b.metrics[name];
+      if (name === "score" && (!a.scoreBasis || a.scoreBasis !== b.scoreBasis)) continue;
+      const av = am[name];
+      const bv = bm[name];
       if (av === undefined || bv === undefined) continue;
       const values = deltas.get(name) ?? [];
       values.push(bv - av);
@@ -196,9 +205,14 @@ export const formatSuiteComparisonText = (comparison: SuiteComparison): string =
     }
   }
   for (const entry of comparison.cases) {
-    if (!entry.regressed) continue;
+    if (entry.regressed) {
+      lines.push(
+        `    ↓ ${suiteGroupKey(entry)}: ${entry.before ? percent(entry.before.passRate) : "—"} → ${entry.after ? percent(entry.after.passRate) : "missing"}`,
+      );
+    }
+    const score = entry.pairedMetricDeltas.score;
     lines.push(
-      `    ↓ ${suiteGroupKey(entry)}: ${entry.before ? percent(entry.before.passRate) : "—"} → ${entry.after ? percent(entry.after.passRate) : "missing"}`,
+      `    ${suiteGroupKey(entry)} score change: ${score ? `${score.mean >= 0 ? "+" : ""}${score.mean} (${score.n} paired)` : "unavailable"}`,
     );
   }
   return lines.join("\n");

package/src/orchestrator/suite-summary.ts

@@ -11,6 +11,7 @@ import {
 import { hasAgentUsage } from "../core/usage.js";
 import { runComparisonIdentity } from "./comparison-identity.js";
 import { safeReadJson } from "./fs-read.js";
+import { gradingScoreBasis } from "./grading.js";
 import type { SuiteCaseResult } from "./orchestrator.js";
 import type { SuiteRun } from "./suite-runs.js";
 
@@ -65,6 +66,7 @@ export const SuiteSampleSchema = z.object({
   passed: z.boolean().nullable(),
   identityHash: z.string().nullable(),
   score: z.exactOptional(z.number()),
+  scoreBasis: z.exactOptional(z.string().nullable()),
   metrics: z.record(z.string(), z.number()),
 });
 export type SuiteSample = z.infer<typeof SuiteSampleSchema>;
@@ -354,7 +356,10 @@ export const buildSuiteSummary = (
     samples: entries.map((entry, index) => {
       const samples: MetricSamples = new Map();
       const result = entry.result?.result;
-      if (result) collectMetadata(samples, result.metadata);
+      if (result) {
+        add(samples, "score", result.grading.caseScore ?? undefined);
+        collectMetadata(samples, result.metadata);
+      }
       return {
         index,
         caseId: entry.item.caseId,
@@ -364,7 +369,7 @@ export const buildSuiteSummary = (
         passed: entry.result?.casePassed ?? null,
         identityHash: result ? runComparisonIdentity(result.metadata) : null,
         ...(result?.grading.caseScore !== null && result?.grading.caseScore !== undefined
-          ? { score: result.grading.caseScore }
+          ? { score: result.grading.caseScore, scoreBasis: gradingScoreBasis(result.grading) }
           : {}),
         metrics: Object.fromEntries(
           [...samples.entries()].map(([name, sample]) => [name, sample.values[0] ?? 0]),

package/src/previewer/server.ts

@@ -7,6 +7,7 @@ import { type DriverMetricDescriptor, type DriverMetrics, exec } from "../core/i
 import {
   compareRuns,
   compareSuiteRuns,
+  hasRegression,
   type ListedRun,
   listExperimentRuns,
   listRuns,
@@ -424,6 +425,7 @@ const handleRunComparison = async ({
   ]);
   sendJson(request, response, 200, {
     kind: "run",
+    regressed: hasRegression(comparison),
     comparison: {
       ...comparison,
       pathA: displayPath(runsRoot, before.runDir),

package/viewer/app.css

@@ -1256,6 +1256,37 @@ h1 {
   color: var(--muted);
 }
 
+.score-bar {
+  position: relative;
+  display: block;
+  width: 100%;
+  min-width: 92px;
+  height: 9px;
+  background: #282d30;
+}
+
+.score-fill {
+  display: block;
+  height: 100%;
+  background: var(--muted);
+}
+
+.score-fill.tone-positive,
+.score-fill.tone-after {
+  background: var(--lime);
+}
+
+.score-fill.tone-negative {
+  background: var(--coral);
+}
+
+.score-bar > .has-threshold {
+  position: absolute;
+  top: -2px;
+  height: 13px;
+  border-left: 1px solid currentColor;
+}
+
 .quantized-bar {
   display: grid;
   grid-template-columns: repeat(20, minmax(2px, 1fr));
@@ -1405,6 +1436,7 @@ h1 {
   text-transform: uppercase;
 }
 
+.assertion-content > .score-bar,
 .assertion-content > .quantized-bar {
   max-width: 220px;
   margin-top: 8px;

package/viewer/charts.js

@@ -51,28 +51,40 @@ const distributionBar = (segments, label) => {
   </div>`;
 };
 
+export const scoreBar = (value, tone, label, threshold = null) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return `<span class="score-bar unavailable" role="img" aria-label="${escapeHtml(label)}"></span>`;
+  }
+  return `<span class="score-bar" role="img" aria-label="${escapeHtml(label)}">
+    <i class="score-fill ${escapeHtml(tone)}" style="width: ${value * 100}%"></i>
+    ${typeof threshold === "number" ? `<i class="has-threshold" style="left: ${threshold * 100}%"></i>` : ""}
+  </span>`;
+};
+
 export const comparisonBars = ({
   title,
   before,
   after,
   maximum,
+  continuous = false,
   beforeText,
   afterText,
   deltaText,
   deltaTone,
 }) => {
+  const bar = continuous ? scoreBar : quantizedBar;
   const scale = Math.max(maximum ?? 0, before ?? 0, after ?? 0, 1);
   return `<figure class="comparison-bars">
     <figcaption><span>${escapeHtml(title)}</span><b class="${escapeHtml(
       deltaTone,
     )}">${escapeHtml(deltaText)}</b></figcaption>
-    <div class="bar-lane"><strong>A</strong>${quantizedBar(
-      (before ?? 0) / scale,
+    <div class="bar-lane"><strong>A</strong>${bar(
+      before === null || before === undefined ? null : before / scale,
       "tone-before",
       `${title} baseline ${beforeText}`,
     )}<span>${escapeHtml(beforeText)}</span></div>
-    <div class="bar-lane"><strong>B</strong>${quantizedBar(
-      (after ?? 0) / scale,
+    <div class="bar-lane"><strong>B</strong>${bar(
+      after === null || after === undefined ? null : after / scale,
       "tone-after",
       `${title} candidate ${afterText}`,
     )}<span>${escapeHtml(afterText)}</span></div>