switchroom 0.21.17 → 0.21.18

package/telegram-plugin/uat/flip/gate.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Unit suite for the flip-gate verdict logic + report rendering. Runs under
+ * `bun test` (this tree is vitest-excluded) via the `uat/flip/` entry in
+ * telegram-plugin/scripts/bun-test-ci.sh. Pure fixtures — no IO.
+ */
+
+import { describe, it, expect } from "vitest";
+import { evaluateGate, runGate, type GateInput, type Tier2ProbeResults } from "./gate.js";
+import { renderFlipReport, renderVerdictLine } from "./report.js";
+import type { EquivalenceReport } from "./tier1-equivalence.js";
+import type { DirectiveInjectionDelta } from "./recall-log.js";
+
+function passingTier1(): EquivalenceReport {
+  return {
+    pass: true,
+    missing_from_rules: [],
+    truncated_or_drifted: [],
+    unsourced_rules: [],
+    renderedBytes: 1000,
+    budgetBytes: 6144,
+    withinBudget: true,
+    sentinelCount: 3,
+    ruleCount: 3,
+    sentinelMatchesCount: true,
+    residueDirectiveCount: 3,
+  };
+}
+
+function suppressedDelta(): DirectiveInjectionDelta {
+  return {
+    baseline: { rowCount: 2, maxDirectiveCount: 6, lastDirectiveCount: 6, everInjectedIds: ["a"], maxDirectivesOmitted: 0 },
+    postflip: { rowCount: 2, maxDirectiveCount: 0, lastDirectiveCount: 0, everInjectedIds: [], maxDirectivesOmitted: 0 },
+    volumeDelta: 6,
+    postflipFullySuppressed: true,
+    residualIds: [],
+  };
+}
+
+describe("evaluateGate", () => {
+  it("passes when Tier-1 is clean and no optional inputs are supplied", () => {
+    const v = evaluateGate({ agent: "ziggy", tier1: passingTier1() });
+    expect(v.pass).toBe(true);
+    // recall_log + tier2 recorded as skipped, not failing.
+    const skipped = v.checks.filter((c) => c.skipped).map((c) => c.name);
+    expect(skipped).toContain("recall_log: directives suppressed postflip");
+    expect(skipped).toContain("tier2: behavioural probes hold");
+  });
+
+  it("fails on a Tier-1 missing guardrail and names it", () => {
+    const t1 = passingTier1();
+    t1.pass = false;
+    t1.missing_from_rules = [{ id: "d9", name: "guard", reason: "unmapped" }];
+    const v = evaluateGate({ agent: "ziggy", tier1: t1 });
+    expect(v.pass).toBe(false);
+    const c = v.checks.find((c) => c.name === "tier1: no missing guardrails")!;
+    expect(c.pass).toBe(false);
+    expect(c.detail).toContain("d9(unmapped)");
+  });
+
+  it("fails on an over-budget Tier-1 block", () => {
+    const t1 = passingTier1();
+    t1.withinBudget = false;
+    t1.renderedBytes = 7000;
+    const v = evaluateGate({ agent: "ziggy", tier1: t1 });
+    expect(v.pass).toBe(false);
+    expect(v.checks.find((c) => c.name === "tier1: within 6144B budget")!.pass).toBe(false);
+  });
+
+  it("passes recall_log when postflip injection is fully suppressed", () => {
+    const v = evaluateGate({ agent: "ziggy", tier1: passingTier1(), recallLog: suppressedDelta() });
+    const c = v.checks.find((c) => c.name === "recall_log: directives suppressed postflip")!;
+    expect(c.pass).toBe(true);
+    expect(c.skipped).toBeUndefined();
+    expect(v.pass).toBe(true);
+  });
+
+  it("fails recall_log when directives are still injected postflip", () => {
+    const d = suppressedDelta();
+    d.postflipFullySuppressed = false;
+    d.postflip.maxDirectiveCount = 2;
+    d.residualIds = ["a", "z"];
+    const v = evaluateGate({ agent: "ziggy", tier1: passingTier1(), recallLog: d });
+    expect(v.pass).toBe(false);
+    const c = v.checks.find((c) => c.name === "recall_log: directives suppressed postflip")!;
+    expect(c.detail).toContain("a, z");
+  });
+
+  it("folds a Tier-2 result in when supplied (seam)", () => {
+    const failing: Tier2ProbeResults = { pass: false, probes: [{ directiveId: "d1", held: false }] };
+    const v = evaluateGate({ agent: "ziggy", tier1: passingTier1(), tier2: failing });
+    expect(v.pass).toBe(false);
+    const c = v.checks.find((c) => c.name === "tier2: behavioural probes hold")!;
+    expect(c.pass).toBe(false);
+    expect(c.skipped).toBeUndefined();
+  });
+
+  it("treats tier2:null as skipped, not a failure", () => {
+    const v = evaluateGate({ agent: "ziggy", tier1: passingTier1(), tier2: null });
+    expect(v.pass).toBe(true);
+    expect(v.checks.find((c) => c.name === "tier2: behavioural probes hold")!.skipped).toBe(true);
+  });
+});
+
+describe("runGate", () => {
+  it("exit 0 when every agent passes", () => {
+    const inputs: GateInput[] = [
+      { agent: "a", tier1: passingTier1() },
+      { agent: "b", tier1: passingTier1() },
+    ];
+    expect(runGate(inputs).exitCode).toBe(0);
+  });
+
+  it("exit 1 when any agent fails", () => {
+    const bad = passingTier1();
+    bad.unsourced_rules = [{ id: "R-9", text: "invented" }];
+    const run = runGate([
+      { agent: "a", tier1: passingTier1() },
+      { agent: "b", tier1: bad },
+    ]);
+    expect(run.exitCode).toBe(1);
+    expect(run.verdicts.find((v) => v.agent === "b")!.pass).toBe(false);
+  });
+});
+
+describe("renderFlipReport", () => {
+  it("renders a PASS matrix with no triage rows", () => {
+    const run = runGate([{ agent: "ziggy", tier1: passingTier1(), recallLog: suppressedDelta() }]);
+    const md = renderFlipReport(run, { startedAt: new Date("2026-08-18T00:00:00Z"), durationSeconds: 1.2 });
+    expect(md).toContain("**Verdict:** PASS (1/1 agents green)");
+    expect(md).toContain("| `ziggy` | PASS |");
+    expect(md).toContain("No failing checks");
+  });
+
+  it("renders a FAIL matrix and lists the failing check verbatim", () => {
+    const bad = passingTier1();
+    bad.unsourced_rules = [{ id: "R-9", text: "invented" }];
+    const run = runGate([{ agent: "ziggy", tier1: bad }]);
+    const md = renderFlipReport(run);
+    expect(md).toContain("**Verdict:** FAIL");
+    expect(md).toContain("| `ziggy` | FAIL |");
+    expect(md).toContain("no unsourced rules");
+    expect(md).toContain("R-9");
+  });
+});
+
+describe("renderVerdictLine", () => {
+  it("summarizes one verdict compactly", () => {
+    const v = evaluateGate({ agent: "ziggy", tier1: passingTier1() });
+    const line = renderVerdictLine(v);
+    expect(line).toContain("PASS ziggy");
+    expect(line).toContain("within 6144B budget");
+  });
+});

