@mutagent/helix 0.1.0-alpha.14

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/scripts/render-report.ts

@@ -0,0 +1,212 @@
+/**
+ * scripts/render-report.ts
+ * ---------------------------------------------------------------------------
+ * The color-coded renderer — composes the 4-tab master-audit HTML from the
+ * assembled scorecard + the tab fragments (data-leak Tab-2, variance Tab-3,
+ * methodology Tab-4). Renders from the evaluator's OWN bundled Mutagent brand
+ * asset (assets/brand/theme.css + wordmark.html) so the report is visually
+ * consistent with the diagnostics gold-standard report (dark theme, MUTAGENT
+ * wordmark, same tokens) WITHOUT referencing the diagnostics package at runtime.
+ *
+ * Deterministic + null-guarded: every dereference is guarded so a contract-
+ * incomplete input fails-loud at the assembler, never crashes the renderer. The
+ * only non-deterministic input is the injected generatedAt (passed in), so two
+ * renders of the same scorecard are byte-identical after the generatedAt mask.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  type GateComponent,
+  type Scorecard,
+  type ScorecardCriterion,
+} from "./contracts/types.ts";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const BRAND_DIR = join(HERE, "..", "assets", "brand");
+
+/** HTML-escape (null-guarded — no throw on undefined). */
+export function esc(s: unknown): string {
+  return String(s ?? "")
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function sevBadge(sev: string): string {
+  const cls =
+    sev === "CRIT"
+      ? "b-crit"
+      : sev === "HIGH"
+        ? "b-high"
+        : sev === "MED"
+          ? "b-med"
+          : "b-low";
+  return `<span class="badge ${cls}">${esc(sev)}</span>`;
+}
+
+function resultBadge(result: string): string {
+  const cls =
+    result === "pass" ? "b-pass" : result === "fail" ? "b-fail" : "b-skip";
+  return `<span class="badge ${cls}">${esc(result)}</span>`;
+}
+
+function criterionRow(c: ScorecardCriterion): string {
+  return (
+    `<tr><td>${esc(c.dimension)}</td>` +
+    `<td>${sevBadge(c.severity)}</td>` +
+    `<td><code>${esc(c.checkMethod)}</code></td>` +
+    `<td>${esc(c.track)}</td>` +
+    `<td>${resultBadge(c.result)}</td>` +
+    `<td>${esc(c.detail)}</td></tr>`
+  );
+}
+
+function componentSection(g: GateComponent): string {
+  const passBadge = g.pass
+    ? `<span class="badge b-pass">PASS</span>`
+    : `<span class="badge b-fail">FAIL</span>`;
+  const rows = g.criteria.map(criterionRow).join("");
+  return (
+    `<h3>${esc(g.componentId)} ${passBadge}</h3>` +
+    `<table><thead><tr><th>Dimension</th><th>Sev</th><th>Check</th><th>Track</th><th>Result</th><th>Detail</th></tr></thead>` +
+    `<tbody>${rows}</tbody></table>`
+  );
+}
+
+export interface RenderTabs {
+  /** Tab-2 data-leak HTML fragment (body of the panel). */
+  dataLeakHtml?: string;
+  /** Tab-4 methodology-review HTML fragment. */
+  methodologyHtml?: string;
+}
+
+function evalMatrixTab(scorecard: Scorecard): string {
+  const t = scorecard.gate.totals;
+  // GA — ternary fail ▸ incomplete ▸ pass (back-compat: derive from runPass when
+  // runVerdict is absent, e.g. legacy v1 scorecards never carry incomplete rows).
+  const runVerdict = scorecard.gate.runVerdict ?? (scorecard.gate.runPass ? "pass" : "fail");
+  const incompleteN = t.incomplete ?? 0;
+  const verdictClass = runVerdict === "pass" ? "pass" : runVerdict === "incomplete" ? "skip" : "fail";
+  const verdictText =
+    runVerdict === "pass"
+      ? "Run PASS — every component cleared the severity gate (0 CRIT/HIGH fail or indeterminate)."
+      : runVerdict === "incomplete"
+        ? `Run INCOMPLETE — ${incompleteN} CRIT/HIGH criteria indeterminate (no CRIT/HIGH fail). The run cannot be certified — NOT a pass.`
+        : `Run FAIL — ${t.critFail} CRIT + ${t.highFail} HIGH criteria failed the gate.`;
+  const tiles = [
+    ["Components", String(scorecard.gate.components.length)],
+    ["Pass", String(t.pass)],
+    ["Fail", String(t.fail)],
+    ["Skip (seam)", String(t.skip)],
+    ["CRIT fail", String(t.critFail)],
+    ["HIGH fail", String(t.highFail)],
+  ]
+    .map(
+      ([l, v]) =>
+        `<div class="s"><div class="v">${esc(v)}</div><div class="l">${esc(l)}</div></div>`,
+    )
+    .join("");
+  const components = scorecard.gate.components.map(componentSection).join("");
+  return (
+    `<h2>Eval Matrix — Track-1 GATE</h2>` +
+    `<div class="sub">Binary, severity-gated. Component PASS iff 0 CRIT/HIGH fail. Run PASS iff all components pass. Advisory.</div>` +
+    `<div class="verdict ${verdictClass}"><strong>${esc(verdictText)}</strong></div>` +
+    `<div class="big-stat">${tiles}</div>` +
+    components
+  );
+}
+
+function varianceTab(scorecard: Scorecard): string {
+  const dims = scorecard.trend.dimensions ?? [];
+  const rows = dims
+    .map(
+      (d) =>
+        `<tr><td>${esc(d.name)}</td><td>${esc(d.measure)}</td><td>${esc(d.target)}</td><td>${esc(d.divergence)}</td></tr>`,
+    )
+    .join("");
+  const pairNote = scorecard.trend.runPair
+    ? `run-pair: <code>${esc(scorecard.trend.runPair.a)}</code> vs <code>${esc(scorecard.trend.runPair.b)}</code>`
+    : "single-run audit — no run-pair compared (variance dimensions not-evaluated)";
+  return (
+    `<h2>Variance Trend — Track-2 TREND</h2>` +
+    `<div class="sub">The 15-dim determinism score, SEPARATE from GATE, never merged. ${pairNote}.</div>` +
+    `<div class="big-stat"><div class="s"><div class="v">${esc(scorecard.trend.varianceScore)}</div><div class="l">Variance score (diverged dims)</div></div></div>` +
+    `<table><thead><tr><th>Dimension</th><th>Measure</th><th>Target</th><th>Divergence</th></tr></thead><tbody>${rows}</tbody></table>`
+  );
+}
+
+/**
+ * Render the full 4-tab report HTML. Pure string assembly; no I/O except reading
+ * the bundled brand assets.
+ */
+export function renderReport(
+  scorecard: Scorecard,
+  tabs: RenderTabs = {},
+): string {
+  const theme = readFileSync(join(BRAND_DIR, "theme.css"), "utf8");
+  const wordmark = readFileSync(join(BRAND_DIR, "wordmark.html"), "utf8");
+
+  const headerTitle = "Evaluator — Master Audit";
+  const headerMeta =
+    `<span class="mk">subject</span> <span class="mv">${esc(scorecard.subject)}</span>` +
+    `<span class="sep">·</span><span class="mk">runId</span> <span class="mv">${esc(scorecard.runId)}</span>` +
+    `<span class="sep">·</span><span class="mk">generated</span> <span class="mv">${esc(scorecard.generatedAt)}</span>`;
+  const header = wordmark
+    .replaceAll("{{HEADER_TITLE}}", esc(headerTitle))
+    .replaceAll("{{HEADER_META}}", headerMeta);
+
+  const dataLeak =
+    tabs.dataLeakHtml ??
+    `<h2>Data-Leak Graph</h2><div class="sub">Tab-2 — pipeline-with-leak-edges (C2C/UI x class x formal-structure).</div><div class="warn"><strong>Not composed:</strong> run workflows/data-leak.workflow.js to populate this tab (judge-execution seam).</div>`;
+  const methodology =
+    tabs.methodologyHtml ??
+    `<h2>Methodology Review</h2><div class="sub">Tab-4 — fitness, not conformance. Decision-tree fitness · data-flow efficiency · process self-feedback.</div><div class="warn"><strong>Not composed:</strong> run the methodology-critic lens to populate this tab (judge-execution seam).</div>`;
+
+  return `<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+<head>
+<meta charset="UTF-8">
+<title>${esc(headerTitle)} — ${esc(scorecard.subject)}</title>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+<style>
+${theme}
+</style>
+</head>
+<body>
+${header}
+<nav class="tabs">
+  <button class="tab-btn active" data-tab="t1">Eval Matrix</button>
+  <button class="tab-btn" data-tab="t2">Data-Leak</button>
+  <button class="tab-btn" data-tab="t3">Variance Trend</button>
+  <button class="tab-btn internal" data-tab="t4">Methodology Review</button>
+</nav>
+<main>
+  <section class="panel active" id="t1">${evalMatrixTab(scorecard)}</section>
+  <section class="panel" id="t2">${dataLeak}</section>
+  <section class="panel" id="t3">${varianceTab(scorecard)}</section>
+  <section class="panel" id="t4">${methodology}</section>
+</main>
+<script>
+(function(){
+  var btns = document.querySelectorAll('nav.tabs button');
+  var panels = document.querySelectorAll('main .panel');
+  for (var i = 0; i < btns.length; i++) {
+    btns[i].addEventListener('click', function(){
+      var tab = this.getAttribute('data-tab');
+      for (var j = 0; j < btns.length; j++) btns[j].classList.remove('active');
+      for (var k = 0; k < panels.length; k++) panels[k].classList.remove('active');
+      this.classList.add('active');
+      var panel = document.getElementById(tab);
+      if (panel) panel.classList.add('active');
+    });
+  }
+})();
+</script>
+</body>
+</html>
+`;
+}

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/scripts/resolve-credential.ts

@@ -0,0 +1,110 @@
+/**
+ * scripts/resolve-credential.ts
+ * The shared secret resolver (operator decision 2026-06-29). PORTED IN — standalone
+ * copy (no cross-skill import; mirrors the orchestrator's canonical impl).
+ *
+ * A `creds_ref` / `credential_ref` in `.mutagent/config.yaml` is NEVER a raw secret
+ * — it names where the value lives. This turns the ref into the value by a fixed
+ * PRECEDENCE:
+ *
+ *   1. process.env[name]   — the running environment wins (CI / shell export).
+ *   2. local `.env`        — projectRoot/.env (the conventional dev secret file).
+ *   3. `.mutagentrc`       — projectRoot/.mutagentrc (the credential/provider store;
+ *                            the fallback when no `.env` is around — it STAYS).
+ *
+ * Raw secret VALUES never enter config.yaml. Pure core with INJECTED deps (env map
+ * + file reader) → deterministic tests. Secret-safety: this module returns the
+ * value only to its caller; it never logs it.
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+export type CredentialRef = string | { env: string; path?: string };
+export type CredentialSource = "env" | ".env" | ".mutagentrc" | "ref-path";
+
+export type ResolveCredentialResult =
+  | { found: true; value: string; source: CredentialSource; from: string }
+  | { found: false; name: string; tried: string[] };
+
+export interface ResolveCredentialDeps {
+  env: Record<string, string | undefined>;
+  /** File contents, or null if unreadable/absent. Never throws. */
+  readFile: (p: string) => string | null;
+}
+
+const ENV_LINE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/;
+
+/** Parse a dotenv-style file (`.env` / `.mutagentrc`). Pure — string in, map out. */
+export function parseDotenv(content: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const m = ENV_LINE.exec(line);
+    if (!m) continue;
+    const key = m[1];
+    let val = m[2];
+    const quoted =
+      (val.startsWith('"') && val.endsWith('"') && val.length >= 2) ||
+      (val.startsWith("'") && val.endsWith("'") && val.length >= 2);
+    if (quoted) {
+      val = val.slice(1, -1);
+    } else {
+      const hash = val.indexOf(" #");
+      if (hash >= 0) val = val.slice(0, hash).trim();
+    }
+    out[key] = val;
+  }
+  return out;
+}
+
+function normalizeRef(ref: CredentialRef): { name: string; refPath?: string } {
+  if (typeof ref === "string") return { name: ref };
+  return { name: ref.env, refPath: ref.path };
+}
+
+/**
+ * Resolve a credential ref to its secret by precedence (env → .env → .mutagentrc),
+ * with an optional ref-pinned file tried FIRST among files. Pure: I/O injected.
+ */
+export function resolveCredential(
+  ref: CredentialRef,
+  projectRoot: string,
+  deps: ResolveCredentialDeps,
+): ResolveCredentialResult {
+  const { name, refPath } = normalizeRef(ref);
+  const tried: string[] = [];
+
+  const envVal = deps.env[name];
+  if (envVal !== undefined && envVal !== "") {
+    return { found: true, value: envVal, source: "env", from: `process.env.${name}` };
+  }
+  tried.push(`process.env.${name}`);
+
+  const fileTiers: { label: CredentialSource; file: string }[] = [];
+  if (refPath) fileTiers.push({ label: "ref-path", file: resolve(projectRoot, refPath) });
+  fileTiers.push({ label: ".env", file: resolve(projectRoot, ".env") });
+  fileTiers.push({ label: ".mutagentrc", file: resolve(projectRoot, ".mutagentrc") });
+
+  for (const tier of fileTiers) {
+    tried.push(tier.file);
+    const content = deps.readFile(tier.file);
+    if (content === null) continue;
+    const val = parseDotenv(content)[name];
+    if (val !== undefined && val !== "") {
+      return { found: true, value: val, source: tier.label, from: tier.file };
+    }
+  }
+
+  return { found: false, name, tried };
+}
+
+/** Real-fs reader: contents or null (never throws). */
+export function readFileOrNull(p: string): string | null {
+  try {
+    return readFileSync(p, "utf-8");
+  } catch {
+    return null;
+  }
+}

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/scripts/resolve-ref.ts

