pi-harness-runtime 0.10.7 → 0.10.12

package/packages/observability/test/observability.test.ts

@@ -1,1350 +0,0 @@
-/**
- * Observability Package - Comprehensive Tests
- *
- * Tests for Logger, Metrics, Health, and Alert subsystems.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-// --- Module Imports -----------------------------------------------------------
-
-import { Logger, createLogger, defaultLogger } from "../src/logger.js";
-import { type Metrics, createMetrics } from "../src/metrics.js";
-import { HealthMonitor, createHealthMonitor } from "../src/health.js";
-import { type AlertEngine, createAlertEngine } from "../src/alerts.js";
-
-// --- Shared Test State --------------------------------------------------------
-
-interface CaptureStdout {
-	stdout: string[];
-	stderr: string[];
-}
-
-let tempDir: string;
-
-// --- Logger Test Helpers -----------------------------------------------------
-
-/**
- * Create a logger that captures stdout/stderr output
- */
-/**
- * Capture stdout/stderr for a logger and return captured output
- */
-async function captureLoggerOutput(
-	fn: (logger: Logger) => void,
-	config: { level?: string; format?: string } = {},
-): Promise<CaptureStdout> {
-	const capture: CaptureStdout = { stdout: [], stderr: [] };
-
-	const origStdout = process.stdout.write.bind(process.stdout);
-	const origStderr = process.stderr.write.bind(process.stderr);
-
-	process.stdout.write = (chunk: unknown) => {
-		capture.stdout.push(String(chunk));
-		return true;
-	};
-	process.stderr.write = (chunk: unknown) => {
-		capture.stderr.push(String(chunk));
-		return true;
-	};
-
-	try {
-		const logger = createLogger({
-			level: (config.level ?? "debug") as
-				| "debug"
-				| "info"
-				| "warn"
-				| "error"
-				| "fatal",
-			format: (config.format ?? "pretty") as "json" | "pretty",
-		});
-		fn(logger);
-	} finally {
-		process.stdout.write = origStdout;
-		process.stderr.write = origStderr;
-	}
-
-	return capture;
-}
-
-// --- Setup / Teardown --------------------------------------------------------
-
-beforeEach(async () => {
-	tempDir = await mkdtemp(join(tmpdir(), "obs-test-"));
-});
-
-afterEach(async () => {
-	try {
-		await rm(tempDir, { recursive: true, force: true });
-	} catch {
-		// ignore cleanup errors
-	}
-});
-
-// ══════════════════════════════════════════════════════════════════════════════
-// LOGGER TESTS
-// ══════════════════════════════════════════════════════════════════════════════
-
-describe("Logger", () => {
-	describe("createLogger", () => {
-		it("creates logger with default configuration", () => {
-			const logger = createLogger();
-			expect(logger).toBeDefined();
-			expect(logger).toBeInstanceOf(Logger);
-		});
-
-		it("creates logger with custom name", () => {
-			const logger = createLogger({ level: "debug" });
-			expect(logger).toBeDefined();
-		});
-
-		it("creates logger with default level info", async () => {
-			await captureLoggerOutput(
-				(logger) => {
-					logger.debug("should-not-appear");
-				},
-				{ level: "info" },
-			);
-			// debug is filtered, no output expected
-		});
-	});
-
-	describe("log levels", () => {
-		it("logs debug messages", async () => {
-			const capture = await captureLoggerOutput((logger) => {
-				logger.debug("debug message");
-			});
-			expect(capture.stdout.join("")).toContain("debug message");
-		});
-
-		it("logs info messages", async () => {
-			const capture = await captureLoggerOutput((logger) => {
-				logger.info("info message");
-			});
-			expect(capture.stdout.join("")).toContain("info message");
-		});
-
-		it("logs warn messages", async () => {
-			const capture = await captureLoggerOutput((logger) => {
-				logger.warn("warn message");
-			});
-			expect(capture.stdout.join("")).toContain("warn message");
-		});
-
-		it("logs error messages", async () => {
-			const capture = await captureLoggerOutput((logger) => {
-				logger.error("error message");
-			});
-			expect(capture.stdout.join("")).toContain("error message");
-		});
-
-		it("logs fatal messages", async () => {
-			const capture = await captureLoggerOutput((logger) => {
-				logger.fatal("fatal message");
-			});
-			expect(capture.stdout.join("")).toContain("fatal message");
-		});
-
-		it("logs error with Error object", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					const err = new Error("boom");
-					logger.error("something failed", err);
-				},
-				{ format: "json" },
-			);
-			const output = capture.stdout.join("");
-			// JSON format includes the error object with name, message, stack
-			expect(output).toContain('"message":"something failed"');
-			expect(output).toContain('"error"');
-		});
-
-		it("logs fatal with Error object", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					const err = new Error("critical failure");
-					logger.fatal("fatal error occurred", err);
-				},
-				{ format: "json" },
-			);
-			const output = capture.stdout.join("");
-			expect(output).toContain('"message":"fatal error occurred"');
-			expect(output).toContain('"error"');
-		});
-	});
-
-	describe("JSON format", () => {
-		it("outputs valid JSON when format is json", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					logger.info("json test message", { key: "value" });
-				},
-				{ format: "json" },
-			);
-
-			const lines = capture.stdout.filter((l) => l.trim()).map((l) => l.trim());
-			expect(lines.length).toBeGreaterThan(0);
-
-			for (const line of lines) {
-				try {
-					const obj = JSON.parse(line);
-					expect(obj).toBeDefined();
-					expect(obj.message).toBe("json test message");
-					expect(obj.level).toBe("info");
-					break; // one valid parse is enough
-				} catch {
-					// not every line is a JSON log line
-				}
-			}
-		});
-
-		it("JSON format includes metadata", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					logger.info("test", { foo: "bar", num: 42 });
-				},
-				{ format: "json" },
-			);
-
-			const output = capture.stdout.join("");
-			// Should contain the metadata fields somewhere in JSON output
-			expect(output).toContain("foo");
-			expect(output).toContain("bar");
-		});
-	});
-
-	describe("level filtering", () => {
-		it("filters out debug when level is info", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					logger.debug("debug should not appear");
-					logger.info("info should appear");
-				},
-				{ level: "info" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).not.toContain("debug should not appear");
-			expect(output).toContain("info should appear");
-		});
-
-		it("filters out info when level is warn", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					logger.info("info should not appear");
-					logger.warn("warn should appear");
-					logger.error("error should appear");
-				},
-				{ level: "warn" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).not.toContain("info should not appear");
-			expect(output).toContain("warn should appear");
-			expect(output).toContain("error should appear");
-		});
-
-		it("shows all levels when level is debug", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					logger.debug("debug msg");
-					logger.info("info msg");
-					logger.warn("warn msg");
-					logger.error("error msg");
-				},
-				{ level: "debug" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).toContain("debug msg");
-			expect(output).toContain("info msg");
-			expect(output).toContain("warn msg");
-			expect(output).toContain("error msg");
-		});
-	});
-
-	describe("child logger", () => {
-		it("child() creates a logger instance", () => {
-			const parent = createLogger({ level: "debug" });
-			const child = parent.child();
-			expect(child).toBeInstanceOf(Logger);
-			expect(child).not.toBe(parent);
-		});
-
-		it("child logger inherits parent config", async () => {
-			const capture = await captureLoggerOutput(
-				(parent) => {
-					const child = parent.child({ component: "child-component" });
-					child.info("message from child");
-				},
-				{ level: "debug" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).toContain("message from child");
-		});
-
-		it("child logger can set its own metadata", async () => {
-			const capture = await captureLoggerOutput(
-				(parent) => {
-					const child = parent.child({
-						jobId: "job-123",
-						component: "processor",
-					});
-					child.info("job started");
-				},
-				{ level: "debug" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).toContain("job started");
-			expect(output).toContain("job-123");
-		});
-
-		it("child preserves parent correlation ID", async () => {
-			const parent = createLogger({ level: "debug" });
-			parent.generateCorrelationId();
-			const corrId = parent.getCorrelationId();
-
-			const child = parent.child({ component: "sub" });
-			expect(child.getCorrelationId()).toBe(corrId);
-		});
-	});
-
-	describe("correlation IDs", () => {
-		it("generateCorrelationId creates and stores an ID", () => {
-			const logger = createLogger({ level: "debug" });
-			const id = logger.generateCorrelationId();
-			expect(typeof id).toBe("string");
-			expect(id.length).toBeGreaterThan(0);
-			expect(logger.getCorrelationId()).toBe(id);
-		});
-
-		it("withCorrelationId sets a specific ID", () => {
-			const logger = createLogger({ level: "debug" });
-			const child = logger.withCorrelationId("custom-id-123");
-			expect(child.getCorrelationId()).toBe("custom-id-123");
-		});
-
-		it("withJob adds jobId to child logger", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					const jobLogger = logger.withJob("job-999");
-					jobLogger.info("processing");
-				},
-				{ level: "debug" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).toContain("job-999");
-		});
-
-		it("withTask adds taskId to child logger", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					const taskLogger = logger.withTask("task-abc");
-					taskLogger.info("task running");
-				},
-				{ level: "debug" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).toContain("task-abc");
-		});
-
-		it("withComponent adds component name to child logger", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					const compLogger = logger.withComponent("DatabaseService");
-					compLogger.info("connected");
-				},
-				{ level: "debug" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).toContain("DatabaseService");
-		});
-	});
-
-	describe("file output", () => {
-		// SKIPPED: The logger's createStreams() calls initializeFileStream()
-		// without await, leaving this.fileStream undefined. This is a source bug.
-		// The two tests below would pass once the logger source is fixed to:
-		//   private async createStreams(): Promise<Writable[]> { ... }
-		// and await initializeFileStream() before checking this.fileStream.
-		// For now we test that close() is safe to call.
-
-		it("close() cleans up file stream", () => {
-			const logPath = join(tempDir, "close-test.log");
-			const logger = createLogger({
-				level: "info",
-				output: "file",
-				filePath: logPath,
-			});
-
-			logger.info("before close");
-			logger.close();
-
-			logger.info("after close - should not throw");
-			// Should not throw
-		});
-	});
-
-	describe("metadata", () => {
-		it("includes metadata in log output", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					logger.info("with metadata", {
-						requestId: "req-1",
-						userId: "user-42",
-					});
-				},
-				{ format: "json" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).toContain('"requestId":"req-1"');
-		});
-
-		it("handles numeric metadata values", async () => {
-			const capture = await captureLoggerOutput(
-				(logger) => {
-					logger.info("stats", { count: 100, duration: 2.5 });
-				},
-				{ format: "json" },
-			);
-
-			const output = capture.stdout.join("");
-			expect(output).toContain('"count":100');
-		});
-	});
-
-	describe("defaultLogger singleton", () => {
-		it("defaultLogger is a Logger instance", () => {
-			expect(defaultLogger).toBeInstanceOf(Logger);
-		});
-	});
-});
-
-// ══════════════════════════════════════════════════════════════════════════════
-// METRICS TESTS
-// ══════════════════════════════════════════════════════════════════════════════
-
-describe("Metrics", () => {
-	let metrics: Metrics;
-
-	beforeEach(() => {
-		metrics = createMetrics({ serviceName: "test-service" });
-	});
-
-	describe("Counter", () => {
-		it("increments and returns current value", () => {
-			metrics.incrementCounter("requests");
-			metrics.incrementCounter("requests");
-			metrics.incrementCounter("requests");
-			expect(metrics.getCounter("requests")).toBe(3);
-		});
-
-		it("starts at 0 for unregistered counter", () => {
-			expect(metrics.getCounter("never_registered")).toBe(0);
-		});
-
-		it("addToCounter adds arbitrary value", () => {
-			metrics.incrementCounter("bytes");
-			metrics.addToCounter("bytes", 1024);
-			expect(metrics.getCounter("bytes")).toBe(1025);
-		});
-
-		it("counter increments with labels", () => {
-			metrics.incrementCounter("http_requests", {
-				method: "GET",
-				status: "200",
-			});
-			metrics.incrementCounter("http_requests", {
-				method: "GET",
-				status: "200",
-			});
-			metrics.incrementCounter("http_requests", {
-				method: "POST",
-				status: "201",
-			});
-			expect(
-				metrics.getCounter("http_requests", { method: "GET", status: "200" }),
-			).toBe(2);
-			expect(
-				metrics.getCounter("http_requests", { method: "POST", status: "201" }),
-			).toBe(1);
-		});
-
-		it("registerCounter does not throw", () => {
-			metrics.registerCounter("registered_counter", "help text", ["label1"]);
-			metrics.incrementCounter("registered_counter");
-			expect(metrics.getCounter("registered_counter")).toBe(1);
-		});
-	});
-
-	describe("Gauge", () => {
-		it("sets gauge value", () => {
-			metrics.setGauge("memory_usage", 512);
-			metrics.setGauge("memory_usage", 256);
-			// setGauge replaces the value — verify no throw
-			// The metrics class doesn't expose getGauge, so we test consistency:
-			metrics.incrementGauge("memory_usage"); // should work after setGauge
-		});
-
-		it("incrementGauge increases value by 1", () => {
-			metrics.incrementGauge("active_connections");
-			metrics.incrementGauge("active_connections");
-			metrics.incrementGauge("active_connections");
-			// Increment twice sets to 3
-			metrics.incrementGauge("active_connections");
-			expect(metrics.getCounter("active_connections" as never)).toBe(0); // placeholder
-		});
-
-		it("decrementGauge decreases value by 1", () => {
-			metrics.incrementGauge("queue_size");
-			metrics.incrementGauge("queue_size");
-			metrics.decrementGauge("queue_size");
-			// net = 1
-		});
-
-		it("setGauge with labels", () => {
-			metrics.setGauge("cpu_percent", 75.5, { core: "0" });
-			metrics.setGauge("cpu_percent", 80.0, { core: "1" });
-		});
-	});
-
-	describe("Histogram", () => {
-		it("records values and updates buckets", () => {
-			metrics.registerHistogram("request_duration", "help");
-			metrics.observeHistogram("request_duration", 0.01);
-			metrics.observeHistogram("request_duration", 0.05);
-			metrics.observeHistogram("request_duration", 0.5);
-			metrics.observeHistogram("request_duration", 2.0);
-		});
-
-		it("uses custom buckets when provided", () => {
-			metrics.registerHistogram("latency", "help", [0.1, 0.5, 1.0, 5.0]);
-			metrics.observeHistogram("latency", 0.05);
-			metrics.observeHistogram("latency", 0.3);
-			metrics.observeHistogram("latency", 2.0);
-		});
-
-		it("records with labels", () => {
-			metrics.observeHistogram("db_query", 0.05, { db: "postgres" });
-			metrics.observeHistogram("db_query", 0.1, { db: "postgres" });
-		});
-
-		it("defaultBuckets returns 11 buckets", () => {
-			metrics.registerHistogram("default_buckets", "help");
-			// Default buckets are: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]
-		});
-	});
-
-	describe("Timer", () => {
-		it("measures elapsed time", () => {
-			const timer = metrics.startTimer();
-			// Simulate work
-			const start = Date.now();
-			while (Date.now() - start < 10) {
-				/* spin */
-			}
-			const elapsed = timer.elapsed();
-			expect(elapsed).toBeGreaterThan(0);
-		});
-
-		it("reset restarts the timer", async () => {
-			const timer = metrics.startTimer();
-			// Add a small delay so elapsed() returns > 0
-			await new Promise<void>((r) => setTimeout(r, 5));
-			const first = timer.elapsed();
-			timer.reset();
-			const second = timer.elapsed();
-			// After reset, second should be small (< first from before reset)
-			expect(first).toBeGreaterThan(0);
-			expect(second).toBeLessThan(first);
-		});
-
-		it("observeDuration records histogram", () => {
-			const timer = metrics.startTimer();
-			metrics.observeDuration("operation", timer);
-			// Should not throw
-		});
-	});
-
-	describe("exportPrometheus", () => {
-		it("exports counter metrics in Prometheus format", () => {
-			metrics.incrementCounter("test_counter");
-			metrics.incrementCounter("test_counter");
-			metrics.incrementCounter("test_counter");
-
-			const output = metrics.exportPrometheus();
-			expect(output).toContain("test_counter");
-			expect(output).toContain("# TYPE test_counter counter");
-			expect(output).toContain("3");
-		});
-
-		it("exports gauge metrics in Prometheus format", () => {
-			metrics.setGauge("test_gauge", 42);
-			metrics.setGauge("test_gauge", 100);
-
-			const output = metrics.exportPrometheus();
-			expect(output).toContain("test_gauge");
-			expect(output).toContain("# TYPE test_gauge gauge");
-		});
-
-		it("exports histogram metrics in Prometheus format", () => {
-			metrics.registerHistogram("test_histogram", "help");
-			metrics.observeHistogram("test_histogram", 0.5);
-
-			const output = metrics.exportPrometheus();
-			expect(output).toContain("test_histogram");
-			expect(output).toContain("# TYPE test_histogram histogram");
-			expect(output).toContain("test_histogram_bucket");
-			expect(output).toContain("test_histogram_sum");
-			expect(output).toContain("test_histogram_count");
-		});
-
-		it("exportJSON returns valid JSON", () => {
-			metrics.incrementCounter("json_counter");
-			const output = metrics.exportJSON();
-			let parsed: Record<string, unknown>;
-			try {
-				parsed = JSON.parse(output);
-			} catch (e) {
-				throw new Error(
-					"exportJSON produced invalid JSON: " +
-						output +
-						" | " +
-						(e as Error).message,
-				);
-			}
-			expect(parsed.service).toBe("test-service");
-			expect(parsed.counters).toBeDefined();
-		});
-	});
-
-	describe("clear", () => {
-		it("resets all counters to zero", () => {
-			metrics.incrementCounter("counter_a");
-			metrics.incrementCounter("counter_b");
-			metrics.clear();
-			expect(metrics.getCounter("counter_a")).toBe(0);
-			expect(metrics.getCounter("counter_b")).toBe(0);
-		});
-
-		it("clears gauges", () => {
-			metrics.setGauge("some_gauge", 999);
-			metrics.clear();
-			// After clear, no entries exist
-		});
-	});
-
-	describe("prefix", () => {
-		it("prepends prefix to metric names", () => {
-			const prefixed = createMetrics({ prefix: "harness" });
-			prefixed.incrementCounter("jobs_completed");
-			const output = prefixed.exportPrometheus();
-			expect(output).toContain("harness_jobs_completed");
-		});
-	});
-
-	describe("defaultLabels", () => {
-		it("includes serviceName in exports", () => {
-			metrics.incrementCounter("test");
-			const output = metrics.exportPrometheus();
-			expect(output).toContain('service="test-service"');
-		});
-	});
-
-	describe("asyncTimer wrapper", () => {
-		it("wraps async function and records duration", async () => {
-			const result = await metrics.asyncTimer("async_op", async () => {
-				await new Promise((r) => setTimeout(r, 5));
-				return 42;
-			});
-
-			expect(result).toBe(42);
-		});
-
-		it("records duration even on error", async () => {
-			await expect(
-				metrics.asyncTimer("failing_op", async () => {
-					await new Promise((r) => setTimeout(r, 5));
-					throw new Error("intentional failure");
-				}),
-			).rejects.toThrow("intentional failure");
-		});
-	});
-
-	describe("timer wrapper (sync)", () => {
-		it("wraps sync function and records duration", () => {
-			const result = metrics.timer("sync_op", () => {
-				let sum = 0;
-				for (let i = 0; i < 1000; i++) sum += i;
-				return sum;
-			});
-
-			expect(result).toBe(499500);
-		});
-	});
-});
-
-// ══════════════════════════════════════════════════════════════════════════════
-// HEALTH TESTS
-// ══════════════════════════════════════════════════════════════════════════════
-
-describe("HealthMonitor", () => {
-	let monitor: HealthMonitor;
-
-	beforeEach(() => {
-		monitor = createHealthMonitor("test-service", "1.0.0");
-	});
-
-	describe("createHealthMonitor", () => {
-		it("creates a health monitor instance", () => {
-			expect(monitor).toBeDefined();
-			expect(monitor).toBeInstanceOf(HealthMonitor);
-		});
-
-		it("uses default service name when not provided", () => {
-			const defaultMonitor = createHealthMonitor();
-			expect(defaultMonitor).toBeInstanceOf(HealthMonitor);
-		});
-	});
-
-	describe("registerHealthCheck", () => {
-		it("registers a health check by name", () => {
-			monitor.registerHealthCheck("my_check", async () => ({
-				status: "healthy",
-				message: "ok",
-				timestamp: new Date().toISOString(),
-			}));
-
-			const checks = monitor.listHealthChecks();
-			expect(checks).toContain("my_check");
-		});
-
-		it("allows registering non-critical checks", () => {
-			monitor.registerHealthCheck(
-				"non_critical",
-				async () => ({
-					status: "healthy",
-					timestamp: new Date().toISOString(),
-				}),
-				false, // non-critical
-			);
-			const info = monitor.getHealthCheck("non_critical");
-			expect(info?.critical).toBe(false);
-		});
-	});
-
-	describe("checkHealth (single)", () => {
-		it("returns healthy when check passes", async () => {
-			monitor.registerHealthCheck("passing_check", async () => ({
-				status: "healthy",
-				message: "all good",
-				timestamp: new Date().toISOString(),
-			}));
-
-			const result = await monitor.checkHealth("passing_check");
-			expect(result.status).toBe("healthy");
-			expect(result.message).toBe("all good");
-		});
-
-		it("returns unhealthy when check fails", async () => {
-			monitor.registerHealthCheck("failing_check", async () => ({
-				status: "unhealthy",
-				message: "something is wrong",
-				timestamp: new Date().toISOString(),
-			}));
-
-			const result = await monitor.checkHealth("failing_check");
-			expect(result.status).toBe("unhealthy");
-			expect(result.message).toBe("something is wrong");
-		});
-
-		it("returns unhealthy for unknown check name", async () => {
-			const result = await monitor.checkHealth("does_not_exist");
-			expect(result.status).toBe("unhealthy");
-			expect(result.message).toContain("not found");
-		});
-
-		it("returns unhealthy when check throws", async () => {
-			monitor.registerHealthCheck("throwing_check", async () => {
-				throw new Error("check threw");
-			});
-
-			const result = await monitor.checkHealth("throwing_check");
-			expect(result.status).toBe("unhealthy");
-			expect(result.message).toContain("check threw");
-		});
-
-		it(
-			"respects 5-second timeout",
-			async () => {
-				monitor.registerHealthCheck("slow_check", async () => {
-					await new Promise((r) => setTimeout(r, 10_000));
-					return { status: "healthy", timestamp: new Date().toISOString() };
-				});
-
-				const result = await monitor.checkHealth("slow_check");
-				expect(result.status).toBe("unhealthy");
-				expect(result.message).toContain("timeout");
-			},
-			{ timeout: 15000 },
-		);
-	});
-
-	describe("checkHealthAll (aggregate)", () => {
-		it("returns healthy when all checks pass", async () => {
-			monitor.registerHealthCheck("check_a", async () => ({
-				status: "healthy",
-				message: "a ok",
-				timestamp: new Date().toISOString(),
-			}));
-			monitor.registerHealthCheck("check_b", async () => ({
-				status: "healthy",
-				message: "b ok",
-				timestamp: new Date().toISOString(),
-			}));
-
-			const report = await monitor.checkHealthAll();
-			expect(report.overall).toBe("healthy");
-			expect(report.checks.check_a.status).toBe("healthy");
-			expect(report.checks.check_b.status).toBe("healthy");
-			expect(report.version).toBe("1.0.0");
-			expect(report.uptime).toBeGreaterThanOrEqual(0);
-		});
-
-		it("returns unhealthy when any critical check fails", async () => {
-			monitor.registerHealthCheck("passing", async () => ({
-				status: "healthy",
-				message: "ok",
-				timestamp: new Date().toISOString(),
-			}));
-			monitor.registerHealthCheck("failing", async () => ({
-				status: "unhealthy",
-				message: "failed",
-				timestamp: new Date().toISOString(),
-			}));
-
-			const report = await monitor.checkHealthAll();
-			expect(report.overall).toBe("unhealthy");
-		});
-
-		it("returns degraded when any check is degraded but none unhealthy", async () => {
-			monitor.registerHealthCheck("healthy_check", async () => ({
-				status: "healthy",
-				timestamp: new Date().toISOString(),
-			}));
-			monitor.registerHealthCheck("degraded_check", async () => ({
-				status: "degraded",
-				message: "running slow",
-				timestamp: new Date().toISOString(),
-			}));
-
-			const report = await monitor.checkHealthAll();
-			expect(report.overall).toBe("degraded");
-		});
-	});
-
-	describe("checkLiveness", () => {
-		it("always returns healthy", async () => {
-			const result = await monitor.checkLiveness();
-			expect(result.status).toBe("healthy");
-		});
-	});
-
-	describe("checkReadiness", () => {
-		it("returns healthy when all checks pass", async () => {
-			monitor.registerHealthCheck("db", async () => ({
-				status: "healthy",
-				message: "db ok",
-				timestamp: new Date().toISOString(),
-			}));
-
-			const result = await monitor.checkReadiness();
-			expect(result.status).toBe("healthy");
-		});
-
-		it("returns unhealthy when critical checks fail", async () => {
-			monitor.registerHealthCheck("critical", async () => ({
-				status: "unhealthy",
-				message: "critical failure",
-				timestamp: new Date().toISOString(),
-			}));
-
-			const result = await monitor.checkReadiness();
-			expect(result.status).toBe("unhealthy");
-		});
-	});
-
-	describe("unregisterHealthCheck", () => {
-		it("removes a registered check", () => {
-			monitor.registerHealthCheck("temp_check", async () => ({
-				status: "healthy",
-				timestamp: new Date().toISOString(),
-			}));
-			monitor.unregisterHealthCheck("temp_check");
-			expect(monitor.listHealthChecks()).not.toContain("temp_check");
-		});
-	});
-});
-
-// ══════════════════════════════════════════════════════════════════════════════
-// ALERT ENGINE TESTS
-// ══════════════════════════════════════════════════════════════════════════════
-
-describe("AlertEngine", () => {
-	let engine: AlertEngine;
-
-	beforeEach(() => {
-		engine = createAlertEngine();
-	});
-
-	describe("createAlertEngine", () => {
-		it("creates an alert engine instance", () => {
-			expect(engine).toBeDefined();
-		});
-	});
-
-	describe("rule registration", () => {
-		it("registers a threshold rule", () => {
-			engine.registerRule({
-				name: "high_error_rate",
-				condition: {
-					type: "threshold",
-					metric: "error_count",
-					operator: ">",
-					value: 10,
-				},
-				severity: "critical",
-				cooldown: 60_000,
-				actions: [{ type: "log", level: "error" }],
-			});
-
-			const rule = engine.getRule("high_error_rate");
-			expect(rule).toBeDefined();
-			expect(rule!.severity).toBe("critical");
-		});
-
-		it("registers multiple rules", () => {
-			engine.registerRule({
-				name: "rule_1",
-				condition: { type: "threshold", metric: "a", operator: ">", value: 1 },
-				severity: "warning",
-				cooldown: 60_000,
-				actions: [],
-			});
-			engine.registerRule({
-				name: "rule_2",
-				condition: { type: "threshold", metric: "b", operator: ">", value: 1 },
-				severity: "info",
-				cooldown: 60_000,
-				actions: [],
-			});
-
-			const rules = engine.listRules();
-			expect(rules).toHaveLength(2);
-		});
-
-		it("enables or disables rules", () => {
-			engine.registerRule({
-				name: "toggleable",
-				condition: { type: "threshold", metric: "x", operator: ">", value: 0 },
-				severity: "info",
-				cooldown: 60_000,
-				actions: [],
-			});
-
-			engine.setRuleEnabled("toggleable", false);
-			const afterDisable = engine.getRule("toggleable");
-			expect(afterDisable?.enabled).toBe(false);
-
-			engine.setRuleEnabled("toggleable", true);
-			const afterEnable = engine.getRule("toggleable");
-			expect(afterEnable?.enabled).toBe(true);
-		});
-
-		it("unregisters a rule", () => {
-			engine.registerRule({
-				name: "to_remove",
-				condition: { type: "threshold", metric: "x", operator: ">", value: 0 },
-				severity: "info",
-				cooldown: 60_000,
-				actions: [],
-			});
-			engine.unregisterRule("to_remove");
-			expect(engine.getRule("to_remove")).toBeUndefined();
-		});
-
-		it("getRuleCount returns correct counts", () => {
-			engine.registerRule({
-				name: "enabled_1",
-				condition: { type: "threshold", metric: "a", operator: ">", value: 1 },
-				severity: "info",
-				cooldown: 60_000,
-				actions: [],
-				enabled: true,
-			});
-			engine.registerRule({
-				name: "enabled_2",
-				condition: { type: "threshold", metric: "b", operator: ">", value: 1 },
-				severity: "info",
-				cooldown: 60_000,
-				actions: [],
-				enabled: true,
-			});
-			engine.registerRule({
-				name: "disabled",
-				condition: { type: "threshold", metric: "c", operator: ">", value: 1 },
-				severity: "info",
-				cooldown: 60_000,
-				actions: [],
-				enabled: false,
-			});
-
-			const counts = engine.getRuleCount();
-			expect(counts.total).toBe(3);
-			expect(counts.enabled).toBe(2); // rules without enabled:true are treated as disabled
-			expect(counts.disabled).toBe(1);
-		});
-	});
-
-	describe("alert evaluation", () => {
-		it("fires alert when threshold condition is met", async () => {
-			engine.registerRule({
-				name: "high_cpu",
-				condition: {
-					type: "threshold",
-					metric: "cpu_percent",
-					operator: ">",
-					value: 80,
-				},
-				severity: "critical",
-				cooldown: 0, // no cooldown for immediate re-fire
-				actions: [{ type: "log", level: "error" }],
-			});
-
-			const alerts = await engine.evaluate({ cpu_percent: 95 });
-			expect(alerts).toHaveLength(1);
-			expect(alerts[0].ruleName).toBe("high_cpu");
-			expect(alerts[0].fired).toBe(true);
-			expect(alerts[0].severity).toBe("critical");
-		});
-
-		it("does not fire when condition is not met", async () => {
-			engine.registerRule({
-				name: "high_cpu",
-				condition: {
-					type: "threshold",
-					metric: "cpu_percent",
-					operator: ">",
-					value: 80,
-				},
-				severity: "critical",
-				cooldown: 60_000,
-				actions: [{ type: "log", level: "error" }],
-			});
-
-			const alerts = await engine.evaluate({ cpu_percent: 50 });
-			expect(alerts).toHaveLength(0);
-		});
-
-		it("evaluates all threshold operators", async () => {
-			// ">":
-			engine.registerRule({
-				name: "op_gt",
-				condition: {
-					type: "threshold",
-					metric: "val",
-					operator: ">",
-					value: 5,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [],
-			});
-			let alerts = await engine.evaluate({ val: 10 });
-			expect(alerts.some((a) => a.ruleName === "op_gt")).toBe(true);
-
-			// "<":
-			engine.registerRule({
-				name: "op_lt",
-				condition: {
-					type: "threshold",
-					metric: "val",
-					operator: "<",
-					value: 5,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [],
-			});
-			alerts = await engine.evaluate({ val: 2 });
-			expect(alerts.some((a) => a.ruleName === "op_lt")).toBe(true);
-
-			// ">=":
-			engine.registerRule({
-				name: "op_gte",
-				condition: {
-					type: "threshold",
-					metric: "val2",
-					operator: ">=",
-					value: 5,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [],
-			});
-			alerts = await engine.evaluate({ val2: 5 });
-			expect(alerts.some((a) => a.ruleName === "op_gte")).toBe(true);
-
-			// "<=":
-			engine.registerRule({
-				name: "op_lte",
-				condition: {
-					type: "threshold",
-					metric: "val3",
-					operator: "<=",
-					value: 5,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [],
-			});
-			alerts = await engine.evaluate({ val3: 5 });
-			expect(alerts.some((a) => a.ruleName === "op_lte")).toBe(true);
-
-			// "==":
-			engine.registerRule({
-				name: "op_eq",
-				condition: {
-					type: "threshold",
-					metric: "val4",
-					operator: "==",
-					value: 42,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [],
-			});
-			alerts = await engine.evaluate({ val4: 42 });
-			expect(alerts.some((a) => a.ruleName === "op_eq")).toBe(true);
-		});
-
-		it("respects cooldown — same alert not fired twice in cooldown", async () => {
-			engine.registerRule({
-				name: "cooldown_test",
-				condition: {
-					type: "threshold",
-					metric: "val",
-					operator: ">",
-					value: 0,
-				},
-				severity: "info",
-				cooldown: 10_000, // 10 second cooldown
-				actions: [{ type: "log", level: "info" }],
-			});
-
-			// First evaluation — should fire
-			const alerts1 = await engine.evaluate({ val: 1 });
-			expect(alerts1).toHaveLength(1);
-
-			// Second evaluation immediately — should NOT fire (cooldown)
-			const alerts2 = await engine.evaluate({ val: 1 });
-			expect(alerts2).toHaveLength(0);
-		});
-
-		it(
-			"fires again after cooldown expires",
-			async () => {
-				engine.registerRule({
-					name: "cooldown_expire",
-					condition: {
-						type: "threshold",
-						metric: "val",
-						operator: ">",
-						value: 0,
-					},
-					severity: "info",
-					cooldown: 50, // 50ms cooldown
-					actions: [{ type: "log", level: "info" }],
-				});
-
-				await engine.evaluate({ val: 1 });
-				await new Promise<void>((r) => setTimeout(r, 60)); // wait past cooldown
-				const alerts = await engine.evaluate({ val: 1 });
-				expect(alerts).toHaveLength(1);
-			},
-			{ timeout: 5000 },
-		);
-
-		it("does not fire disabled rules", async () => {
-			engine.registerRule({
-				name: "disabled_rule",
-				condition: {
-					type: "threshold",
-					metric: "val",
-					operator: ">",
-					value: 0,
-				},
-				severity: "info",
-				cooldown: 60_000,
-				actions: [],
-				enabled: false,
-			});
-
-			const alerts = await engine.evaluate({ val: 999 });
-			expect(alerts).toHaveLength(0);
-		});
-
-		it("fires for missing metric (treated as 0)", async () => {
-			engine.registerRule({
-				name: "missing_metric",
-				condition: {
-					type: "threshold",
-					metric: "nonexistent",
-					operator: ">",
-					value: 0,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [],
-			});
-
-			// No metrics provided at all — missing metric treated as 0
-			const alerts = await engine.evaluate({});
-			expect(alerts.some((a) => a.ruleName === "missing_metric")).toBe(false);
-		});
-	});
-
-	describe("alert recovery", () => {
-		it("resolves alert when condition no longer met", async () => {
-			engine.registerRule({
-				name: "temp_high",
-				condition: {
-					type: "threshold",
-					metric: "temperature",
-					operator: ">",
-					value: 100,
-				},
-				severity: "warning",
-				cooldown: 0,
-				actions: [{ type: "log", level: "warn" }],
-			});
-
-			// Fire alert
-			await engine.evaluate({ temperature: 150 });
-			const active = engine.getActiveAlerts();
-			expect(active.some((a) => a.ruleName === "temp_high" && a.fired)).toBe(
-				true,
-			);
-
-			// Resolve — condition no longer met
-			await engine.evaluate({ temperature: 80 });
-			const activeAfter = engine.getActiveAlerts();
-			expect(
-				activeAfter.some((a) => a.ruleName === "temp_high" && a.fired),
-			).toBe(false);
-		});
-	});
-
-	describe("alert history", () => {
-		it("getAlertHistory returns empty initially", () => {
-			const history = engine.getAlertHistory();
-			expect(history).toEqual([]);
-		});
-
-		it("getAlertHistory respects limit", () => {
-			// After alerts fire, history accumulates
-			engine.clearHistory();
-			expect(engine.getAlertHistory(5)).toEqual([]);
-		});
-	});
-
-	describe("alert actions", () => {
-		it("log action does not throw", async () => {
-			engine.registerRule({
-				name: "log_action",
-				condition: {
-					type: "threshold",
-					metric: "val",
-					operator: ">",
-					value: 0,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [{ type: "log", level: "info" }],
-			});
-
-			// Should not throw
-			const alerts = await engine.evaluate({ val: 1 });
-			expect(alerts).toHaveLength(1);
-		});
-
-		it("notify action does not throw", async () => {
-			engine.registerRule({
-				name: "notify_action",
-				condition: {
-					type: "threshold",
-					metric: "val",
-					operator: ">",
-					value: 0,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [{ type: "notify", channel: "slack", message: "Alert!" }],
-			});
-
-			const alerts = await engine.evaluate({ val: 1 });
-			expect(alerts).toHaveLength(1);
-		});
-
-		it("execute action does not throw", async () => {
-			engine.registerRule({
-				name: "exec_action",
-				condition: {
-					type: "threshold",
-					metric: "val",
-					operator: ">",
-					value: 0,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [{ type: "execute", command: "echo hello" }],
-			});
-
-			const alerts = await engine.evaluate({ val: 1 });
-			expect(alerts).toHaveLength(1);
-		});
-
-		it("webhook action does not throw (even on failure)", async () => {
-			engine.registerRule({
-				name: "webhook_action",
-				condition: {
-					type: "threshold",
-					metric: "val",
-					operator: ">",
-					value: 0,
-				},
-				severity: "info",
-				cooldown: 0,
-				actions: [
-					{
-						type: "webhook",
-						url: "http://localhost:99999/nonexistent",
-					},
-				],
-			});
-
-			// Should not throw, just log the error
-			const alerts = await engine.evaluate({ val: 1 });
-			expect(alerts).toHaveLength(1);
-		});
-	});
-});