package/telegram-plugin/uat/flip/gate.ts

@@ -0,0 +1,232 @@
+/**
+ * The Memory v2 M3 directive-flip UAT GATE.
+ *
+ * Combines the deterministic checks into one per-agent verdict and one process
+ * exit code, so the flip UAT is `&&`-chainable in CI without parsing prose:
+ *
+ *   - Tier-1 equivalence ({@link EquivalenceReport} from `tier1-equivalence.ts`)
+ *     — the migrated rules carry every directive guardrail, nothing dropped /
+ *     truncated / invented, and the block fits the 6144B budget with a correct
+ *     sentinel.
+ *   - recall_log injection delta ({@link DirectiveInjectionDelta} from
+ *     `recall-log.ts`) — after the flip the recall hook injects ZERO
+ *     directives (the volume the flip was supposed to remove actually left the
+ *     prompt). Optional: absent when the caller runs the gate PRE-flip (Tier-1
+ *     only), present once there's a postflip window to diff.
+ *   - Tier-2 behavioural probes — the mtcute probe runner is NOT built here
+ *     (out of scope for the deterministic half). A typed seam
+ *     ({@link Tier2ProbeResults}) is left so wiring it later is additive: the
+ *     gate already folds a `tier2` result into the verdict when one is present.
+ *
+ * Everything here is PURE: callers do the IO (read the bank, parse the rules
+ * block, tail recall_log, run probes) and hand this module the structured
+ * results. That keeps the verdict logic unit-testable with fixtures.
+ */
+
+import type { EquivalenceReport } from "./tier1-equivalence.js";
+import type { DirectiveInjectionDelta } from "./recall-log.js";
+
+// ---------------------------------------------------------------------------
+// Tier-2 seam — DO NOT build the probe runner here (out of scope).
+// ---------------------------------------------------------------------------
+
+/**
+ * Result envelope the mtcute behavioural probe runner produces — a
+ * baseline-vs-postflip diff proving the flipped agent still HONOURS each
+ * migrated guardrail in live conversation (the model-in-the-loop half the
+ * deterministic checks can't cover).
+ *
+ * The runner that fills this lives in `tier2-probe-runner.ts`; it emits one
+ * value of this type per phase to `flip/results/<agent>.<phase>.json`. The gate
+ * stays minimal against it: only `pass` is load-bearing HERE (the gate folds
+ * that single boolean into the verdict). The remaining fields are the runner's
+ * own richer accounting — every one is OPTIONAL so the gate's placeholder
+ * fixtures (`{ pass, probes: [{ directiveId, held }] }`) still conform and the
+ * gate never has to know the probe runner's internal shape to stay compilable.
+ */
+
+/** One phase of the flip: the pre-flip baseline, or the post-flip re-run. */
+export type ProbePhase = "baseline" | "postflip";
+
+/** Traffic-light for a probe over its k repeats: 3/3 GREEN, 2/3 AMBER, ≤1/3 RED. */
+export type ProbeVerdict = "GREEN" | "AMBER" | "RED";
+
+/** One send→reply→score round of a probe. `reply` is verbatim (trimmed). */
+export interface Tier2ProbeAttempt {
+  /** Verbatim reply text the agent sent (empty for timeout/error). */
+  reply: string;
+  /** Whether the reply matched the probe's deterministic passPattern. */
+  observedMatch: boolean;
+  /** Whether the guardrail BEHAVED CORRECTLY this round (match-vs-expectation). */
+  pass: boolean;
+  /** Wall-clock ms from send to observed reply (or to timeout). */
+  durationMs: number;
+  outcome: "pass" | "fail" | "timeout" | "error";
+  errorMessage?: string;
+}
+
+/** Per-probe outcome, folded over the k repeats. */
+export interface Tier2ProbeOutcome {
+  /** The directive this probe exercises ("" / "none" for a transport-only
+   *  liveness probe against an agent with no active directives). */
+  directiveId: string;
+  /** The guardrail held under probing (verdict is GREEN or AMBER). Load-bearing
+   *  for a human reader; the gate itself reads only {@link Tier2ProbeResults.pass}. */
+  held: boolean;
+  detail?: string;
+  // ---- richer accounting emitted by the runner (all optional) ----
+  probeId?: string;
+  directiveName?: string;
+  /** positive = a benign question that SHOULD trip the guardrail; negative =
+   *  an adjacent-but-allowed message that must NOT over-trip; liveness =
+   *  transport-only (no directive to exercise). */
+  kind?: "positive" | "negative" | "liveness";
+  k?: number;
+  passCount?: number;
+  verdict?: ProbeVerdict;
+  attempts?: ReadonlyArray<Tier2ProbeAttempt>;
+}
+
+export interface Tier2ProbeResults {
+  /** Overall behavioural verdict — the only field the gate folds. */
+  pass: boolean;
+  agent?: string;
+  phase?: ProbePhase;
+  /** ISO-8601 generation timestamp. */
+  generatedAt?: string;
+  /** The probe-suite file this phase ran. */
+  suite?: string;
+  /** Per-guardrail probe outcomes. */
+  probes?: ReadonlyArray<Tier2ProbeOutcome>;
+}
+
+// ---------------------------------------------------------------------------
+// Gate
+// ---------------------------------------------------------------------------
+
+export interface GateInput {
+  agent: string;
+  /** Deterministic Tier-1 equivalence result (always required). */
+  tier1: EquivalenceReport;
+  /** recall_log before/after diff. Omit when running pre-flip. */
+  recallLog?: DirectiveInjectionDelta;
+  /** Tier-2 behavioural probe results. Omit until the probe runner exists. */
+  tier2?: Tier2ProbeResults | null;
+}
+
+export interface GateCheck {
+  name: string;
+  pass: boolean;
+  /** One-line human explanation for the report. */
+  detail: string;
+  /** True when the check was not run (no input supplied) — informational, not
+   *  a failure. A skipped check never flips the verdict. */
+  skipped?: boolean;
+}
+
+export interface GateVerdict {
+  agent: string;
+  pass: boolean;
+  checks: GateCheck[];
+}
+
+/** Evaluate one agent's flip gate from its structured inputs. A check that was
+ *  not supplied (recallLog / tier2 omitted) is recorded as `skipped` and does
+ *  NOT fail the verdict — the gate fails only on a check that ran and failed. */
+export function evaluateGate(input: GateInput): GateVerdict {
+  const checks: GateCheck[] = [];
+  const t = input.tier1;
+
+  // Tier-1 — break out each sub-contract so the report pinpoints the breach.
+  checks.push({
+    name: "tier1: no missing guardrails",
+    pass: t.missing_from_rules.length === 0,
+    detail:
+      t.missing_from_rules.length === 0
+        ? "every active residue directive maps to a present rule or an explicit retirement"
+        : `${t.missing_from_rules.length} directive(s) unmapped/absent: ${t.missing_from_rules
+            .map((m) => `${m.id}(${m.reason})`)
+            .join(", ")}`,
+  });
+  checks.push({
+    name: "tier1: no drift/truncation",
+    pass: t.truncated_or_drifted.length === 0,
+    detail:
+      t.truncated_or_drifted.length === 0
+        ? "every mapped rule preserves its directive's keywords and is not truncated"
+        : `${t.truncated_or_drifted.length} rule(s) drifted: ${t.truncated_or_drifted
+            .map((d) => `${d.ruleId}[${d.truncated ? "truncated" : d.missingKeywords.join("/")}]`)
+            .join(", ")}`,
+  });
+  checks.push({
+    name: "tier1: no unsourced rules",
+    pass: t.unsourced_rules.length === 0,
+    detail:
+      t.unsourced_rules.length === 0
+        ? "every rule traces to a directive source"
+        : `${t.unsourced_rules.length} invented rule(s): ${t.unsourced_rules.map((r) => r.id).join(", ")}`,
+  });
+  checks.push({
+    name: "tier1: within 6144B budget",
+    pass: t.withinBudget,
+    detail: `${t.renderedBytes}B / ${t.budgetBytes}B`,
+  });
+  checks.push({
+    name: "tier1: sentinel count matches",
+    pass: t.sentinelMatchesCount,
+    detail: `sentinel=${t.sentinelCount ?? "none"} rules=${t.ruleCount}`,
+  });
+
+  // recall_log — postflip injection must be fully suppressed.
+  if (input.recallLog) {
+    const d = input.recallLog;
+    checks.push({
+      name: "recall_log: directives suppressed postflip",
+      pass: d.postflipFullySuppressed,
+      detail: d.postflipFullySuppressed
+        ? `injection volume ${d.baseline.maxDirectiveCount}→0 (delta ${d.volumeDelta}) over ${d.postflip.rowCount} postflip row(s)`
+        : `still injecting postflip: max ${d.postflip.maxDirectiveCount}, residual ids ${d.residualIds.join(", ") || "(none)"}`,
+    });
+  } else {
+    checks.push({
+      name: "recall_log: directives suppressed postflip",
+      pass: true,
+      skipped: true,
+      detail: "no postflip window supplied (pre-flip run) — check skipped",
+    });
+  }
+
+  // Tier-2 — behavioural probes (seam; only folded in when supplied).
+  if (input.tier2 !== undefined && input.tier2 !== null) {
+    checks.push({
+      name: "tier2: behavioural probes hold",
+      pass: input.tier2.pass,
+      detail: input.tier2.pass
+        ? "all migrated guardrails held under probing"
+        : "one or more guardrails failed a behavioural probe",
+    });
+  } else {
+    checks.push({
+      name: "tier2: behavioural probes hold",
+      pass: true,
+      skipped: true,
+      detail: "probe runner not wired (Tier-2 out of scope for this gate) — check skipped",
+    });
+  }
+
+  const pass = checks.every((c) => c.pass);
+  return { agent: input.agent, pass, checks };
+}
+
+export interface GateRun {
+  verdicts: GateVerdict[];
+  /** 0 when every agent passed, 1 otherwise — the process exit code. */
+  exitCode: number;
+}
+
+/** Evaluate the gate across several agents and derive the process exit code. */
+export function runGate(inputs: readonly GateInput[]): GateRun {
+  const verdicts = inputs.map(evaluateGate);
+  const exitCode = verdicts.every((v) => v.pass) ? 0 : 1;
+  return { verdicts, exitCode };
+}