@@ -0,0 +1,98 @@
+/**
+ * scripts/resolve-ref.ts — GA-1/GA-2 the resolve-ref primitive (named CLI + lib).
+ * ---------------------------------------------------------------------------
+ * The single deterministic guard both GA edges ride:
+ *   · GA-1 GATHER — an `observed` criterion's evidence refs must RE-RESOLVE
+ *                   exact-match against the trace (else inferred-as-observed).
+ *   · GA-2 BIND   — at judge time every criterion TERM (its referents) must
+ *                   resolve to a grounded referent in the SITUATION trace; an
+ *                   unbound term ⇒ indeterminate(factual-intent), NOT a fail.
+ *
+ * The pure core (`resolveRef` / `bindCriterionTerms` / `normalizeRefText`) lives
+ * in the contract (`contracts/eval-types.ts`) so it is import-safe everywhere
+ * (the gate `assertGroundingHonest` rides it too). This script RE-EXPORTS that
+ * core under the spec's `resolve-ref` name, adds the BIND verdict-shaping helper,
+ * and a thin CLI for ad-hoc resolution. PURE — no clock/random/network.
+ */
+import { readFileSync } from "node:fs";
+import {
+  AssumptionKind,
+  OutcomeVerdict,
+  bindCriterionTerms,
+  resolveRef,
+  type CriterionVerdict,
+  type DiscoveryRef,
+  type EvalTrace,
+  type MinedCriterion,
+  type VerdictBlock,
+} from "./contracts/eval-types.ts";
+
+export {
+  bindCriterionTerms,
+  normalizeRefText,
+  resolveRef,
+  type BindResult,
+  type RefResolution,
+} from "./contracts/eval-types.ts";
+
+/**
+ * GA-2 L1 — bind a criterion to a SITUATION before judging. Returns either
+ * `{ bound: true }` (judge may proceed) or a ready-made INDETERMINATE verdict
+ * (`uncertain` + `blockedBy: { kind: factual-intent }`) naming the unbound terms.
+ * The judge NEVER returns a fail on an unbound term — abstention is the contract.
+ * PURE.
+ */
+export function bindBeforeJudge(
+  criterion: MinedCriterion,
+  traceId: string,
+  situation: EvalTrace[],
+  extraTerms: DiscoveryRef[] = [],
+): { bound: true } | { bound: false; verdict: CriterionVerdict } {
+  const refs = criterion.discovery.evidence.refs;
+  const res = bindCriterionTerms(refs, situation, extraTerms);
+  if (res.bound) return { bound: true };
+  const unboundList = res.unbound.map((r) => `${r.obs}/${r.path}:"${r.value}"`).join(", ");
+  const blockedBy: VerdictBlock = {
+    kind: AssumptionKind.FactualIntent,
+    text: `unbound criterion term(s) — no referent in this situation: ${unboundList}`,
+  };
+  return {
+    bound: false,
+    verdict: {
+      criterionId: criterion.id,
+      traceId,
+      result: OutcomeVerdict.Uncertain,
+      confidence: 0,
+      critique:
+        "BIND failed (GA-2 L1): a term this criterion presupposes has no grounded " +
+        `referent in the situation — abstaining (indeterminate), not failing. ${blockedBy.text}`,
+      blockedBy,
+    },
+  };
+}
+
+// ── CLI: bun scripts/resolve-ref.ts <traces.json> <obs> <path> <value> ───────
+declare const Bun: { argv: string[] } | undefined;
+
+function main(): void {
+  const argv = typeof Bun !== "undefined" ? Bun.argv.slice(2) : process.argv.slice(2);
+  const [tracesPath, obs, path, value] = argv;
+  if (!tracesPath || obs === undefined || value === undefined) {
+    console.error("usage: resolve-ref.ts <traces.json> <obs> <path> <value>");
+    process.exit(2);
+    return;
+  }
+  const raw = JSON.parse(readFileSync(tracesPath, "utf8")) as unknown;
+  const traces = (Array.isArray(raw) ? raw : [raw]) as EvalTrace[];
+  const ref: DiscoveryRef = { obs, path: path ?? "", value };
+  const res = resolveRef(ref, traces);
+  console.info(JSON.stringify(res, null, 2));
+  process.exit(res.resolved ? 0 : 1);
+}
+
+const isMain =
+  typeof import.meta !== "undefined" &&
+  (import.meta as unknown as { main?: boolean }).main === true;
+if (isMain) {
+  main();
+}

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/scripts/result-verify.ts

