@teamscala/service-boot 0.23.405 → 0.23.406

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "@teamscala/service-boot",
   "type": "module",
-  "version": "0.23.405",
+  "version": "0.23.406",
   "sideEffects": false,
   "imports": {
     "#service-boot/*": "./src/*",

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

@@ -79,12 +79,19 @@ function isSustained(
 	aggregate: FaultAggregate,
 	policy: FaultEscalationPolicy,
 	override: KindThresholdOverride | undefined,
+	now: Date,
 ): boolean {
 	const minCount = override?.minCount ?? policy.minCount;
 	const minSpan = override?.minSpanMinutes ?? policy.minSpanMinutes;
+	// Recency, not merely presence in the lookback window. Count and span
+	// answer "did this happen"; a fault qualifies only while it is STILL
+	// happening. Without this the 720-minute lookback keeps a dead fault
+	// qualifying for hours, and since a resolved episode reads as no episode
+	// it re-escalates on every sweep until its events age out (2026-08-26).
 	return (
 		aggregate.count >= minCount &&
-		minutesBetween(aggregate.firstSeen, aggregate.lastSeen) >= minSpan
+		minutesBetween(aggregate.firstSeen, aggregate.lastSeen) >= minSpan &&
+		minutesBetween(aggregate.lastSeen, now) < policy.resolveAfterMinutes
 	);
 }
 
@@ -107,7 +114,7 @@ export function decideSweep(
 
 	for (const aggregate of aggregates) {
 		const episode = byKind.get(aggregate.kind);
-		if (!isSustained(aggregate, policy, kindThresholds[aggregate.kind])) continue;
+		if (!isSustained(aggregate, policy, kindThresholds[aggregate.kind], now)) continue;
 		// No episode, or the previous episode closed (quiet past resolve window):
 		// a NEW episode begins and must be delivered.
 		if (!episode || episode.resolvedAt) {

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

@@ -202,3 +202,47 @@ describe("composeEscalationMessage", () => {
 		expect(message.split("\n")).toHaveLength(4);
 	});
 });
+
+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);
+	});
+});