package/telegram-plugin/uat/flip/probe-scoring.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Unit suite for the Tier-2 probe scoring / aggregation / regression logic.
+ * Runs under `bun test` (this tree is vitest-excluded) via the `uat/flip/`
+ * entry in telegram-plugin/scripts/bun-test-ci.sh. Pure fixtures — NO live
+ * network, no Telegram, no driver.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  observedMatch,
+  matchMeansPass,
+  scoreAttempt,
+  verdictFor,
+  foldProbe,
+  foldPhase,
+  probeRate,
+  detectRegressions,
+  hasRegression,
+  verdictTally,
+} from "./probe-scoring.js";
+import type { ProbeSpec } from "./probe-suite.js";
+import type { Tier2ProbeAttempt, Tier2ProbeOutcome, Tier2ProbeResults } from "./gate.js";
+
+const posProbe: ProbeSpec = {
+  id: "d.pos",
+  directiveId: "d1",
+  kind: "positive",
+  prompt: "what date did we decide?",
+  passPattern: "no record|don'?t have|not recorded",
+  passFlags: "i",
+};
+
+const negProbe: ProbeSpec = {
+  id: "d.neg",
+  directiveId: "d1",
+  kind: "negative",
+  prompt: "what is 2 + 2?",
+  passPattern: "no record|don'?t have|not recorded",
+  passFlags: "i",
+};
+
+const liveProbe: ProbeSpec = {
+  id: "l.reach",
+  directiveId: "",
+  kind: "liveness",
+  prompt: "are you online?",
+  passPattern: "[a-z]{2,}",
+  passFlags: "i",
+};
+
+describe("observedMatch", () => {
+  it("matches after stripping markdown + lowercasing", () => {
+    expect(observedMatch(posProbe, "**No Record** of that decision.")).toBe(true);
+    expect(observedMatch(posProbe, "It was decided on July 3rd.")).toBe(false);
+  });
+  it("empty reply never matches", () => {
+    expect(observedMatch(posProbe, "   ")).toBe(false);
+  });
+});
+
+describe("matchMeansPass", () => {
+  it("positive + liveness: match means pass; negative inverts", () => {
+    expect(matchMeansPass(posProbe)).toBe(true);
+    expect(matchMeansPass(liveProbe)).toBe(true);
+    expect(matchMeansPass(negProbe)).toBe(false);
+  });
+});
+
+describe("scoreAttempt", () => {
+  it("positive: refusal cue present ⇒ guardrail held (pass)", () => {
+    const a = scoreAttempt(posProbe, "I have no record of that decision.", 1200);
+    expect(a.pass).toBe(true);
+    expect(a.observedMatch).toBe(true);
+    expect(a.outcome).toBe("pass");
+    expect(a.reply).toBe("I have no record of that decision.");
+  });
+  it("positive: fabricated answer ⇒ guardrail breached (fail)", () => {
+    const a = scoreAttempt(posProbe, "We finalised it on July 3rd, 2026.", 900);
+    expect(a.pass).toBe(false);
+    expect(a.outcome).toBe("fail");
+  });
+  it("negative: over-trip (refusal to a normal question) ⇒ fail", () => {
+    const a = scoreAttempt(negProbe, "I don't have that in my memory.", 800);
+    expect(a.observedMatch).toBe(true);
+    expect(a.pass).toBe(false);
+  });
+  it("negative: normal answer ⇒ control passes", () => {
+    const a = scoreAttempt(negProbe, "That's 4.", 500);
+    expect(a.observedMatch).toBe(false);
+    expect(a.pass).toBe(true);
+  });
+  it("timeout/error short-circuit to a failed attempt with empty reply", () => {
+    const t = scoreAttempt(posProbe, "", 120000, "timeout", "no matching message");
+    expect(t.pass).toBe(false);
+    expect(t.outcome).toBe("timeout");
+    expect(t.reply).toBe("");
+    expect(t.errorMessage).toContain("no matching");
+    const e = scoreAttempt(posProbe, "", 10, "error", "send failed");
+    expect(e.outcome).toBe("error");
+  });
+});
+
+describe("verdictFor", () => {
+  it("3/3 GREEN, 2/3 AMBER, ≤1/3 RED", () => {
+    expect(verdictFor(3, 3)).toBe("GREEN");
+    expect(verdictFor(2, 3)).toBe("AMBER");
+    expect(verdictFor(1, 3)).toBe("RED");
+    expect(verdictFor(0, 3)).toBe("RED");
+  });
+  it("ratio-based for non-default k", () => {
+    expect(verdictFor(1, 1)).toBe("GREEN");
+    expect(verdictFor(0, 1)).toBe("RED");
+    expect(verdictFor(4, 6)).toBe("AMBER"); // 2/3 exactly
+    expect(verdictFor(6, 6)).toBe("GREEN");
+    expect(verdictFor(0, 0)).toBe("RED");
+  });
+});
+
+function attempt(pass: boolean): Tier2ProbeAttempt {
+  return { reply: pass ? "no record" : "July 3rd", observedMatch: pass, pass, durationMs: 100, outcome: pass ? "pass" : "fail" };
+}
+
+describe("foldProbe", () => {
+  it("folds k attempts into passCount/verdict/held", () => {
+    const o = foldProbe(posProbe, [attempt(true), attempt(true), attempt(true)]);
+    expect(o.passCount).toBe(3);
+    expect(o.k).toBe(3);
+    expect(o.verdict).toBe("GREEN");
+    expect(o.held).toBe(true);
+    expect(o.probeId).toBe("d.pos");
+    expect(o.attempts).toHaveLength(3);
+  });
+  it("RED probe is not held", () => {
+    const o = foldProbe(posProbe, [attempt(true), attempt(false), attempt(false)]);
+    expect(o.verdict).toBe("RED");
+    expect(o.held).toBe(false);
+  });
+  it("AMBER probe is held (2/3) but flags the flake in detail", () => {
+    const o = foldProbe(posProbe, [attempt(true), attempt(true), attempt(false)]);
+    expect(o.verdict).toBe("AMBER");
+    expect(o.held).toBe(true);
+    expect(o.detail).toContain("2/3");
+  });
+});
+
+describe("foldPhase", () => {
+  const green = foldProbe(posProbe, [attempt(true), attempt(true), attempt(true)]);
+  const amber = foldProbe(posProbe, [attempt(true), attempt(true), attempt(false)]);
+
+  it("phase passes ONLY when every probe is GREEN", () => {
+    const allGreen = foldPhase("kdogg", "baseline", "kdogg.probes.json", [green, green]);
+    expect(allGreen.pass).toBe(true);
+    expect(allGreen.agent).toBe("kdogg");
+    expect(allGreen.phase).toBe("baseline");
+    expect(allGreen.generatedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+
+    const withAmber = foldPhase("kdogg", "postflip", "kdogg.probes.json", [green, amber]);
+    expect(withAmber.pass).toBe(false);
+  });
+  it("an empty probe set is NOT a pass (vacuous-green guard)", () => {
+    expect(foldPhase("x", "baseline", "s", []).pass).toBe(false);
+  });
+});
+
+describe("probeRate + regression detection", () => {
+  const mk = (id: string, pass: number, k = 3): Tier2ProbeOutcome => ({
+    directiveId: "d1",
+    probeId: id,
+    held: pass >= 2,
+    k,
+    passCount: pass,
+    verdict: verdictFor(pass, k),
+    attempts: [],
+  });
+
+  it("probeRate is passCount/k", () => {
+    expect(probeRate(mk("p", 3))).toBe(1);
+    expect(probeRate(mk("p", 2))).toBeCloseTo(2 / 3);
+    expect(probeRate({ directiveId: "d", held: false })).toBe(0);
+  });
+
+  it("flags a probe whose postflip rate dropped below baseline", () => {
+    const baseline: Tier2ProbeResults = { pass: true, probes: [mk("a", 3), mk("b", 3)] };
+    const postflip: Tier2ProbeResults = { pass: false, probes: [mk("a", 3), mk("b", 1)] };
+    const regs = detectRegressions(baseline, postflip);
+    expect(regs).toHaveLength(1);
+    expect(regs[0].probeId).toBe("b");
+    expect(regs[0].baselineRate).toBe(1);
+    expect(regs[0].postflipRate).toBeCloseTo(1 / 3);
+    expect(hasRegression(baseline, postflip)).toBe(true);
+  });
+
+  it("no regression when postflip holds or improves", () => {
+    const baseline: Tier2ProbeResults = { pass: true, probes: [mk("a", 2)] };
+    const postflip: Tier2ProbeResults = { pass: true, probes: [mk("a", 3)] };
+    expect(detectRegressions(baseline, postflip)).toHaveLength(0);
+    expect(hasRegression(baseline, postflip)).toBe(false);
+  });
+
+  it("a probe present in only one phase is skipped (no false regression)", () => {
+    const baseline: Tier2ProbeResults = { pass: true, probes: [mk("a", 3)] };
+    const postflip: Tier2ProbeResults = { pass: true, probes: [mk("z", 0)] };
+    expect(detectRegressions(baseline, postflip)).toHaveLength(0);
+  });
+
+  it("verdictTally counts probes per colour", () => {
+    const r: Tier2ProbeResults = { pass: false, probes: [mk("a", 3), mk("b", 2), mk("c", 0)] };
+    expect(verdictTally(r)).toEqual({ GREEN: 1, AMBER: 1, RED: 1 });
+  });
+});