@@ -0,0 +1,129 @@
+/**
+ * scripts/result-verify.ts — GA-5 the result-verifier (reviewer ≠ judge · downgrade-only).
+ * ---------------------------------------------------------------------------
+ * The ⑤ VERIFY guard: an INDEPENDENT pass over a decided verdict that asks the
+ * one question sourcing can't secure — does the CLAIM actually ENTAIL the
+ * VERDICT, or is there an inferential leap (a hidden, ungrounded premise)?
+ *
+ * Two hard invariants (the contract):
+ *   1. DOWNGRADE-ONLY — the verifier may only move a verdict DOWN the lattice
+ *      `pass|fail → uncertain(blockedBy)`. It NEVER flips pass↔fail and NEVER
+ *      promotes uncertain→pass/fail. `uncertain` is the floor (returned as-is).
+ *   2. NEVER FIXES — it is a reviewer, not a judge and not a remediator (EV-051);
+ *      it emits a (possibly-downgraded) verdict, nothing else.
+ *
+ * The deterministic skeleton here re-resolves the verdict's cited refs (GA-1) and
+ * applies the independent reviewer's `entails` judgement (the LLM leaf). On a
+ * dead ref OR an inferential leap → downgrade to `uncertain` + a typed
+ * `blockedBy`. PURE — no clock/random/network.
+ */
+import {
+  AssumptionKind,
+  OutcomeVerdict,
+  resolveRef,
+  type AssumptionKindValue,
+  type CriterionVerdict,
+  type EvalTrace,
+  type VerdictBlock,
+} from "./contracts/eval-types.ts";
+
+/** The independent reviewer's judgement (produced by the LLM verify leaf). */
+export interface VerifierSignal {
+  /** does the CLAIM entail the VERDICT? false ⇒ inferential leap ⇒ downgrade. */
+  entails: boolean;
+  /** when !entails: the residual (ungrounded) premise — becomes blockedBy.text. */
+  leap?: string;
+  /** the kind of the residual assumption (default `normative`). */
+  leapKind?: AssumptionKindValue;
+  /** the reviewer identity (≠ the judge that produced the verdict). */
+  reviewerId?: string;
+}
+
+export interface VerifyResult {
+  verdict: CriterionVerdict;
+  downgraded: boolean;
+  reason: string;
+}
+
+function downgrade(
+  verdict: CriterionVerdict,
+  blockedBy: VerdictBlock,
+  reason: string,
+): VerifyResult {
+  return {
+    verdict: {
+      ...verdict,
+      result: OutcomeVerdict.Uncertain,
+      // confidence is meaningless on an abstain — zero it.
+      confidence: 0,
+      critique: `${verdict.critique}\n\n[VERIFY downgrade] ${reason}`,
+      blockedBy,
+    },
+    downgraded: true,
+    reason,
+  };
+}
+
+/**
+ * Verify ONE decided verdict against its situation + the independent reviewer
+ * signal. DOWNGRADE-ONLY. PURE.
+ *
+ * @param verdict   the judge's decided verdict (pass | fail | uncertain).
+ * @param situation the trace(s) the verdict was rendered over (for re-resolution).
+ * @param signal    the independent reviewer's entailment judgement.
+ */
+export function verifyVerdict(
+  verdict: CriterionVerdict,
+  situation: EvalTrace[],
+  signal: VerifierSignal,
+): VerifyResult {
+  // `uncertain` is the lattice floor — nothing to downgrade.
+  if (verdict.result === OutcomeVerdict.Uncertain) {
+    return { verdict, downgraded: false, reason: "already uncertain (lattice floor) — unchanged." };
+  }
+
+  // (a) re-resolve cited refs — a dead ref means the evidence no longer supports
+  //     the claim ⇒ downgrade to uncertain(factual-intent).
+  const refs = verdict.refs ?? [];
+  if (refs.length > 0 && situation.length > 0) {
+    const anyResolves = refs.some((r) => resolveRef(r, situation).resolved);
+    if (!anyResolves) {
+      return downgrade(
+        verdict,
+        {
+          kind: AssumptionKind.FactualIntent,
+          text: "cited evidence no longer re-resolves against the situation (dead ref).",
+        },
+        "VERIFY: none of the verdict's cited refs re-resolve — evidence does not support the claim.",
+      );
+    }
+  }
+
+  // (b) entailment — the master switch. claim true ≠ verdict true.
+  if (!signal.entails) {
+    return downgrade(
+      verdict,
+      {
+        kind: signal.leapKind ?? AssumptionKind.Normative,
+        text: signal.leap ?? "claim does not entail the verdict (residual ungrounded premise).",
+      },
+      `VERIFY (${signal.reviewerId ?? "reviewer"}): inferential leap — the claim does not ` +
+        "entail the verdict; downgrading to indeterminate (not flipping).",
+    );
+  }
+
+  // entails ∧ refs resolve → grounded; verdict stands (verifier never promotes).
+  return { verdict, downgraded: false, reason: "VERIFY: claim entails verdict ∧ refs resolve — grounded." };
+}
+
+/** Batch verify — keyed by criterionId; verdicts with no signal default to
+ *  `entails: true` (no reviewer objection ⇒ stands). DOWNGRADE-ONLY. PURE. */
+export function verifyVerdicts(
+  verdicts: CriterionVerdict[],
+  situation: EvalTrace[],
+  signals: Record<string, VerifierSignal>,
+): VerifyResult[] {
+  return verdicts.map((v) =>
+    verifyVerdict(v, situation, signals[v.criterionId] ?? { entails: true }),
+  );
+}