@teamscala/service-boot 0.23.516 → 0.23.518

package/src/handlers/platform-fault-escalation.test.ts

@@ -1,497 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { describe, expect, test } from "bun:test";
-import {
-	composeEscalationMessage,
-	composeZeroVolumeMessage,
-	decideSweep,
-	extractWhatsAppMessageId,
-	formatEscalationSample,
-	type EscalationEpisode,
-	type FaultAggregate,
-	type FaultEscalationPolicy,
-} from "./platform-fault-escalation-logic.ts";
-
-const NOW = new Date("2026-08-15T23:45:00+10:00");
-const POLICY: FaultEscalationPolicy = {
-	minCount: 10,
-	minSpanMinutes: 25,
-	resolveAfterMinutes: 30,
-};
-
-function agg(kind: string, count: number, firstSeenMinutesAgo: number, lastSeenMinutesAgo: number): FaultAggregate {
-	return {
-		kind,
-		count,
-		firstSeen: new Date(NOW.getTime() - firstSeenMinutesAgo * 60_000),
-		lastSeen: new Date(NOW.getTime() - lastSeenMinutesAgo * 60_000),
-	};
-}
-
-function episode(overrides: Partial<EscalationEpisode> & { kind: string }): EscalationEpisode {
-	return {
-		firstSeenAt: NOW,
-		lastSeenAt: NOW,
-		eventCount: 10,
-		escalatedAt: new Date(NOW.getTime() - 60 * 60_000),
-		workItemId: "wi-1",
-		resolvedAt: null,
-		rearmedAt: null,
-		lastUpdatedAt: null,
-		...overrides,
-	};
-}
-
-describe("decideSweep — thresholds", () => {
-	test("a single event is noise — never escalates", () => {
-		const decision = decideSweep([agg("push.error", 1, 2, 2)], [], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(0);
-	});
-
-	test("recurrence without duration does not escalate (10 events in 5 min)", () => {
-		const decision = decideSweep([agg("burst.error", 10, 5, 0)], [], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(0);
-	});
-
-	test("duration without recurrence does not escalate (3 events over 40 min)", () => {
-		const decision = decideSweep([agg("sparse.error", 3, 40, 0)], [], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(0);
-	});
-
-	test("the 490-over-12h shape escalates (duration + recurrence)", () => {
-		const sustained = agg("host-command-bus.command.failed", 490, 720, 0);
-		const decision = decideSweep([sustained], [], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(1);
-		expect(decision.escalate[0]!.aggregate.kind).toBe("host-command-bus.command.failed");
-		expect(decision.escalate[0]!.episode).toBeNull();
-	});
-
-	test("per-kind threshold override lets a low-rate persistent kind through", () => {
-		// guard.fail.open: 8 events over 12h — below the default recurrence floor
-		// of 10, but persistent. The override lowers recurrence to 4 over 60 min.
-		const drip = agg("guard.fail.open", 8, 720, 0);
-		const withoutOverride = decideSweep([drip], [], POLICY, NOW);
-		expect(withoutOverride.escalate).toHaveLength(0);
-		const withOverride = decideSweep([drip], [], POLICY, NOW, {
-			"guard.fail.open": { minCount: 4, minSpanMinutes: 60 },
-		});
-		expect(withOverride.escalate).toHaveLength(1);
-	});
-
-	test("override raises a floor too — bursty kinds can be tightened", () => {
-		const sustained = agg("llm.provider.call.failed", 40, 60, 0); // passes default
-		const decision = decideSweep([sustained], [], POLICY, NOW, {
-			"llm.provider.call.failed": { minCount: 100 },
-		});
-		expect(decision.escalate).toHaveLength(0);
-	});
-});
-
-describe("decideSweep — dedup (one escalation per fault, no re-fire)", () => {
-	test("already escalated and unresolved does NOT re-escalate", () => {
-		const sustained = agg("host-command-bus.command.failed", 500, 720, 0);
-		const open = episode({ kind: "host-command-bus.command.failed", escalatedAt: new Date(NOW.getTime() - 3_600_000) });
-		const decision = decideSweep([sustained], [open], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(0);
-	});
-
-	test("open delivered episode emits NOTHING while it recurs — transitions, not cadence", () => {
-		// 2026-08-26: the hourly "still recurring" comment made the alarm
-		// skippable noise and hid a real signal. An open, delivered episode now
-		// stays silent until the close transition fires (see the resolve suite).
-		const sustained = agg("llm.provider.call.failed", 300, 720, 0);
-		const longOpen = episode({
-			kind: "llm.provider.call.failed",
-			escalatedAt: new Date(NOW.getTime() - 90 * 60_000),
-			lastUpdatedAt: new Date(NOW.getTime() - 90 * 60_000),
-		});
-		const decision = decideSweep([sustained], [longOpen], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(0);
-		expect(decision.resolve).toHaveLength(0);
-		expect(Object.keys(decision).sort()).toEqual([
-			"escalate",
-			"rearm",
-			"resolve",
-			"resolveProbeGate",
-			"zeroVolumeHold",
-		]);
-	});
-
-	test("a claimed-but-undelivered episode is RETRIED, not counted as escalated", () => {
-		const sustained = agg("guard.fail.open", 40, 720, 0);
-		const claim = episode({ kind: "guard.fail.open", escalatedAt: null, workItemId: null });
-		const decision = decideSweep([sustained], [claim], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(1);
-		expect(decision.escalate[0]!.episode).toBe(claim);
-	});
-});
-
-describe("decideSweep — resolution + re-arm", () => {
-	// QUIET RE-ARMS, IT DOES NOT RESOLVE. These two asserted `resolve` until
-	// 2026-08-29, which is the unsound close: only a probe can say a condition
-	// ended, and no probe is declared for these kinds.
-	test("quiet past the resolve window RE-ARMS the episode, and claims nothing", () => {
-		const gone = episode({ kind: "wake.failed", lastSeenAt: new Date(NOW.getTime() - 60 * 60_000) });
-		const decision = decideSweep([], [gone], POLICY, NOW);
-		expect(decision.rearm).toHaveLength(1);
-		expect(decision.rearm[0]!.quietMinutes).toBeGreaterThanOrEqual(30);
-		expect(decision.resolve).toHaveLength(0);
-	});
-
-	test("an absent kind re-arms by its episode's last_seen, not the sweep clock", () => {
-		const gone = episode({ kind: "listen.connect_failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) });
-		const decision = decideSweep([], [gone], POLICY, NOW);
-		expect(decision.rearm).toHaveLength(1);
-		expect(decision.resolve).toHaveLength(0);
-	});
-
-	// THE INVARIANT THAT MAKES RE-ARMING SAFE. If a re-armed episode did not
-	// escalate again, dropping the quiet-close would have left every
-	// probe-less alarm permanently silent — worse than the false close.
-	test("a RE-ARMED episode escalates again when its fault recurs", () => {
-		const recurring = agg("guard.fail.open", 50, 40, 0);
-		const rearmed = episode({
-			kind: "guard.fail.open",
-			rearmedAt: new Date(NOW.getTime() - 35 * 60_000),
-		});
-		const decision = decideSweep([recurring], [rearmed], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(1);
-	});
-
-	// A re-armed episode is already armed; re-arming it every sweep would emit
-	// a transition per sweep, which is the repeating-condition shape itself.
-	test("an already re-armed episode is not re-armed again while it stays quiet", () => {
-		const rearmed = episode({
-			kind: "guard.fail.open",
-			lastSeenAt: new Date(NOW.getTime() - 60 * 60_000),
-			rearmedAt: new Date(NOW.getTime() - 35 * 60_000),
-		});
-		const decision = decideSweep([], [rearmed], POLICY, NOW);
-		expect(decision.rearm).toHaveLength(0);
-		expect(decision.resolve).toHaveLength(0);
-	});
-
-	// A kind WITH a probe keeps the stronger path: it is never re-armed on
-	// quiet, because something can actually be asked about it.
-	test("a kind declaring a capability probe goes to the probe gate, never to re-arm", () => {
-		const gone = episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 60 * 60_000) });
-		const decision = decideSweep([], [gone], POLICY, NOW, {}, undefined, {
-			"llm.provider.call.failed": { url: "http://127.0.0.1:9/health" },
-		});
-		expect(decision.resolveProbeGate).toHaveLength(1);
-		expect(decision.rearm).toHaveLength(0);
-		expect(decision.resolve).toHaveLength(0);
-	});
-
-	test("after resolution the same fault escalates again (new episode)", () => {
-		const recurring = agg("host-command-bus.command.failed", 50, 40, 0);
-		const resolved = episode({
-			kind: "host-command-bus.command.failed",
-			resolvedAt: new Date(NOW.getTime() - 35 * 60_000),
-		});
-		const decision = decideSweep([recurring], [resolved], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(1);
-	});
-
-	test("still-active kind within the resolve window is not resolved even if below threshold", () => {
-		const active = agg("slow.error", 3, 20, 0); // below threshold, but recent
-		const open = episode({ kind: "slow.error", lastSeenAt: active.lastSeen });
-		const decision = decideSweep([active], [open], POLICY, NOW);
-		expect(decision.resolve).toHaveLength(0);
-		expect(decision.rearm).toHaveLength(0);
-	});
-});
-
-describe("decideSweep — a future-dated lastSeen is not recurrence evidence", () => {
-	// 2026-08-26: an escalation sent 08:20Z cited "last at 09:04:54Z" — 44
-	// minutes in its own future. The rows existed (producer envelopes whose
-	// clock ran 70 minutes ahead), and `minutesBetween(lastSeen, now)` went
-	// negative, passing every recency check while the kind was actually quiet.
-	// A timestamp that has not happened yet cannot evidence a fault happening
-	// now — no matter how the aggregate was built.
-	test("a future-dated aggregate does not escalate", () => {
-		const phantom = agg("guard.fail.open", 40, 720, -44);
-		const decision = decideSweep([phantom], [], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(0);
-	});
-
-	test("a future-dated aggregate does not hold an open episode open past the quiet window", () => {
-		// lastSeen 44 min in the future means the kind's real events are quiet:
-		// the episode's own last_seen_at (honest) drives the resolve decision,
-		// and the phantom aggregate must not veto it.
-		const quietEpisode = episode({
-			kind: "guard.fail.open",
-			lastSeenAt: new Date(NOW.getTime() - 60 * 60_000),
-		});
-		const phantom = agg("guard.fail.open", 40, 720, -44);
-		const decision = decideSweep([phantom], [quietEpisode], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(0);
-		// Re-armed rather than resolved: no probe is declared for this kind.
-		expect(decision.rearm).toHaveLength(1);
-		expect(decision.resolve).toHaveLength(0);
-	});
-});
-
-describe("extractWhatsAppMessageId — delivery verification", () => {
-	test("the messaging_whatsapp_send result shape yields message_id", () => {
-		expect(extractWhatsAppMessageId({ ok: true, message_id: "3EB089B9D6ADD58153C561" })).toBe(
-			"3EB089B9D6ADD58153C561",
-		);
-	});
-
-	test("a 'true' ack or an error body is NOT a message id — delivery stays unverified", () => {
-		// A boolean-ish ack string must never be recorded as a delivered id:
-		// that would mark the episode delivered with an unfollowable handle.
-		expect(extractWhatsAppMessageId({ ok: true })).toBeNull();
-		expect(extractWhatsAppMessageId({ ok: false, error: "no device" })).toBeNull();
-		expect(extractWhatsAppMessageId("true")).toBeNull();
-		expect(extractWhatsAppMessageId(null)).toBeNull();
-	});
-});
-
-describe("composeEscalationMessage", () => {
-	test("carries the three escalation-routing fields and stays phone-sized", () => {
-		const message = composeEscalationMessage({
-			kind: "host-command-bus.command.failed",
-			aggregate: agg("host-command-bus.command.failed", 490, 720, 0),
-			impact: "scala-tools verbs are failing host-wide",
-			recommendation: "check oxmgr logs for the bus consumer",
-			sample: "",
-			lastEvent: null,
-		});
-		expect(message).toContain("Platform fault: host-command-bus.command.failed");
-		expect(message).toContain("Observed: 490 errors over 12 h");
-		expect(message).toContain("Impact: scala-tools verbs are failing host-wide");
-		expect(message).toContain("Recommendation: check oxmgr logs for the bus consumer");
-		expect(message.split("\n")).toHaveLength(4);
-	});
-
-	// 2026-08-26: an escalation sent 08:20Z cited "last at 09:04:54Z", a
-	// timestamp 44 minutes in its own future matching no event the operator
-	// could find. The Observed line now cites the newest backing row's own
-	// occurred_at and id, so "last at T" resolves to a real event_log row.
-	test("cites the newest backing row's timestamp and event id — resolvable evidence", () => {
-		const message = composeEscalationMessage({
-			kind: "guard.fail.open",
-			aggregate: agg("guard.fail.open", 490, 720, 0),
-			impact: "guard enforcement is failing open",
-			recommendation: "check the guard daemon",
-			sample: "",
-			lastEvent: { occurredAt: "2026-08-26T08:20:29Z", eventId: "01a03b79-c124-748f-a79f-a9a436729544" },
-		});
-		expect(message).toContain("last 2026-08-26T08:20:29Z (event 01a03b79)");
-	});
-
-	// 2026-08-26: three escalations reached the orchestrator seat carrying
-	// kind, count and duration only — triaging each required a hand event_log
-	// query, and the llm.provider.call.failed impact line pointed AWAY from
-	// the defect (payloads held our own 'Invalid length: Expected <=1200 but
-	// received 1255' contract violations recorded against healthy providers).
-	// The sample line carries the evidence in the first read.
-	test("carries the sampled payload evidence as its own line", () => {
-		const message = composeEscalationMessage({
-			kind: "llm.provider.call.failed",
-			aggregate: agg("llm.provider.call.failed", 26, 560, 0),
-			sample: 'status=429; message=Usage limit reached for 5 hour. Your limit will reset at 2026-08-26 01:19:03',
-			impact: "AI chat/completion calls are failing",
-			recommendation: "check provider quota",
-			lastEvent: null,
-		});
-		const lines = message.split("\n");
-		expect(lines).toHaveLength(5);
-		expect(lines[2]).toContain("Sample: status=429");
-		expect(lines[2]).toContain("reset at 2026-08-26 01:19:03");
-	});
-});
-
-describe("formatEscalationSample — evidence truncated hard, secrets never shipped", () => {
-	test("non-string values are JSON-encoded so structure survives the phone channel", () => {
-		expect(formatEscalationSample(429)).toBe("429");
-		expect(formatEscalationSample(true)).toBe("true");
-		expect(formatEscalationSample({ expected: 1200, received: 1255 })).toBe('{"expected":1200,"received":1255}');
-	});
-
-	test("truncates hard at the bound with an ellipsis so the reader knows the cut happened", () => {
-		const formatted = formatEscalationSample("x".repeat(500));
-		expect(formatted.length).toBe(201); // 200 chars + ellipsis
-		expect(formatted.endsWith("…")).toBe(true);
-	});
-
-	test("redacts credential shapes before truncation — a cut can never expose a secret tail", () => {
-		expect(formatEscalationSample("key sk-abcdefghijklmnopqrstuvwxyz failed")).toBe("key [redacted] failed");
-		expect(formatEscalationSample("Authorization: Bearer abcdefghijklmnop")).toBe(
-			"Authorization=[redacted]",
-		);
-		expect(formatEscalationSample("api_key=abcdefgh1234 rejected")).toBe("api_key=[redacted] rejected");
-	});
-
-	test("collapses whitespace to one line — the sample is one message line", () => {
-		expect(formatEscalationSample("line one\nline two\t tabbed")).toBe("line one line two tabbed");
-	});
-
-	test("empty input yields an empty sample (no Sample line)", () => {
-		expect(formatEscalationSample(undefined)).toBe("");
-		expect(formatEscalationSample("")).toBe("");
-	});
-});
-
-describe("decideSweep — qualification asks 'is this happening', not 'did this happen'", () => {
-	// 2026-08-26: llm.provider.call.failed re-escalated every ~10 minutes with
-	// lastSeen frozen at 16:54 — escalated 19:40 on a fault three hours dead,
-	// resolved 19:45, repeat. The tell was the closure counter climbing
-	// (141/151/171 min): quiet measured from one frozen aggregate lastSeen.
-	// isSustained checked count and span but never recency, so a dead fault
-	// kept qualifying for the rest of the 720-minute lookback while a resolved
-	// episode read as "no episode" and re-escalated it.
-	const resolved = (kind: string) =>
-		episode({ kind, resolvedAt: new Date(NOW.getTime() - 5 * 60_000) });
-
-	test("a fault quiet past the resolve window does not re-escalate after resolution", () => {
-		const decision = decideSweep(
-			[agg("stale.error", 30, 400, 170)],
-			[resolved("stale.error")],
-			POLICY,
-			NOW,
-		);
-		expect(decision.escalate).toHaveLength(0);
-	});
-
-	test("a fault quiet past the resolve window does not escalate with no episode at all", () => {
-		const decision = decideSweep([agg("stale.error", 30, 400, 170)], [], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(0);
-	});
-
-	// The other direction, and the one that protects live escalations: the fix
-	// must not silence a fault that is still emitting.
-	test("a fault still emitting escalates", () => {
-		const decision = decideSweep([agg("live.error", 30, 400, 2)], [], POLICY, NOW);
-		expect(decision.escalate).toHaveLength(1);
-	});
-
-	test("a recurring fault opens a NEW episode after its previous one resolved", () => {
-		const decision = decideSweep(
-			[agg("live.error", 30, 400, 2)],
-			[resolved("live.error")],
-			POLICY,
-			NOW,
-		);
-		expect(decision.escalate).toHaveLength(1);
-	});
-});
-
-describe("decideSweep — zero-volume gate (quiet vs dead producer)", () => {
-	const SOURCES = {
-		"llm.provider.call.failed": { volume_kind_pattern: "^llm\.router\.routing_decision$", min_volume: 1 },
-	};
-	const VOLUME_BACKED = { sources: SOURCES, countByKind: {}, flagActiveByKind: {} };
-
-	test("an open episode with NO volume does not resolve — it holds", () => {
-		const episodes = [episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
-		const inputs = { ...VOLUME_BACKED, countByKind: { "llm.provider.call.failed": 0 } };
-		const decision = decideSweep([], episodes, POLICY, NOW, {}, inputs);
-		expect(decision.resolve).toHaveLength(0);
-		expect(decision.zeroVolumeHold).toHaveLength(1);
-		expect(decision.zeroVolumeHold[0].volumeCount).toBe(0);
-	});
-
-	test("quiet WITH healthy call volume re-arms (the normal path for a probe-less kind)", () => {
-		const episodes = [episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
-		const inputs = { ...VOLUME_BACKED, countByKind: { "llm.provider.call.failed": 120 } };
-		const decision = decideSweep([], episodes, POLICY, NOW, {}, inputs);
-		expect(decision.zeroVolumeHold).toHaveLength(0);
-		expect(decision.rearm).toHaveLength(1);
-		expect(decision.resolve).toHaveLength(0);
-		expect(decision.rearm[0]!.clearZeroVolumeFlag).toBe(false);
-	});
-
-	test("a sourceless kind re-arms on quiet", () => {
-		const episodes = [episode({ kind: "guard.fail.open", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
-		const decision = decideSweep([], episodes, POLICY, NOW, {}, { ...VOLUME_BACKED, countByKind: {} });
-		expect(decision.rearm).toHaveLength(1);
-		expect(decision.resolve).toHaveLength(0);
-		expect(decision.zeroVolumeHold).toHaveLength(0);
-	});
-
-	test("recovery from a flagged hold clears the flag on resolve", () => {
-		const episodes = [episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
-		const inputs = {
-			...VOLUME_BACKED,
-			countByKind: { "llm.provider.call.failed": 50 },
-			flagActiveByKind: { "llm.provider.call.failed": true },
-		};
-		const decision = decideSweep([], episodes, POLICY, NOW, {}, inputs);
-		expect(decision.rearm[0]!.clearZeroVolumeFlag).toBe(true);
-	});
-
-	test("without a sixth argument the legacy shape is untouched", () => {
-		const episodes = [episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
-		const decision = decideSweep([], episodes, POLICY, NOW);
-		expect(decision.rearm).toHaveLength(1);
-		expect(decision.resolve).toHaveLength(0);
-	});
-});
-
-describe("composeZeroVolumeMessage — the quiet-is-not-healthy notice", () => {
-	test("names the held kind, both absences and the floors; stays phone-sized", () => {
-		const message = composeZeroVolumeMessage({
-			kind: "llm.provider.call.failed",
-			volumeKindPattern: "^llm\.router\.routing_decision$",
-			minVolume: 1,
-			quietMinutes: 600,
-			volumeCount: 0,
-			firstSeenAt: new Date(NOW.getTime() - 700 * 60_000),
-		});
-		for (const fragment of ["llm.provider.call.failed", "routing_decision", "(0 < floor 1", "Recommendation:"]) {
-			expect(message).toContain(fragment);
-		}
-		expect(message.split("\n").length).toBeLessThanOrEqual(4);
-	});
-});
-
-describe("decideSweep — probe-gated resolution (operator ruling 2026-08-28)", () => {
-	const PROBE_SOURCES = {
-		"llm.provider.call.failed": { url: "https://ai.scala.business/health", timeout_seconds: 5 },
-	};
-
-	test("a kind with a declared probe is gated, not resolved on quiet", () => {
-		const gone = episode({
-			kind: "llm.provider.call.failed",
-			lastSeenAt: new Date(NOW.getTime() - 60 * 60_000),
-		});
-		const decision = decideSweep([agg("llm.provider.call.failed", 10, 700, 60)], [gone], POLICY, NOW, {}, undefined, PROBE_SOURCES);
-		expect(decision.resolve).toHaveLength(0);
-		expect(decision.resolveProbeGate).toHaveLength(1);
-		expect(decision.resolveProbeGate[0]!.probeUrl).toBe("https://ai.scala.business/health");
-		expect(decision.resolveProbeGate[0]!.quietMinutes).toBeGreaterThanOrEqual(30);
-	});
-
-	test("a kind without a declared probe RE-ARMS on quiet — it is never closed unverified", () => {
-		const gone = episode({ kind: "wake.failed", lastSeenAt: new Date(NOW.getTime() - 60 * 60_000) });
-		const decision = decideSweep([agg("wake.failed", 10, 700, 60)], [gone], POLICY, NOW, {}, undefined, PROBE_SOURCES);
-		expect(decision.rearm).toHaveLength(1);
-		expect(decision.resolve).toHaveLength(0);
-		expect(decision.resolveProbeGate).toHaveLength(0);
-	});
-
-	test("the gate passes through the zero-volume flag so a healthy probe clears it", () => {
-		const gone = episode({
-			kind: "llm.provider.call.failed",
-			lastSeenAt: new Date(NOW.getTime() - 60 * 60_000),
-		});
-		const zeroVolume = {
-			sources: { "llm.provider.call.failed": { volume_kind_pattern: "^llm\.router\.routing_decision$", min_volume: 1 } },
-			countByKind: { "llm.provider.call.failed": 12 },
-			flagActiveByKind: { "llm.provider.call.failed": true },
-		};
-		const decision = decideSweep([agg("llm.provider.call.failed", 10, 700, 60)], [gone], POLICY, NOW, {}, zeroVolume, PROBE_SOURCES);
-		expect(decision.resolveProbeGate).toHaveLength(1);
-		expect(decision.resolveProbeGate[0]!.clearZeroVolumeFlag).toBe(true);
-	});
-});