@camstack/system 1.2.151 → 1.2.154

package/dist/builtins/native-metrics/native-metrics.addon.mjs

@@ -1,731 +1,1546 @@
-import { Ht as createEvent, Ot as errMsg, ft as reducePoints, kt as BaseAddon, ot as metricsProviderCapability, pt as resolveBucketMs, q as foldSnapshotByFunction, tn as EventCategory } from "../../dist-CbRciAbu.mjs";
+import { Ht as createEvent, Ot as errMsg, ft as reducePoints, kt as BaseAddon, ot as metricsProviderCapability, pt as resolveBucketMs, q as foldSnapshotByFunction, tn as EventCategory } from "../../dist-D_NyUV6Y.mjs";
 import { readFile, readdir } from "node:fs/promises";
 import { execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
-import * as os from "node:os";
 import * as fs from "node:fs";
-//#region src/builtins/native-metrics/native-metrics-provider.ts
-var IS_DARWIN = os.platform() === "darwin";
-var IS_LINUX = os.platform() === "linux";
-var NativeMetricsProvider = class {
-	id = "native";
-	cachedSnapshot = null;
-	samplingTimer = null;
-	macMemTimer = null;
-	prevCpu;
-	diagnostics = null;
-	consecutiveSampleErrors = 0;
-	constructor() {
-		this.prevCpu = aggregateCpuTimes();
+import { readFileSync } from "node:fs";
+import * as os from "node:os";
+//#region src/builtins/native-metrics/cgroup-memory.ts
+/** `readFileSync`, with every failure flattened to `null`. */
+var nodeCgroupFileReader = { read(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+} };
+/** Where the v2 unified hierarchy is mounted, and where v1 hangs its controllers. */
+var CGROUP_MOUNT_ROOT = "/sys/fs/cgroup";
+/**
+* The i915 GEM accounting file.
+*
+* **debugfs, and it is not mounted in our containers.** Verified on the live
+* hub on 2026-08-29: readable on the Unraid host (`6014 shrinkable [0 free]
+* objects, 1194934272 bytes`), `ENOENT` inside the `CamStack` container where
+* `native-metrics` actually runs. It is probed ONCE per process and latched —
+* a bind mount cannot appear under a running container — so an absent file
+* costs one failed `open` for the life of the runner and one log line, never a
+* failure per tick.
+*
+* Making it populate is a one-line change on the container, not here:
+* mounting `/sys/kernel/debug` read-only into `CamStack` fills this field on
+* the next sample with no code change.
+*/
+var I915_GEM_OBJECTS_PATH = "/sys/kernel/debug/dri/0/i915_gem_objects";
+/**
+* v1's "no limit" sentinel — `PAGE_COUNTER_MAX << PAGE_SHIFT`, which is what a
+* 64-bit kernel writes into `memory.limit_in_bytes` when nothing is set. It is
+* a limit in the same sense that `Infinity` is a number, so it reads as `null`.
+*/
+var V1_UNLIMITED_SENTINEL = 0x7ffffffffffff000;
+/**
+* Parse `/proc/self/cgroup`.
+*
+* Two formats, and the file may contain both on a hybrid host:
+*
+* ```
+* 0::/                                  ← v2 unified
+* 5:memory:/docker/9f3c…                ← v1, memory controller
+* 4:cpu,cpuacct:/docker/9f3c…           ← v1, other controllers
+* ```
+*
+* v2 wins when present: on a hybrid host the unified hierarchy is the one
+* carrying `memory.current`, and every camstack deployment is v2 (verified on
+* the live hub, which reports the single line `0::/`).
+*
+* Returns `null` when the file names no memory hierarchy at all — which is
+* also what a non-Linux host produces, because there is no file to read.
+*/
+function parseCgroupSelf(text) {
+	let v1 = null;
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		if (line.length === 0) continue;
+		const first = line.indexOf(":");
+		if (first < 0) continue;
+		const second = line.indexOf(":", first + 1);
+		if (second < 0) continue;
+		const controllers = line.slice(first + 1, second);
+		const path = line.slice(second + 1);
+		if (path.length === 0) continue;
+		const normalized = path.startsWith("/") ? path : `/${path}`;
+		if (controllers.length === 0) return {
+			version: "v2",
+			path: normalized
+		};
+		if (v1 === null && controllers.split(",").includes("memory")) v1 = {
+			version: "v1",
+			path: normalized
+		};
+	}
+	return v1;
+}
+/**
+* Parse a `memory.stat` file — v1 or v2, both are `key value` per line.
+*
+* Unknown keys are KEPT rather than refused: a v2 `memory.stat` carries ~50
+* fields and we read five of them, and a kernel that adds a sixth must not
+* turn into a parse failure. A malformed line is skipped, not thrown on.
+*/
+function parseCgroupStat(text) {
+	const out = /* @__PURE__ */ new Map();
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		if (line.length === 0) continue;
+		const space = line.indexOf(" ");
+		if (space <= 0) continue;
+		const key = line.slice(0, space);
+		const value = Number(line.slice(space + 1).trim());
+		if (!Number.isFinite(value)) continue;
+		out.set(key, value);
+	}
+	return out;
+}
+/**
+* Parse a single-scalar cgroup file (`memory.current`, `memory.max`, …).
+*
+* `max` — v2's word for "no limit" — and v1's `V1_UNLIMITED_SENTINEL` both
+* become `null`, because a ceiling nothing can reach is not a ceiling and
+* charting it as 8 exabytes would flatten every real series to zero.
+*/
+function parseCgroupScalar(text) {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return null;
+	if (trimmed === "max") return null;
+	const value = Number(trimmed);
+	if (!Number.isFinite(value) || value < 0) return null;
+	if (value >= V1_UNLIMITED_SENTINEL) return null;
+	return value;
+}
+/**
+* Parse the first line of `i915_gem_objects`.
+*
+* ```
+* 6014 shrinkable [0 free] objects, 1194934272 bytes
+* ```
+*
+* Only the byte total is taken. The format has changed across kernel releases
+* more than once, so a line that does not match reads `null` — an unrecognised
+* format is UNKNOWN, never zero.
+*/
+function parseI915GemObjects(text) {
+	const match = text.match(/^\s*\d+\s+shrinkable\b[^,\n]*,\s*(\d+)\s+bytes/m);
+	if (match === null) return null;
+	const bytes = Number(match[1]);
+	return Number.isFinite(bytes) ? bytes : null;
+}
+/**
+* Find the cgroup from INSIDE this process — never a hard-coded path.
+*
+* The path the hub happens to have (`/sys/fs/cgroup/docker/<id>/memory.stat`
+* as seen from the Unraid host) is an artefact of where you are standing. From
+* inside the container the same cgroup is at the mount ROOT, because Docker
+* gives the container its own cgroup namespace and `/proc/self/cgroup` reports
+* `0::/`. Hard-coding either one breaks the other.
+*
+* So the resolution is: ask `/proc/self/cgroup` which hierarchy and which
+* path, then take the FIRST candidate directory that actually publishes the
+* usage file.
+*
+* - **v2** — `<mount><path>` then `<mount>`. The second candidate is the
+*   namespaced case and the one that answers on our hub; the first is the
+*   un-namespaced case (a host process, or `--cgroupns=host`).
+* - **v1** — `<mount>/memory<path>` then `<mount>/memory`, same reasoning.
+* - **neither** — `null`. macOS has no `/proc/self/cgroup` at all, so a
+*   developer Mac lands here and reports nothing, which is the truth.
+*/
+function resolveCgroupMemoryLayout(fs) {
+	const selfText = fs.read("/proc/self/cgroup");
+	if (selfText === null) return null;
+	const entry = parseCgroupSelf(selfText);
+	if (entry === null) return null;
+	const suffix = entry.path === "/" ? "" : entry.path;
+	const candidates = entry.version === "v2" ? [`${CGROUP_MOUNT_ROOT}${suffix}`, CGROUP_MOUNT_ROOT] : [`${CGROUP_MOUNT_ROOT}/memory${suffix}`, `${CGROUP_MOUNT_ROOT}/memory`];
+	const usageFile = entry.version === "v2" ? "memory.current" : "memory.usage_in_bytes";
+	const limitFile = entry.version === "v2" ? "memory.max" : "memory.limit_in_bytes";
+	for (const directory of candidates) {
+		if (fs.read(`${directory}/${usageFile}`) === null) continue;
+		return {
+			source: entry.version === "v2" ? "cgroup-v2" : "cgroup-v1",
+			directory,
+			currentPath: `${directory}/${usageFile}`,
+			limitPath: `${directory}/${limitFile}`,
+			statPath: `${directory}/memory.stat`
+		};
+	}
+	return null;
+}
+/** A stat lookup that answers `null` for a key this hierarchy does not publish. */
+function statValue(stat, key) {
+	const value = stat.get(key);
+	return value === void 0 ? null : value;
+}
+/**
+* v2 publishes `slab` directly; older v2 kernels publish only the two halves.
+* Summing them is the same number, so the fallback is exact rather than an
+* approximation — and when neither is present the answer is `null`.
+*/
+function resolveSlab(stat) {
+	const direct = statValue(stat, "slab");
+	if (direct !== null) return direct;
+	const reclaimable = stat.get("slab_reclaimable");
+	const unreclaimable = stat.get("slab_unreclaimable");
+	if (reclaimable === void 0 || unreclaimable === void 0) return null;
+	return reclaimable + unreclaimable;
+}
+/**
+* Turn one layout's three files into a snapshot.
+*
+* Pure over the text, so the whole mapping — including a v2 `memory.stat` full
+* of fields we do not read — is testable against a real fixture.
+*
+* v1's `memory.stat` names the same quantities differently and publishes fewer
+* of them: `rss` is the anonymous charge, `cache` is the page cache, and there
+* is no slab accounting at all. Mapping them onto the same field names is what
+* makes a v1 node and a v2 node comparable; reporting `slabBytes: null` on v1
+* is what stops that comparison from lying.
+*/
+function buildContainerMemorySnapshot(input) {
+	const currentBytes = parseCgroupScalar(input.currentText);
+	if (currentBytes === null) return null;
+	const stat = input.statText === null ? /* @__PURE__ */ new Map() : parseCgroupStat(input.statText);
+	const isV2 = input.source === "cgroup-v2";
+	return {
+		source: input.source,
+		currentBytes,
+		limitBytes: input.limitText === null ? null : parseCgroupScalar(input.limitText),
+		anonBytes: statValue(stat, isV2 ? "anon" : "rss"),
+		fileBytes: statValue(stat, isV2 ? "file" : "cache"),
+		shmemBytes: statValue(stat, "shmem"),
+		slabBytes: isV2 ? resolveSlab(stat) : null,
+		gpuShmemBytes: input.gpuShmemBytes
+	};
+}
+/**
+* The sampler. Resolves once, latches, and logs TRANSITIONS only.
+*
+* Three states are worth a line and none of them is worth one per tick:
+*
+* 1. **Resolution** — once, at the first sample. Either the layout that
+*    answered, or "no cgroup on this node", which is a fact about the node and
+*    not an error.
+* 2. **GPU probe** — once, at the first sample. Absent debugfs is the normal
+*    case inside a container and is stated as such, then never retried: a bind
+*    mount cannot appear under a running container.
+* 3. **Read failing / recovering** — a cgroup that resolved and then stopped
+*    answering is a real change and says so, once in each direction. A tick
+*    that fails while already failing is silent, because the first line
+*    already said it.
+*
+* The silence is bounded by design: at the 10 s snapshot cadence a per-tick
+* warning would be 8 640 lines a day on a node that simply is not Linux.
+*/
+var ContainerMemoryProbe = class {
+	logger;
+	fs;
+	wantGpu;
+	resolved = false;
+	layout = null;
+	gpuProbed = false;
+	gpuReadable = false;
+	/** `null` until the first sample — so the FIRST outcome is a transition too. */
+	lastReadOk = null;
+	constructor(deps) {
+		this.logger = deps.logger;
+		this.fs = deps.fs ?? nodeCgroupFileReader;
+		this.wantGpu = deps.readGpu ?? true;
+	}
+	/** Did this node resolve a cgroup at all? Absent is a reportable fact. */
+	get available() {
+		return this.layout !== null;
 	}
 	/**
-	* Optional diagnostics sink for sampling errors. The first failure and
-	* every Nth failure thereafter are reported so a permanently-broken
-	* collector doesn't spam logs but is still observable.
+	* One reading, or `null` when this node has no cgroup or the cgroup stopped
+	* answering. `null` is ABSENT — the caller contributes no point, and no
+	* point is what a chart must show, never a zero.
 	*/
-	setDiagnostics(diag) {
-		this.diagnostics = diag;
-	}
-	startSampling(intervalMs) {
-		if (IS_DARWIN) {
-			sampleMacMemory(this);
-			this.macMemTimer = setInterval(() => sampleMacMemory(this), 5e3);
-			if (this.macMemTimer.unref) this.macMemTimer.unref();
+	sample() {
+		const layout = this.resolveOnce();
+		if (layout === null) return null;
+		const currentText = this.fs.read(layout.currentPath);
+		if (currentText === null) {
+			this.noteRead(false, `unreadable: ${layout.currentPath}`);
+			return null;
 		}
-		this.collectSnapshot().then((s) => {
-			this.cachedSnapshot = s;
-			this.consecutiveSampleErrors = 0;
-		}).catch((err) => this.reportSampleError(err));
-		this.samplingTimer = setInterval(() => {
-			this.collectSnapshot().then((s) => {
-				this.cachedSnapshot = s;
-				this.consecutiveSampleErrors = 0;
-			}).catch((err) => this.reportSampleError(err));
-		}, intervalMs);
-		if (this.samplingTimer.unref) this.samplingTimer.unref();
-	}
-	reportSampleError(err) {
-		this.consecutiveSampleErrors++;
-		if (!this.diagnostics) return;
-		if (!(this.consecutiveSampleErrors === 1 || this.consecutiveSampleErrors % 60 === 0)) return;
-		this.diagnostics.warn("metrics-provider sample failed", {
-			consecutiveErrors: this.consecutiveSampleErrors,
-			error: err instanceof Error ? err.message : String(err)
+		const snapshot = buildContainerMemorySnapshot({
+			source: layout.source,
+			currentText,
+			limitText: this.fs.read(layout.limitPath),
+			statText: this.fs.read(layout.statPath),
+			gpuShmemBytes: this.readGpuShmem()
 		});
+		if (snapshot === null) {
+			this.noteRead(false, `unparseable: ${layout.currentPath}`);
+			return null;
+		}
+		this.noteRead(true, null);
+		return snapshot;
 	}
-	stopSampling() {
-		if (this.samplingTimer) {
-			clearInterval(this.samplingTimer);
-			this.samplingTimer = null;
+	/** Resolve on first use and never again — a cgroup does not move under a pid. */
+	resolveOnce() {
+		if (this.resolved) return this.layout;
+		this.resolved = true;
+		try {
+			this.layout = resolveCgroupMemoryLayout(this.fs);
+		} catch (err) {
+			this.layout = null;
+			this.logger.warn("cgroup memory resolution failed — container memory will be ABSENT", { meta: { error: errMsg(err) } });
+			return null;
 		}
-		if (this.macMemTimer) {
-			clearInterval(this.macMemTimer);
-			this.macMemTimer = null;
+		if (this.layout === null) {
+			this.logger.info("no cgroup on this node — container memory is ABSENT, not zero, for every sample", { meta: {
+				platform: process.platform,
+				probed: "/proc/self/cgroup"
+			} });
+			return null;
 		}
+		this.logger.info("container memory resolved from the cgroup", { meta: {
+			source: this.layout.source,
+			directory: this.layout.directory
+		} });
+		return this.layout;
 	}
-	async collectSnapshot() {
-		const cpu = this.sampleCpu();
-		const memory = this.getMemoryInfo();
-		const processInfo = getProcessResources();
-		const [gpu, network, disk, cpuTemp] = await Promise.all([
-			getGpuInfoInternal().catch(() => null),
-			takeNetworkIoSnapshot(),
-			takeDiskIoSnapshot(),
-			getCpuTemperatureInternal().catch(() => null)
-		]);
-		const snapshot = {
-			cpu,
-			memory,
-			gpu,
-			network,
-			disk,
-			pressure: {
-				cpu: getPressure("cpu"),
-				memory: getPressure("memory"),
-				io: getPressure("io")
-			},
-			process: processInfo,
-			cpuTemperature: cpuTemp,
-			timestampMs: Date.now()
-		};
-		this.cachedSnapshot = snapshot;
-		return snapshot;
+	/**
+	* The GPU number, probed once.
+	*
+	* It is host-wide and lives in debugfs, so it is absent far more often than
+	* it is present — inside every camstack container today. One `open` decides
+	* it for the life of the process; after that an unreadable file costs
+	* nothing at all, not even a syscall.
+	*/
+	readGpuShmem() {
+		if (!this.wantGpu) return null;
+		if (!this.gpuProbed) {
+			this.gpuProbed = true;
+			const text = this.fs.read(I915_GEM_OBJECTS_PATH);
+			this.gpuReadable = text !== null && parseI915GemObjects(text) !== null;
+			this.logger.info(this.gpuReadable ? "i915 GEM accounting is readable — GPU-backed shmem will be reported" : "i915 GEM accounting is NOT readable — gpuShmemBytes stays UNKNOWN (this is normal: debugfs is not mounted in the container, and a node with no Intel GPU has no such file)", { meta: { path: I915_GEM_OBJECTS_PATH } });
+			if (!this.gpuReadable) return null;
+			return text === null ? null : parseI915GemObjects(text);
+		}
+		if (!this.gpuReadable) return null;
+		const text = this.fs.read(I915_GEM_OBJECTS_PATH);
+		return text === null ? null : parseI915GemObjects(text);
+	}
+	/** Log a read outcome only when it CHANGES. Never once per tick. */
+	noteRead(ok, reason) {
+		if (this.lastReadOk === ok) return;
+		const first = this.lastReadOk === null;
+		this.lastReadOk = ok;
+		if (!ok) {
+			this.logger.warn("cgroup memory stopped answering — container memory is ABSENT until it returns", { meta: { reason: reason ?? "unknown" } });
+			return;
+		}
+		if (!first) this.logger.info("cgroup memory is answering again");
 	}
-	async getCached() {
-		return this.cachedSnapshot;
+};
+/**
+* One node's fixed-capacity circular buffer of samples.
+*
+* Mirrors {@link LogRingBuffer}: write at `head`, wrap, and once full every
+* accepted sample evicts the oldest. `rows` is carried alongside so the fleet
+* budget never has to walk the samples to know what a partition costs.
+*/
+var LoadPartition = class {
+	capacity;
+	slots;
+	head = 0;
+	count = 0;
+	rows = 0;
+	/** Newest retained sample's timestamp — the monotonic gate for `push`. */
+	newestAtMs = null;
+	constructor(capacity) {
+		this.capacity = capacity;
+		this.slots = Array.from({ length: capacity });
 	}
-	async getCurrent() {
-		const s = this.cachedSnapshot ?? await this.collectSnapshot();
-		const mb = (bytes) => Math.round(bytes / 1024 / 1024);
+	/**
+	* Accept a sample.
+	*
+	* A sample at or before the newest one already held is REFUSED. The bus drops
+	* a node's own broadcast echo, but a cross-node redelivery or a replayed
+	* subscription must not be able to double a point — and idempotence here is
+	* what lets every reader above treat the series as a set.
+	*
+	* `accepted` is reported separately from `rowDelta` on purpose: a full ring
+	* that evicts a sample of the same size has a delta of zero and is not a
+	* refusal, and conflating the two would silently stop advancing the write
+	* ordinal on a steady-state cluster.
+	*/
+	push(sample) {
+		if (this.newestAtMs !== null && sample.atMs <= this.newestAtMs) return {
+			accepted: false,
+			rowDelta: 0
+		};
+		const evicted = this.count === this.capacity ? this.slots[this.head]?.processes.length ?? 0 : 0;
+		this.slots[this.head] = sample;
+		this.head = (this.head + 1) % this.capacity;
+		if (this.count < this.capacity) this.count++;
+		this.newestAtMs = sample.atMs;
+		const rowDelta = sample.processes.length - evicted;
+		this.rows += rowDelta;
 		return {
-			cpuPercent: s.cpu.total,
-			memoryPercent: s.memory.percent,
-			memoryUsedMB: mb(s.memory.usedBytes),
-			memoryTotalMB: mb(s.memory.totalBytes),
-			temperature: s.cpuTemperature ?? void 0,
-			gpuPercent: s.gpu?.utilization,
-			gpuMemoryPercent: s.gpu && s.gpu.memoryTotalBytes > 0 ? Math.round(s.gpu.memoryUsedBytes / s.gpu.memoryTotalBytes * 1e3) / 10 : void 0
+			accepted: true,
+			rowDelta
 		};
 	}
-	async getDiskSpace(input) {
-		return getDiskSpaceInternal(input.dirPath);
+	/** Drop the oldest sample. Returns the rows reclaimed (0 when empty). */
+	dropOldest() {
+		if (this.count === 0) return 0;
+		const index = (this.head - this.count + this.capacity) % this.capacity;
+		const victim = this.slots[index];
+		this.slots[index] = void 0;
+		this.count--;
+		const reclaimed = victim?.processes.length ?? 0;
+		this.rows -= reclaimed;
+		if (this.count === 0) this.newestAtMs = null;
+		return reclaimed;
 	}
-	async getGpuInfo() {
-		return getGpuInfoInternal();
+	/** Oldest-first, optionally only what is strictly newer than `sinceMs`. */
+	list(sinceMs) {
+		const out = [];
+		for (let i = 0; i < this.count; i++) {
+			const index = (this.head - this.count + i + this.capacity) % this.capacity;
+			const sample = this.slots[index];
+			if (sample === void 0) continue;
+			if (sinceMs !== void 0 && sample.atMs <= sinceMs) continue;
+			out.push(sample);
+		}
+		return out;
 	}
-	async getCpuTemperature() {
-		return getCpuTemperatureInternal();
+	size() {
+		return this.count;
 	}
-	async getProcessStats(input) {
-		const { getPidStats } = await import("../../resource-monitor-BWmQ5i-o.mjs").then((n) => n.r);
-		const raw = await getPidStats(input.pids);
-		const result = [];
-		for (const [pid, s] of raw) result.push({
-			pid,
-			cpu: s.cpu,
-			memory: s.memory,
-			privateBytes: s.privateBytes,
-			sharedBytes: s.sharedBytes
-		});
-		return result;
+	rowCount() {
+		return this.rows;
 	}
-	sampleCpu() {
-		const curr = aggregateCpuTimes();
-		const prev = this.prevCpu;
-		this.prevCpu = curr;
-		const dUser = curr.user - prev.user;
-		const dNice = curr.nice - prev.nice;
-		const dSys = curr.sys - prev.sys;
-		const dIrq = curr.irq - prev.irq;
-		const dIdle = curr.idle - prev.idle;
-		const dTotal = dUser + dNice + dSys + dIrq + dIdle;
-		const pct = (v) => dTotal === 0 ? 0 : Math.round(v / dTotal * 1e3) / 10;
-		return {
-			total: pct(dUser + dNice + dSys + dIrq),
-			user: pct(dUser),
-			system: pct(dSys),
-			irq: pct(dIrq),
-			nice: pct(dNice),
-			loadAvg: os.loadavg(),
-			cores: os.cpus().length
-		};
+	oldestAtMs() {
+		if (this.count === 0) return null;
+		const index = (this.head - this.count + this.capacity) % this.capacity;
+		return this.slots[index]?.atMs ?? null;
 	}
-	/** Cached macOS memory (set by sampleMacMemory timer). */
-	_cachedMacMem = null;
-	getMemoryInfo() {
-		const total = os.totalmem();
-		if (total === 0) return {
-			percent: 0,
-			totalBytes: 0,
-			usedBytes: 0,
-			availableBytes: 0,
-			swapUsedBytes: 0,
-			swapTotalBytes: 0
-		};
-		if (IS_DARWIN && this._cachedMacMem !== null) return this._cachedMacMem;
-		const free = os.freemem();
-		const used = total - free;
-		let swapUsedBytes = 0;
-		let swapTotalBytes = 0;
-		if (IS_LINUX) try {
-			const meminfo = fs.readFileSync("/proc/meminfo", "utf-8");
-			const swapTotal = parseInt(meminfo.match(/SwapTotal:\s+(\d+)/)?.[1] ?? "0", 10) * 1024;
-			const swapFree = parseInt(meminfo.match(/SwapFree:\s+(\d+)/)?.[1] ?? "0", 10) * 1024;
-			swapTotalBytes = swapTotal;
-			swapUsedBytes = swapTotal - swapFree;
-		} catch {}
-		return {
-			percent: Math.round((total - free) / total * 1e3) / 10,
-			totalBytes: total,
-			usedBytes: used,
-			availableBytes: free,
-			swapUsedBytes,
-			swapTotalBytes
-		};
+	lastWriteAtMs() {
+		return this.newestAtMs;
 	}
 };
-function aggregateCpuTimes() {
-	const cpus = os.cpus();
-	let user = 0, nice = 0, sys = 0, irq = 0, idle = 0;
-	for (const cpu of cpus) {
-		user += cpu.times.user;
-		nice += cpu.times.nice;
-		sys += cpu.times.sys;
-		irq += cpu.times.irq;
-		idle += cpu.times.idle;
+/**
+* The partitioned ring: one {@link LoadPartition} per node id.
+*
+* Three bounds, doing three different jobs — the same division as the log
+* buffer, for the same reason:
+*
+* - **`samplesPerNode`** is HARD and per partition. It is what the operator
+*   asked for (an hour) and it can never be exceeded.
+* - **`maxTotalProcessRows`** is the FLEET budget, and it is denominated in the
+*   thing memory is proportional to. When it bites, the oldest sample of the
+*   HEAVIEST partition is dropped — the node creating the pressure is the node
+*   that pays, and a quiet node keeps its full hour. The node just written to is
+*   NOT protected here: if it is the heaviest, it is the culprit.
+* - **`maxNodes`** is the backstop against an unbounded key space, and it drops
+*   whole partitions least-recently-written first, never the one being written.
+*
+* Plus {@link DEFAULT_NODE_IDLE_EVICTION_MS}, which is what stops a node that
+* simply stopped emitting from living in memory forever.
+*/
+var NodeLoadRing = class {
+	partitions = /* @__PURE__ */ new Map();
+	/**
+	* Node id → write ordinal of its last accepted sample. A monotonic counter,
+	* not a clock: partition eviction must follow the order writes actually
+	* happened, and node clocks disagree.
+	*/
+	lastWriteSeq = /* @__PURE__ */ new Map();
+	writeSeq = 0;
+	totalRows = 0;
+	samplesPerNode;
+	maxTotalProcessRows;
+	maxNodes;
+	idleEvictionMs;
+	now;
+	constructor(options = {}) {
+		this.samplesPerNode = options.samplesPerNode ?? 180;
+		this.maxTotalProcessRows = options.maxTotalProcessRows ?? 32e3;
+		this.maxNodes = options.maxNodes ?? 16;
+		this.idleEvictionMs = options.idleEvictionMs ?? 36e5;
+		this.now = options.now ?? Date.now;
 	}
-	return {
-		user,
-		nice,
-		sys,
-		irq,
-		idle
-	};
-}
-function sampleMacMemory(provider) {
-	try {
-		const output = execFileSync("vm_stat", {
-			timeout: 2e3,
-			encoding: "utf-8"
+	/**
+	* Retain one snapshot. `processes` is stored by reference — the payload is
+	* already an immutable arrival off the bus, and copying it would double the
+	* measured cost for nothing.
+	*
+	* Returns whether the sample was ACCEPTED — that is, whether it was new
+	* rather than a replay of a timestamp this node has already delivered.
+	*
+	* The return value is not diagnostics. It is the idempotence gate the
+	* DURABLE tier rides on (`load-series-store.ts`): only an accepted sample is
+	* appended to the table, which is what lets that table carry an `INTEGER`
+	* rowid key instead of a composite unique index over two million rows. The
+	* gate is one monotonic comparison in memory; the index it replaces was
+	* measured at ~40 bytes per row.
+	*/
+	record(nodeId, atMs, processes) {
+		if (nodeId.length === 0) return false;
+		this.sweepIdle();
+		let partition = this.partitions.get(nodeId);
+		if (partition === void 0) {
+			partition = new LoadPartition(this.samplesPerNode);
+			this.partitions.set(nodeId, partition);
+		}
+		const outcome = partition.push({
+			atMs,
+			processes
 		});
-		const pageSize = 16384;
-		const parse = (label) => {
-			const match = output.match(new RegExp(`${label}:\\s+(\\d+)`));
-			return match ? parseInt(match[1], 10) * pageSize : 0;
+		if (!outcome.accepted) {
+			if (partition.size() === 0) this.partitions.delete(nodeId);
+			return false;
+		}
+		this.totalRows += outcome.rowDelta;
+		this.lastWriteSeq.set(nodeId, ++this.writeSeq);
+		if (this.partitions.size > this.maxNodes) this.evictPartitions(this.partitions.size - this.maxNodes, nodeId);
+		this.enforceRowBudget();
+		return true;
+	}
+	/**
+	* Read one node's retained series, oldest-first.
+	*
+	* `sinceMs` is EXCLUSIVE: a caller passes the newest timestamp it already
+	* holds and gets back only what it is missing. That is the whole contract
+	* that lets the admin UI seed from here and then continue live without
+	* doubling a point it already drew.
+	*
+	* A node nobody has recorded answers with an empty series, not an error —
+	* unknown is the truth about a node that has not reported.
+	*/
+	read(nodeId, sinceMs) {
+		this.sweepIdle();
+		const partition = this.partitions.get(nodeId);
+		if (partition === void 0) return {
+			nodeId,
+			samples: [],
+			retainedSamples: 0,
+			oldestAtMs: null,
+			capacity: this.samplesPerNode
 		};
-		const free = parse("Pages free");
-		const inactive = parse("Pages inactive");
-		const purgeable = parse("Pages purgeable");
-		const speculative = parse("Pages speculative");
-		const available = free + inactive + purgeable + speculative;
-		const total = os.totalmem();
-		const used = total - available;
-		let swapUsedBytes = 0;
-		let swapTotalBytes = 0;
-		try {
-			const swapOut = execFileSync("sysctl", ["-n", "vm.swapusage"], {
-				timeout: 2e3,
-				encoding: "utf-8"
-			});
-			const totalMatch = swapOut.match(/total\s*=\s*([\d.]+)M/);
-			const usedMatch = swapOut.match(/used\s*=\s*([\d.]+)M/);
-			if (totalMatch) swapTotalBytes = parseFloat(totalMatch[1]) * 1024 * 1024;
-			if (usedMatch) swapUsedBytes = parseFloat(usedMatch[1]) * 1024 * 1024;
-		} catch {}
-		provider._cachedMacMem = {
-			percent: Math.round(used / total * 1e3) / 10,
-			totalBytes: total,
-			usedBytes: used,
-			availableBytes: available,
-			swapUsedBytes,
-			swapTotalBytes
+		return {
+			nodeId,
+			samples: partition.list(sinceMs),
+			retainedSamples: partition.size(),
+			oldestAtMs: partition.oldestAtMs(),
+			capacity: this.samplesPerNode
 		};
-	} catch {
-		provider._cachedMacMem = null;
 	}
-}
-function getDiskSpaceInternal(dirPath) {
-	return new Promise((resolve, reject) => {
-		fs.statfs(dirPath, (err, stats) => {
-			if (err) return reject(err);
-			const totalBytes = stats.blocks * stats.bsize;
-			const availableBytes = stats.bavail * stats.bsize;
-			const usedBytes = totalBytes - stats.bfree * stats.bsize;
-			resolve({
-				path: dirPath,
-				totalBytes,
-				usedBytes,
-				availableBytes,
-				percent: totalBytes > 0 ? Math.round(usedBytes / totalBytes * 1e3) / 10 : 0
-			});
-		});
-	});
-}
-async function takeDiskIoSnapshot() {
-	const now = Date.now();
-	if (IS_LINUX) try {
-		const data = fs.readFileSync("/proc/diskstats", "utf-8");
-		let readOps = 0, readBytes = 0, writeOps = 0, writeBytes = 0;
-		for (const line of data.split("\n")) {
-			const parts = line.trim().split(/\s+/);
-			if (parts.length < 14) continue;
-			const devName = parts[2];
-			if (/\d+$/.test(devName) && !/^nvme\d+n\d+$/.test(devName)) continue;
-			readOps += parseInt(parts[3], 10) || 0;
-			readBytes += (parseInt(parts[5], 10) || 0) * 512;
-			writeOps += parseInt(parts[7], 10) || 0;
-			writeBytes += (parseInt(parts[9], 10) || 0) * 512;
+	/** Node ids with a live partition. Observability for the fleet bound. */
+	nodeIds() {
+		return [...this.partitions.keys()];
+	}
+	/** Process rows retained across every partition — the number that IS memory. */
+	rowCount() {
+		return this.totalRows;
+	}
+	/** Samples retained across every partition. */
+	sampleCount() {
+		let total = 0;
+		for (const partition of this.partitions.values()) total += partition.size();
+		return total;
+	}
+	/**
+	* Drop partitions whose newest sample is older than the retention window.
+	*
+	* Lazy, on write and on read — never a timer. A timer would be a new
+	* periodic cost in a subsystem whose entire premise is that it adds none,
+	* and a ring that nobody writes to and nobody reads is not growing either.
+	*/
+	sweepIdle() {
+		const cutoff = this.now() - this.idleEvictionMs;
+		for (const [nodeId, partition] of [...this.partitions.entries()]) {
+			const lastWrite = partition.lastWriteAtMs();
+			if (lastWrite !== null && lastWrite > cutoff) continue;
+			this.dropPartition(nodeId);
 		}
-		return {
-			readBytes,
-			writeBytes,
-			readOps,
-			writeOps,
-			timestampMs: now
-		};
-	} catch {}
-	return {
-		readBytes: 0,
-		writeBytes: 0,
-		readOps: 0,
-		writeOps: 0,
-		timestampMs: now
-	};
+	}
+	/**
+	* Bring the fleet back under the row budget by dropping the OLDEST sample of
+	* the HEAVIEST partition, repeatedly.
+	*
+	* Terminates: every iteration removes one sample from a non-empty partition,
+	* and the population of samples is finite and strictly decreasing.
+	*/
+	enforceRowBudget() {
+		while (this.totalRows > this.maxTotalProcessRows) {
+			const victim = this.heaviestPartition();
+			if (victim === null) return;
+			const [nodeId, partition] = victim;
+			this.totalRows -= partition.dropOldest();
+			if (partition.size() === 0) this.dropPartition(nodeId);
+		}
+	}
+	heaviestPartition() {
+		let best = null;
+		for (const entry of this.partitions.entries()) {
+			if (entry[1].size() === 0) continue;
+			if (best === null || entry[1].rowCount() > best[1].rowCount()) best = entry;
+		}
+		return best;
+	}
+	/** Drop `count` whole partitions, least-recently-written first. */
+	evictPartitions(count, protectedNodeId) {
+		const order = [...this.partitions.keys()].filter((nodeId) => nodeId !== protectedNodeId).toSorted((a, b) => (this.lastWriteSeq.get(a) ?? 0) - (this.lastWriteSeq.get(b) ?? 0));
+		let remaining = count;
+		for (const nodeId of order) {
+			if (remaining <= 0) return;
+			this.dropPartition(nodeId);
+			remaining -= 1;
+		}
+	}
+	/** Remove a partition and everything that indexes it. */
+	dropPartition(nodeId) {
+		const partition = this.partitions.get(nodeId);
+		if (partition === void 0) return;
+		this.totalRows -= partition.rowCount();
+		this.partitions.delete(nodeId);
+		this.lastWriteSeq.delete(nodeId);
+	}
+};
+//#endregion
+//#region src/builtins/native-metrics/container-memory-series.ts
+/**
+* @durable class=audit owner=metrics-native
+*   write="one row per NODE per sample, appended by the HUB's `native-metrics`
+*     off its subscription to `metrics.node-processes-snapshot` — the same
+*     subscription, the same accepted-sample gate and the same timestamps as
+*     `metrics:node-load-samples`, so a memory row and the process rows of the
+*     same instant share an `atMs`. A node with no cgroup writes NOTHING; it
+*     never writes a zeroed row."
+*   retention="The operator's `loadSeriesRetentionHours` by age and
+*     CONTAINER_MEMORY_MAX_ROWS by count, swept in the same pass as the process
+*     table and through the same bounded page. Losing the table loses the cold
+*     window only: the ring keeps serving the last hour."
+*/
+var CONTAINER_MEMORY_COLLECTION = "metrics:node-memory-samples";
+/**
+* Fleet ceiling on the hot ring, in READINGS.
+*
+* One reading per node per sample, so this is simply the per-node ceiling times
+* the partition ceiling the process ring already declares (16). 2 880 readings
+* of ten numbers each is well under a megabyte — the bound exists so a runaway
+* node id space costs a fixed amount, not because the number is large.
+*/
+var CONTAINER_MEMORY_MAX_TOTAL_ROWS = 2880;
+/**
+* Hard ceiling on the durable table, in ROWS. The guarantee behind the
+* retention intention, exactly as `DEFAULT_MAX_ROWS` is for the process table.
+*
+* | cadence | retention | rows (3 nodes) |
+* | --- | --- | --- |
+* | 10 s | 6 h (default) | 6 480 |
+* | 5 s | 6 h | 12 960 |
+* | 5 s | 72 h, 16 nodes | 829 440 — capped here |
+*
+* 50 000 rows is 7.7x the shipped default. This row is strictly narrower than
+* a `metrics:node-load-samples` row — fewer columns, one index, every value an
+* integer varint — and that one was MEASURED at 87 B/row, so 50 000 rows is
+* **under 4.2 MiB** with the real figure lower still. It is not a knob: a
+* guarantee that moves with the hand that raised the intention is not one.
+*/
+var CONTAINER_MEMORY_MAX_ROWS = 5e4;
+var CONTAINER_MEMORY_COLUMNS = [
+	{
+		name: "id",
+		type: "INTEGER",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "nodeId",
+		type: "TEXT",
+		notNull: true
+	},
+	(
+	/** Shared with the process rows of the same tick — that is the whole point. */
+	{
+		name: "atMs",
+		type: "INTEGER",
+		notNull: true
+	}),
+	{
+		name: "source",
+		type: "TEXT",
+		notNull: true
+	},
+	(
+	/**
+	* Whole MiB, like `rssMib` on the process row and for the same reason: a
+	* byte-exact residency on a value in the tens of gigabytes is precision no
+	* chart can draw, and it costs bytes on every row forever.
+	*/
+	{
+		name: "currentMib",
+		type: "INTEGER",
+		notNull: true
+	}),
+	(
+	/** `NULL` = NO LIMIT. Never a sentinel. */
+	{
+		name: "limitMib",
+		type: "INTEGER"
+	}),
+	(
+	/** `NULL` = UNKNOWN on all four. Never zero. */
+	{
+		name: "anonMib",
+		type: "INTEGER"
+	}),
+	{
+		name: "fileMib",
+		type: "INTEGER"
+	},
+	{
+		name: "shmemMib",
+		type: "INTEGER"
+	},
+	{
+		name: "slabMib",
+		type: "INTEGER"
+	},
+	(
+	/** Host-wide i915 GEM bytes. `NULL` wherever debugfs is not mounted. */
+	{
+		name: "gpuShmemMib",
+		type: "INTEGER"
+	})
+];
+var CONTAINER_MEMORY_INDEXES = [(
+/** The one index, and it serves both the read and the prune — see the
+*  process table's `idx_load_samples_node_at` for the full reasoning. */
+{
+	name: "idx_node_memory_node_at",
+	columns: ["nodeId", "atMs"]
+})];
+var BYTES_PER_MIB$1 = 1048576;
+/** Bytes → whole MiB. `null` stays `null`: unknown is not zero. */
+function toMib(value) {
+	return value === null ? null : Math.round(value / BYTES_PER_MIB$1);
+}
+/** Whole MiB → bytes. `null` stays `null`. */
+function fromMib(value) {
+	return value === null ? null : value * BYTES_PER_MIB$1;
 }
-async function takeNetworkIoSnapshot() {
-	const now = Date.now();
-	if (IS_LINUX) try {
-		const data = fs.readFileSync("/proc/net/dev", "utf-8");
-		let rxBytes = 0, txBytes = 0, rxPackets = 0, txPackets = 0, rxErrors = 0, txErrors = 0;
-		for (const line of data.split("\n")) {
-			const match = line.match(/^\s*(\w+):\s+(.+)$/);
-			if (!match) continue;
-			if (match[1] === "lo") continue;
-			const cols = match[2].trim().split(/\s+/);
-			rxBytes += parseInt(cols[0], 10) || 0;
-			rxPackets += parseInt(cols[1], 10) || 0;
-			rxErrors += parseInt(cols[2], 10) || 0;
-			txBytes += parseInt(cols[8], 10) || 0;
-			txPackets += parseInt(cols[9], 10) || 0;
-			txErrors += parseInt(cols[10], 10) || 0;
-		}
-		return {
-			rxBytes,
-			txBytes,
-			rxPackets,
-			txPackets,
-			rxErrors,
-			txErrors,
-			timestampMs: now
-		};
-	} catch {}
-	if (IS_DARWIN) try {
-		const stdout = await execAsync("netstat", ["-ib"]);
-		let rxBytes = 0, txBytes = 0, rxPackets = 0, txPackets = 0, rxErrors = 0, txErrors = 0;
-		for (const line of stdout.split("\n")) {
-			const parts = line.trim().split(/\s+/);
-			if (parts.length < 11) continue;
-			if (parts[0] === "lo0" || parts[0] === "Name") continue;
-			if (!parts[2]?.startsWith("Link#")) continue;
-			rxPackets += parseInt(parts[4], 10) || 0;
-			rxErrors += parseInt(parts[5], 10) || 0;
-			rxBytes += parseInt(parts[6], 10) || 0;
-			txPackets += parseInt(parts[7], 10) || 0;
-			txErrors += parseInt(parts[8], 10) || 0;
-			txBytes += parseInt(parts[9], 10) || 0;
-		}
-		return {
-			rxBytes,
-			txBytes,
-			rxPackets,
-			txPackets,
-			rxErrors,
-			txErrors,
-			timestampMs: now
-		};
-	} catch {}
+/** The ONE encode. */
+function snapshotToRow(nodeId, atMs, snapshot) {
 	return {
-		rxBytes: 0,
-		txBytes: 0,
-		rxPackets: 0,
-		txPackets: 0,
-		rxErrors: 0,
-		txErrors: 0,
-		timestampMs: now
+		nodeId,
+		atMs,
+		source: snapshot.source,
+		currentMib: Math.round(snapshot.currentBytes / BYTES_PER_MIB$1),
+		limitMib: toMib(snapshot.limitBytes),
+		anonMib: toMib(snapshot.anonBytes),
+		fileMib: toMib(snapshot.fileBytes),
+		shmemMib: toMib(snapshot.shmemBytes),
+		slabMib: toMib(snapshot.slabBytes),
+		gpuShmemMib: toMib(snapshot.gpuShmemBytes)
 	};
 }
-async function getCpuTemperatureInternal() {
-	if (IS_LINUX) for (const p of ["/sys/class/thermal/thermal_zone0/temp", "/sys/class/hwmon/hwmon0/temp1_input"]) try {
-		const raw = fs.readFileSync(p, "utf-8").trim();
-		const millideg = parseInt(raw, 10);
-		if (!isNaN(millideg)) return Math.round(millideg / 100) / 10;
-	} catch {
-		continue;
-	}
-	if (IS_DARWIN) try {
-		const match = (await execAsync("sudo", [
-			"-n",
-			"powermetrics",
-			"--samplers",
-			"smc",
-			"-i",
-			"1",
-			"-n",
-			"1"
-		], 3e3)).match(/CPU die temperature:\s+([\d.]+)\s*C/);
-		if (match) return Math.round(parseFloat(match[1]) * 10) / 10;
-	} catch {}
-	return null;
-}
-async function getGpuInfoInternal() {
-	if (IS_DARWIN) try {
-		const utilMatch = (await execAsync("ioreg", [
-			"-r",
-			"-d",
-			"1",
-			"-c",
-			"IOAccelerator"
-		])).match(/"GPU Core Utilization"\s*=\s*(\d+)/);
-		const util = utilMatch ? parseInt(utilMatch[1], 10) : 0;
-		const utilPct = util > 1e3 ? Math.round(util / 1e7) : util;
-		return {
-			utilization: Math.min(100, utilPct),
-			model: "Apple Silicon GPU",
-			memoryUsedBytes: 0,
-			memoryTotalBytes: 0,
-			temperature: null
-		};
-	} catch {}
-	if (IS_LINUX) try {
-		const parts = (await execAsync("nvidia-smi", ["--query-gpu=utilization.gpu,name,memory.used,memory.total,temperature.gpu", "--format=csv,noheader,nounits"])).trim().split(",").map((s) => s.trim());
-		if (parts.length >= 5) return {
-			utilization: parseInt(parts[0], 10) || 0,
-			model: parts[1] ?? "Unknown GPU",
-			memoryUsedBytes: (parseInt(parts[2], 10) || 0) * 1024 * 1024,
-			memoryTotalBytes: (parseInt(parts[3], 10) || 0) * 1024 * 1024,
-			temperature: parseInt(parts[4], 10) || null
-		};
-	} catch {}
-	return null;
+/**
+* The ONE decode. A row whose `source` is not a hierarchy this build knows is
+* skipped rather than coerced — a stored string that no longer means anything
+* must not be charted as though it did.
+*/
+function rowToPoint(row) {
+	if (row.source !== "cgroup-v2" && row.source !== "cgroup-v1") return null;
+	return {
+		atMs: row.atMs,
+		source: row.source,
+		currentBytes: row.currentMib * BYTES_PER_MIB$1,
+		limitBytes: fromMib(row.limitMib),
+		anonBytes: fromMib(row.anonMib),
+		fileBytes: fromMib(row.fileMib),
+		shmemBytes: fromMib(row.shmemMib),
+		slabBytes: fromMib(row.slabMib),
+		gpuShmemBytes: fromMib(row.gpuShmemMib)
+	};
 }
-function getProcessResources() {
-	let openFds = 0;
-	let threadCount = 0;
-	if (IS_LINUX) {
-		try {
-			openFds = fs.readdirSync(`/proc/${process.pid}/fd`).length;
-		} catch {}
-		try {
-			const match = fs.readFileSync(`/proc/${process.pid}/status`, "utf-8").match(/Threads:\s+(\d+)/);
-			if (match) threadCount = parseInt(match[1], 10);
-		} catch {}
-	}
-	const nodeProcess = process;
+/** Structural validation on read. A malformed row is skipped, never charted. */
+function recordToMemoryRow(data) {
+	const nodeId = data["nodeId"];
+	const source = data["source"];
+	if (typeof nodeId !== "string" || typeof source !== "string") return null;
+	const atMs = Number(data["atMs"]);
+	const currentMib = Number(data["currentMib"]);
+	if (!Number.isFinite(atMs) || !Number.isFinite(currentMib)) return null;
+	const optional = (raw) => {
+		if (raw === null || raw === void 0) return null;
+		const n = Number(raw);
+		return Number.isFinite(n) ? n : null;
+	};
 	return {
-		openFds,
-		threadCount,
-		activeHandles: (nodeProcess._getActiveHandles?.() ?? []).length,
-		activeRequests: (nodeProcess._getActiveRequests?.() ?? []).length
+		nodeId,
+		atMs,
+		source,
+		currentMib,
+		limitMib: optional(data["limitMib"]),
+		anonMib: optional(data["anonMib"]),
+		fileMib: optional(data["fileMib"]),
+		shmemMib: optional(data["shmemMib"]),
+		slabMib: optional(data["slabMib"]),
+		gpuShmemMib: optional(data["gpuShmemMib"])
 	};
 }
-function getPressure(resource) {
-	if (!IS_LINUX) return null;
-	try {
-		const data = fs.readFileSync(`/proc/pressure/${resource}`, "utf-8");
-		const parseLine = (prefix) => {
-			const match = data.match(new RegExp(`${prefix} avg10=(\\d+\\.\\d+) avg60=(\\d+\\.\\d+) avg300=(\\d+\\.\\d+)`));
-			if (!match) return null;
-			return {
-				avg10: parseFloat(match[1]),
-				avg60: parseFloat(match[2]),
-				avg300: parseFloat(match[3])
-			};
-		};
-		const some = parseLine("some");
-		if (!some) return null;
-		return {
-			some,
-			full: parseLine("full")
-		};
-	} catch {
-		return null;
+/**
+* The HOT tier — a naming adapter over {@link NodeLoadRing}, not a second ring.
+*
+* One reading per sample, so the ring's "rows" and its samples are the same
+* count and its fleet budget is a sample budget. Every bound, the idle sweep
+* and the monotonic replay gate come from there unchanged.
+*/
+var ContainerMemoryRing = class {
+	ring;
+	constructor(options = {}) {
+		this.ring = new NodeLoadRing({
+			samplesPerNode: options.samplesPerNode ?? 180,
+			maxTotalProcessRows: CONTAINER_MEMORY_MAX_TOTAL_ROWS,
+			...options.now !== void 0 ? { now: options.now } : {}
+		});
 	}
-}
-function execAsync(cmd, args, timeoutMs = 5e3) {
-	return new Promise((resolve, reject) => {
-		execFile(cmd, args, { timeout: timeoutMs }, (err, stdout) => {
-			if (err) return reject(err);
-			resolve(stdout);
+	/** Retain one reading. `false` = a timestamp this node already delivered. */
+	record(nodeId, atMs, snapshot) {
+		return this.ring.record(nodeId, atMs, [snapshot]);
+	}
+	/**
+	* Read one node's retained readings, oldest-first. `sinceMs` is EXCLUSIVE,
+	* matching every other reader in this subsystem.
+	*
+	* A node nobody has recorded answers EMPTY — which is what "this node has no
+	* cgroup" looks like, and it must stay distinguishable from a zero.
+	*/
+	read(nodeId, sinceMs) {
+		const series = this.ring.read(nodeId, sinceMs);
+		const out = [];
+		for (const sample of series.samples) {
+			const snapshot = sample.processes[0];
+			if (snapshot === void 0) continue;
+			out.push({
+				...snapshot,
+				atMs: sample.atMs
+			});
+		}
+		return out;
+	}
+};
+/**
+* Merge the two tiers and reduce, oldest-first.
+*
+* Dedupe is on `atMs` with the HOT copy winning, exactly as the process reader
+* does: the ring holds the reading as it arrived, the table holds it after the
+* MiB encode.
+*
+* Reduction keeps, for each bucket, the reading with the largest
+* `currentBytes` — WHOLE, every field from that one sample. A per-field
+* maximum would synthesise a row whose parts never coexisted (an `anon` peak
+* and a `file` peak minutes apart, summed into a total that never happened),
+* and a mean would smear away the spike this series exists to find. `atMs`
+* becomes the bucket START so the points lie on the same x-axis as the folded
+* process series, which is the only reason both travel in one answer.
+*
+* An empty bucket stays ABSENT — never zero, never carried forward.
+*/
+function reduceContainerMemory(points, bucketMs, origin) {
+	if (bucketMs <= 0 || points.length === 0) return points;
+	const buckets = /* @__PURE__ */ new Map();
+	for (const point of points) {
+		const start = origin + Math.floor((point.atMs - origin) / bucketMs) * bucketMs;
+		const held = buckets.get(start);
+		if (held === void 0 || point.currentBytes > held.currentBytes) buckets.set(start, {
+			...point,
+			atMs: start
 		});
-	});
+	}
+	return [...buckets.values()].toSorted((a, b) => a.atMs - b.atMs);
+}
+/** Merge cold + hot on `atMs`, hot wins. Exported because dedup is the
+*  property worth testing on its own. */
+function mergeContainerMemory(cold, hot) {
+	const byAt = /* @__PURE__ */ new Map();
+	for (const point of cold) byAt.set(point.atMs, point);
+	for (const point of hot) byAt.set(point.atMs, point);
+	return [...byAt.values()].toSorted((a, b) => a.atMs - b.atMs);
 }
 /**
-* One node's fixed-capacity circular buffer of samples.
+* The COLD tier. Append-only, bounded, and never the authority on anything the
+* hot ring can answer.
 *
-* Mirrors {@link LogRingBuffer}: write at `head`, wrap, and once full every
-* accepted sample evicts the oldest. `rows` is carried alongside so the fleet
-* budget never has to walk the samples to know what a partition costs.
+* Every method is best-effort and says so in the log rather than throwing at
+* the emitter: a storage hiccup must cost a gap in a chart, never a dropped
+* snapshot on the bus.
 */
-var LoadPartition = class {
-	capacity;
-	slots;
-	head = 0;
-	count = 0;
-	rows = 0;
-	/** Newest retained sample's timestamp — the monotonic gate for `push`. */
-	newestAtMs = null;
-	constructor(capacity) {
-		this.capacity = capacity;
-		this.slots = Array.from({ length: capacity });
+var ContainerMemoryStore = class {
+	declared = false;
+	store;
+	logger;
+	nowFn;
+	prunePageRows;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+		this.nowFn = deps.now ?? (() => Date.now());
+		this.prunePageRows = deps.prunePageRows ?? 2e4;
+	}
+	/** Idempotently declare the collection. `false` when the store refused. */
+	async declare() {
+		if (this.declared) return true;
+		try {
+			await this.store.declareCollection.mutate({
+				collection: CONTAINER_MEMORY_COLLECTION,
+				columns: [...CONTAINER_MEMORY_COLUMNS],
+				indexes: CONTAINER_MEMORY_INDEXES.map((i) => ({
+					name: i.name,
+					columns: [...i.columns]
+				}))
+			});
+			this.declared = true;
+			return true;
+		} catch (err) {
+			this.logger.warn("container memory declareCollection failed — nothing will be retained on disk", { meta: {
+				collection: CONTAINER_MEMORY_COLLECTION,
+				error: errMsg(err)
+			} });
+			return false;
+		}
+	}
+	/** Append ONE reading. */
+	async append(nodeId, atMs, snapshot) {
+		if (!await this.declare()) return 0;
+		const record = { ...snapshotToRow(nodeId, atMs, snapshot) };
+		try {
+			const { inserted } = await this.store.insertMany.mutate({
+				collection: CONTAINER_MEMORY_COLLECTION,
+				records: [{ data: record }]
+			});
+			return inserted;
+		} catch (err) {
+			this.logger.warn("container memory reading not retained — this interval will be missing", { meta: {
+				nodeId,
+				atMs,
+				error: errMsg(err)
+			} });
+			return 0;
+		}
+	}
+	/** Read one node's cold readings, oldest-first. `sinceMs` is EXCLUSIVE. */
+	async read(nodeId, sinceMs, limitRows) {
+		if (!await this.declare()) return [];
+		try {
+			const records = await this.store.query.query({
+				collection: CONTAINER_MEMORY_COLLECTION,
+				filter: {
+					where: { nodeId },
+					whereBetween: { atMs: [sinceMs + 1, Number.MAX_SAFE_INTEGER] },
+					orderBy: {
+						field: "atMs",
+						direction: "asc"
+					},
+					limit: limitRows
+				}
+			});
+			const points = [];
+			for (const record of records) {
+				const row = recordToMemoryRow(record.data);
+				if (row === null) continue;
+				const point = rowToPoint(row);
+				if (point !== null) points.push(point);
+			}
+			return points;
+		} catch (err) {
+			this.logger.warn("container memory cold read failed — answering from the hot window only", { meta: {
+				nodeId,
+				sinceMs,
+				error: errMsg(err)
+			} });
+			return [];
+		}
 	}
 	/**
-	* Accept a sample.
-	*
-	* A sample at or before the newest one already held is REFUSED. The bus drops
-	* a node's own broadcast echo, but a cross-node redelivery or a replayed
-	* subscription must not be able to double a point — and idempotence here is
-	* what lets every reader above treat the series as a set.
+	* Enforce BOTH bounds, oldest-first, through a bounded page each.
 	*
-	* `accepted` is reported separately from `rowDelta` on purpose: a full ring
-	* that evicts a sample of the same size has a delta of zero and is not a
-	* refusal, and conflating the two would silently stop advancing the write
-	* ordinal on a steady-state cluster.
+	* Not rate-limited here: it is driven by the process store's own prune
+	* cadence, so it runs at most once a minute by construction and a second
+	* timer would be a second thing to get wrong.
 	*/
-	push(sample) {
-		if (this.newestAtMs !== null && sample.atMs <= this.newestAtMs) return {
-			accepted: false,
-			rowDelta: 0
-		};
-		const evicted = this.count === this.capacity ? this.slots[this.head]?.processes.length ?? 0 : 0;
-		this.slots[this.head] = sample;
-		this.head = (this.head + 1) % this.capacity;
-		if (this.count < this.capacity) this.count++;
-		this.newestAtMs = sample.atMs;
-		const rowDelta = sample.processes.length - evicted;
-		this.rows += rowDelta;
+	async prune(nodeIds, retention) {
+		if (!await this.declare()) return null;
+		const ageCutoff = this.nowFn() - retention.retentionHours * 36e5;
+		let deletedByAge = 0;
+		let rowsExamined = 0;
+		for (const nodeId of nodeIds) {
+			const outcome = await this.deleteOldestPage(nodeId, ageCutoff, this.prunePageRows);
+			deletedByAge += outcome.deleted;
+			rowsExamined += outcome.examined;
+		}
+		const total = await this.count();
+		const excess = total === null ? 0 : total - CONTAINER_MEMORY_MAX_ROWS;
+		let deletedByCap = 0;
+		if (excess > 0) {
+			let remaining = Math.min(excess, this.prunePageRows);
+			for (const nodeId of nodeIds) {
+				if (remaining <= 0) break;
+				const outcome = await this.deleteOldestPage(nodeId, null, remaining);
+				deletedByCap += outcome.deleted;
+				remaining -= outcome.deleted;
+				rowsExamined += outcome.examined;
+			}
+			this.logger.warn("container memory ROW CAP bit — evicting the oldest readings", { meta: {
+				collection: CONTAINER_MEMORY_COLLECTION,
+				rows: total,
+				cap: CONTAINER_MEMORY_MAX_ROWS,
+				over: excess,
+				deleted: deletedByCap,
+				hint: "lower the retention or the sampling cadence — the cap is the guarantee, not the intention"
+			} });
+		}
 		return {
-			accepted: true,
-			rowDelta
+			deletedByAge,
+			deletedByCap,
+			rowsExamined,
+			capBit: excess > 0
 		};
 	}
-	/** Drop the oldest sample. Returns the rows reclaimed (0 when empty). */
-	dropOldest() {
-		if (this.count === 0) return 0;
-		const index = (this.head - this.count + this.capacity) % this.capacity;
-		const victim = this.slots[index];
-		this.slots[index] = void 0;
-		this.count--;
-		const reclaimed = victim?.processes.length ?? 0;
-		this.rows -= reclaimed;
-		if (this.count === 0) this.newestAtMs = null;
-		return reclaimed;
-	}
-	/** Oldest-first, optionally only what is strictly newer than `sinceMs`. */
-	list(sinceMs) {
-		const out = [];
-		for (let i = 0; i < this.count; i++) {
-			const index = (this.head - this.count + i + this.capacity) % this.capacity;
-			const sample = this.slots[index];
-			if (sample === void 0) continue;
-			if (sinceMs !== void 0 && sample.atMs <= sinceMs) continue;
-			out.push(sample);
+	/** Total rows, or `null` when the store could not answer. */
+	async count() {
+		if (!await this.declare()) return null;
+		try {
+			return await this.store.count.query({ collection: CONTAINER_MEMORY_COLLECTION });
+		} catch (err) {
+			this.logger.warn("container memory count failed — the row cap is not enforced this pass", { meta: { error: errMsg(err) } });
+			return null;
 		}
-		return out;
-	}
-	size() {
-		return this.count;
-	}
-	rowCount() {
-		return this.rows;
-	}
-	oldestAtMs() {
-		if (this.count === 0) return null;
-		const index = (this.head - this.count + this.capacity) % this.capacity;
-		return this.slots[index]?.atMs ?? null;
-	}
-	lastWriteAtMs() {
-		return this.newestAtMs;
 	}
-};
-/**
-* The partitioned ring: one {@link LoadPartition} per node id.
-*
-* Three bounds, doing three different jobs — the same division as the log
-* buffer, for the same reason:
-*
-* - **`samplesPerNode`** is HARD and per partition. It is what the operator
-*   asked for (an hour) and it can never be exceeded.
-* - **`maxTotalProcessRows`** is the FLEET budget, and it is denominated in the
-*   thing memory is proportional to. When it bites, the oldest sample of the
-*   HEAVIEST partition is dropped — the node creating the pressure is the node
-*   that pays, and a quiet node keeps its full hour. The node just written to is
-*   NOT protected here: if it is the heaviest, it is the culprit.
-* - **`maxNodes`** is the backstop against an unbounded key space, and it drops
-*   whole partitions least-recently-written first, never the one being written.
-*
-* Plus {@link DEFAULT_NODE_IDLE_EVICTION_MS}, which is what stops a node that
-* simply stopped emitting from living in memory forever.
-*/
-var NodeLoadRing = class {
-	partitions = /* @__PURE__ */ new Map();
 	/**
-	* Node id → write ordinal of its last accepted sample. A monotonic counter,
-	* not a clock: partition eviction must follow the order writes actually
-	* happened, and node clocks disagree.
+	* Delete this node's oldest rows, at most one page's worth.
+	*
+	* `cutoff === null` means "the oldest rows, whatever their age" — the
+	* row-cap path, which is bounded by `limitRows` instead. Either way the page
+	* is READ FIRST, ordered by the one index, and its last `atMs` becomes the
+	* effective cutoff for a single bounded delete. An unbounded `deleteWhere`
+	* would be one statement and one stalling transaction the first time a
+	* retention is lowered.
 	*/
-	lastWriteSeq = /* @__PURE__ */ new Map();
-	writeSeq = 0;
-	totalRows = 0;
-	samplesPerNode;
-	maxTotalProcessRows;
-	maxNodes;
-	idleEvictionMs;
-	now;
-	constructor(options = {}) {
-		this.samplesPerNode = options.samplesPerNode ?? 180;
-		this.maxTotalProcessRows = options.maxTotalProcessRows ?? 32e3;
-		this.maxNodes = options.maxNodes ?? 16;
-		this.idleEvictionMs = options.idleEvictionMs ?? 36e5;
-		this.now = options.now ?? Date.now;
+	async deleteOldestPage(nodeId, cutoff, limitRows) {
+		if (limitRows <= 0) return {
+			deleted: 0,
+			examined: 0
+		};
+		try {
+			const page = await this.store.query.query({
+				collection: CONTAINER_MEMORY_COLLECTION,
+				filter: {
+					where: { nodeId },
+					...cutoff === null ? {} : { whereBetween: { atMs: [0, cutoff] } },
+					orderBy: {
+						field: "atMs",
+						direction: "asc"
+					},
+					limit: Math.min(limitRows, this.prunePageRows)
+				},
+				columns: ["atMs"]
+			});
+			if (page.length === 0) return {
+				deleted: 0,
+				examined: 0
+			};
+			const effectiveCutoff = Number(page.at(-1)?.data["atMs"]);
+			if (!Number.isFinite(effectiveCutoff)) return {
+				deleted: 0,
+				examined: page.length
+			};
+			const { deleted } = await this.store.deleteWhere.mutate({
+				collection: CONTAINER_MEMORY_COLLECTION,
+				filter: {
+					where: { nodeId },
+					whereBetween: { atMs: [0, effectiveCutoff] }
+				}
+			});
+			return {
+				deleted,
+				examined: page.length
+			};
+		} catch (err) {
+			this.logger.warn("container memory prune failed — the table keeps growing this pass", { meta: {
+				nodeId,
+				cutoff,
+				error: errMsg(err)
+			} });
+			return {
+				deleted: 0,
+				examined: 0
+			};
+		}
+	}
+};
+//#endregion
+//#region src/builtins/native-metrics/native-metrics-provider.ts
+var IS_DARWIN = os.platform() === "darwin";
+var IS_LINUX = os.platform() === "linux";
+var NativeMetricsProvider = class {
+	id = "native";
+	cachedSnapshot = null;
+	samplingTimer = null;
+	macMemTimer = null;
+	prevCpu;
+	diagnostics = null;
+	consecutiveSampleErrors = 0;
+	constructor() {
+		this.prevCpu = aggregateCpuTimes();
 	}
 	/**
-	* Retain one snapshot. `processes` is stored by reference — the payload is
-	* already an immutable arrival off the bus, and copying it would double the
-	* measured cost for nothing.
-	*
-	* Returns whether the sample was ACCEPTED — that is, whether it was new
-	* rather than a replay of a timestamp this node has already delivered.
-	*
-	* The return value is not diagnostics. It is the idempotence gate the
-	* DURABLE tier rides on (`load-series-store.ts`): only an accepted sample is
-	* appended to the table, which is what lets that table carry an `INTEGER`
-	* rowid key instead of a composite unique index over two million rows. The
-	* gate is one monotonic comparison in memory; the index it replaces was
-	* measured at ~40 bytes per row.
+	* Optional diagnostics sink for sampling errors. The first failure and
+	* every Nth failure thereafter are reported so a permanently-broken
+	* collector doesn't spam logs but is still observable.
 	*/
-	record(nodeId, atMs, processes) {
-		if (nodeId.length === 0) return false;
-		this.sweepIdle();
-		let partition = this.partitions.get(nodeId);
-		if (partition === void 0) {
-			partition = new LoadPartition(this.samplesPerNode);
-			this.partitions.set(nodeId, partition);
+	setDiagnostics(diag) {
+		this.diagnostics = diag;
+	}
+	startSampling(intervalMs) {
+		if (IS_DARWIN) {
+			sampleMacMemory(this);
+			this.macMemTimer = setInterval(() => sampleMacMemory(this), 5e3);
+			if (this.macMemTimer.unref) this.macMemTimer.unref();
 		}
-		const outcome = partition.push({
-			atMs,
-			processes
+		this.collectSnapshot().then((s) => {
+			this.cachedSnapshot = s;
+			this.consecutiveSampleErrors = 0;
+		}).catch((err) => this.reportSampleError(err));
+		this.samplingTimer = setInterval(() => {
+			this.collectSnapshot().then((s) => {
+				this.cachedSnapshot = s;
+				this.consecutiveSampleErrors = 0;
+			}).catch((err) => this.reportSampleError(err));
+		}, intervalMs);
+		if (this.samplingTimer.unref) this.samplingTimer.unref();
+	}
+	reportSampleError(err) {
+		this.consecutiveSampleErrors++;
+		if (!this.diagnostics) return;
+		if (!(this.consecutiveSampleErrors === 1 || this.consecutiveSampleErrors % 60 === 0)) return;
+		this.diagnostics.warn("metrics-provider sample failed", {
+			consecutiveErrors: this.consecutiveSampleErrors,
+			error: err instanceof Error ? err.message : String(err)
 		});
-		if (!outcome.accepted) {
-			if (partition.size() === 0) this.partitions.delete(nodeId);
-			return false;
+	}
+	stopSampling() {
+		if (this.samplingTimer) {
+			clearInterval(this.samplingTimer);
+			this.samplingTimer = null;
+		}
+		if (this.macMemTimer) {
+			clearInterval(this.macMemTimer);
+			this.macMemTimer = null;
 		}
-		this.totalRows += outcome.rowDelta;
-		this.lastWriteSeq.set(nodeId, ++this.writeSeq);
-		if (this.partitions.size > this.maxNodes) this.evictPartitions(this.partitions.size - this.maxNodes, nodeId);
-		this.enforceRowBudget();
-		return true;
 	}
-	/**
-	* Read one node's retained series, oldest-first.
-	*
-	* `sinceMs` is EXCLUSIVE: a caller passes the newest timestamp it already
-	* holds and gets back only what it is missing. That is the whole contract
-	* that lets the admin UI seed from here and then continue live without
-	* doubling a point it already drew.
-	*
-	* A node nobody has recorded answers with an empty series, not an error —
-	* unknown is the truth about a node that has not reported.
-	*/
-	read(nodeId, sinceMs) {
-		this.sweepIdle();
-		const partition = this.partitions.get(nodeId);
-		if (partition === void 0) return {
-			nodeId,
-			samples: [],
-			retainedSamples: 0,
-			oldestAtMs: null,
-			capacity: this.samplesPerNode
+	async collectSnapshot() {
+		const cpu = this.sampleCpu();
+		const memory = this.getMemoryInfo();
+		const processInfo = getProcessResources();
+		const [gpu, network, disk, cpuTemp] = await Promise.all([
+			getGpuInfoInternal().catch(() => null),
+			takeNetworkIoSnapshot(),
+			takeDiskIoSnapshot(),
+			getCpuTemperatureInternal().catch(() => null)
+		]);
+		const snapshot = {
+			cpu,
+			memory,
+			gpu,
+			network,
+			disk,
+			pressure: {
+				cpu: getPressure("cpu"),
+				memory: getPressure("memory"),
+				io: getPressure("io")
+			},
+			process: processInfo,
+			cpuTemperature: cpuTemp,
+			timestampMs: Date.now()
 		};
+		this.cachedSnapshot = snapshot;
+		return snapshot;
+	}
+	async getCached() {
+		return this.cachedSnapshot;
+	}
+	async getCurrent() {
+		const s = this.cachedSnapshot ?? await this.collectSnapshot();
+		const mb = (bytes) => Math.round(bytes / 1024 / 1024);
 		return {
-			nodeId,
-			samples: partition.list(sinceMs),
-			retainedSamples: partition.size(),
-			oldestAtMs: partition.oldestAtMs(),
-			capacity: this.samplesPerNode
+			cpuPercent: s.cpu.total,
+			memoryPercent: s.memory.percent,
+			memoryUsedMB: mb(s.memory.usedBytes),
+			memoryTotalMB: mb(s.memory.totalBytes),
+			temperature: s.cpuTemperature ?? void 0,
+			gpuPercent: s.gpu?.utilization,
+			gpuMemoryPercent: s.gpu && s.gpu.memoryTotalBytes > 0 ? Math.round(s.gpu.memoryUsedBytes / s.gpu.memoryTotalBytes * 1e3) / 10 : void 0
 		};
 	}
-	/** Node ids with a live partition. Observability for the fleet bound. */
-	nodeIds() {
-		return [...this.partitions.keys()];
+	async getDiskSpace(input) {
+		return getDiskSpaceInternal(input.dirPath);
 	}
-	/** Process rows retained across every partition — the number that IS memory. */
-	rowCount() {
-		return this.totalRows;
+	async getGpuInfo() {
+		return getGpuInfoInternal();
 	}
-	/** Samples retained across every partition. */
-	sampleCount() {
-		let total = 0;
-		for (const partition of this.partitions.values()) total += partition.size();
-		return total;
+	async getCpuTemperature() {
+		return getCpuTemperatureInternal();
 	}
-	/**
-	* Drop partitions whose newest sample is older than the retention window.
-	*
-	* Lazy, on write and on read — never a timer. A timer would be a new
-	* periodic cost in a subsystem whose entire premise is that it adds none,
-	* and a ring that nobody writes to and nobody reads is not growing either.
-	*/
-	sweepIdle() {
-		const cutoff = this.now() - this.idleEvictionMs;
-		for (const [nodeId, partition] of [...this.partitions.entries()]) {
-			const lastWrite = partition.lastWriteAtMs();
-			if (lastWrite !== null && lastWrite > cutoff) continue;
-			this.dropPartition(nodeId);
+	async getProcessStats(input) {
+		const { getPidStats } = await import("../../resource-monitor-BWmQ5i-o.mjs").then((n) => n.r);
+		const raw = await getPidStats(input.pids);
+		const result = [];
+		for (const [pid, s] of raw) result.push({
+			pid,
+			cpu: s.cpu,
+			memory: s.memory,
+			privateBytes: s.privateBytes,
+			sharedBytes: s.sharedBytes
+		});
+		return result;
+	}
+	sampleCpu() {
+		const curr = aggregateCpuTimes();
+		const prev = this.prevCpu;
+		this.prevCpu = curr;
+		const dUser = curr.user - prev.user;
+		const dNice = curr.nice - prev.nice;
+		const dSys = curr.sys - prev.sys;
+		const dIrq = curr.irq - prev.irq;
+		const dIdle = curr.idle - prev.idle;
+		const dTotal = dUser + dNice + dSys + dIrq + dIdle;
+		const pct = (v) => dTotal === 0 ? 0 : Math.round(v / dTotal * 1e3) / 10;
+		return {
+			total: pct(dUser + dNice + dSys + dIrq),
+			user: pct(dUser),
+			system: pct(dSys),
+			irq: pct(dIrq),
+			nice: pct(dNice),
+			loadAvg: os.loadavg(),
+			cores: os.cpus().length
+		};
+	}
+	/** Cached macOS memory (set by sampleMacMemory timer). */
+	_cachedMacMem = null;
+	getMemoryInfo() {
+		const total = os.totalmem();
+		if (total === 0) return {
+			percent: 0,
+			totalBytes: 0,
+			usedBytes: 0,
+			availableBytes: 0,
+			swapUsedBytes: 0,
+			swapTotalBytes: 0
+		};
+		if (IS_DARWIN && this._cachedMacMem !== null) return this._cachedMacMem;
+		const free = os.freemem();
+		const used = total - free;
+		let swapUsedBytes = 0;
+		let swapTotalBytes = 0;
+		if (IS_LINUX) try {
+			const meminfo = fs.readFileSync("/proc/meminfo", "utf-8");
+			const swapTotal = parseInt(meminfo.match(/SwapTotal:\s+(\d+)/)?.[1] ?? "0", 10) * 1024;
+			const swapFree = parseInt(meminfo.match(/SwapFree:\s+(\d+)/)?.[1] ?? "0", 10) * 1024;
+			swapTotalBytes = swapTotal;
+			swapUsedBytes = swapTotal - swapFree;
+		} catch {}
+		return {
+			percent: Math.round((total - free) / total * 1e3) / 10,
+			totalBytes: total,
+			usedBytes: used,
+			availableBytes: free,
+			swapUsedBytes,
+			swapTotalBytes
+		};
+	}
+};
+function aggregateCpuTimes() {
+	const cpus = os.cpus();
+	let user = 0, nice = 0, sys = 0, irq = 0, idle = 0;
+	for (const cpu of cpus) {
+		user += cpu.times.user;
+		nice += cpu.times.nice;
+		sys += cpu.times.sys;
+		irq += cpu.times.irq;
+		idle += cpu.times.idle;
+	}
+	return {
+		user,
+		nice,
+		sys,
+		irq,
+		idle
+	};
+}
+function sampleMacMemory(provider) {
+	try {
+		const output = execFileSync("vm_stat", {
+			timeout: 2e3,
+			encoding: "utf-8"
+		});
+		const pageSize = 16384;
+		const parse = (label) => {
+			const match = output.match(new RegExp(`${label}:\\s+(\\d+)`));
+			return match ? parseInt(match[1], 10) * pageSize : 0;
+		};
+		const free = parse("Pages free");
+		const inactive = parse("Pages inactive");
+		const purgeable = parse("Pages purgeable");
+		const speculative = parse("Pages speculative");
+		const available = free + inactive + purgeable + speculative;
+		const total = os.totalmem();
+		const used = total - available;
+		let swapUsedBytes = 0;
+		let swapTotalBytes = 0;
+		try {
+			const swapOut = execFileSync("sysctl", ["-n", "vm.swapusage"], {
+				timeout: 2e3,
+				encoding: "utf-8"
+			});
+			const totalMatch = swapOut.match(/total\s*=\s*([\d.]+)M/);
+			const usedMatch = swapOut.match(/used\s*=\s*([\d.]+)M/);
+			if (totalMatch) swapTotalBytes = parseFloat(totalMatch[1]) * 1024 * 1024;
+			if (usedMatch) swapUsedBytes = parseFloat(usedMatch[1]) * 1024 * 1024;
+		} catch {}
+		provider._cachedMacMem = {
+			percent: Math.round(used / total * 1e3) / 10,
+			totalBytes: total,
+			usedBytes: used,
+			availableBytes: available,
+			swapUsedBytes,
+			swapTotalBytes
+		};
+	} catch {
+		provider._cachedMacMem = null;
+	}
+}
+function getDiskSpaceInternal(dirPath) {
+	return new Promise((resolve, reject) => {
+		fs.statfs(dirPath, (err, stats) => {
+			if (err) return reject(err);
+			const totalBytes = stats.blocks * stats.bsize;
+			const availableBytes = stats.bavail * stats.bsize;
+			const usedBytes = totalBytes - stats.bfree * stats.bsize;
+			resolve({
+				path: dirPath,
+				totalBytes,
+				usedBytes,
+				availableBytes,
+				percent: totalBytes > 0 ? Math.round(usedBytes / totalBytes * 1e3) / 10 : 0
+			});
+		});
+	});
+}
+async function takeDiskIoSnapshot() {
+	const now = Date.now();
+	if (IS_LINUX) try {
+		const data = fs.readFileSync("/proc/diskstats", "utf-8");
+		let readOps = 0, readBytes = 0, writeOps = 0, writeBytes = 0;
+		for (const line of data.split("\n")) {
+			const parts = line.trim().split(/\s+/);
+			if (parts.length < 14) continue;
+			const devName = parts[2];
+			if (/\d+$/.test(devName) && !/^nvme\d+n\d+$/.test(devName)) continue;
+			readOps += parseInt(parts[3], 10) || 0;
+			readBytes += (parseInt(parts[5], 10) || 0) * 512;
+			writeOps += parseInt(parts[7], 10) || 0;
+			writeBytes += (parseInt(parts[9], 10) || 0) * 512;
 		}
-	}
-	/**
-	* Bring the fleet back under the row budget by dropping the OLDEST sample of
-	* the HEAVIEST partition, repeatedly.
-	*
-	* Terminates: every iteration removes one sample from a non-empty partition,
-	* and the population of samples is finite and strictly decreasing.
-	*/
-	enforceRowBudget() {
-		while (this.totalRows > this.maxTotalProcessRows) {
-			const victim = this.heaviestPartition();
-			if (victim === null) return;
-			const [nodeId, partition] = victim;
-			this.totalRows -= partition.dropOldest();
-			if (partition.size() === 0) this.dropPartition(nodeId);
+		return {
+			readBytes,
+			writeBytes,
+			readOps,
+			writeOps,
+			timestampMs: now
+		};
+	} catch {}
+	return {
+		readBytes: 0,
+		writeBytes: 0,
+		readOps: 0,
+		writeOps: 0,
+		timestampMs: now
+	};
+}
+async function takeNetworkIoSnapshot() {
+	const now = Date.now();
+	if (IS_LINUX) try {
+		const data = fs.readFileSync("/proc/net/dev", "utf-8");
+		let rxBytes = 0, txBytes = 0, rxPackets = 0, txPackets = 0, rxErrors = 0, txErrors = 0;
+		for (const line of data.split("\n")) {
+			const match = line.match(/^\s*(\w+):\s+(.+)$/);
+			if (!match) continue;
+			if (match[1] === "lo") continue;
+			const cols = match[2].trim().split(/\s+/);
+			rxBytes += parseInt(cols[0], 10) || 0;
+			rxPackets += parseInt(cols[1], 10) || 0;
+			rxErrors += parseInt(cols[2], 10) || 0;
+			txBytes += parseInt(cols[8], 10) || 0;
+			txPackets += parseInt(cols[9], 10) || 0;
+			txErrors += parseInt(cols[10], 10) || 0;
 		}
-	}
-	heaviestPartition() {
-		let best = null;
-		for (const entry of this.partitions.entries()) {
-			if (entry[1].size() === 0) continue;
-			if (best === null || entry[1].rowCount() > best[1].rowCount()) best = entry;
+		return {
+			rxBytes,
+			txBytes,
+			rxPackets,
+			txPackets,
+			rxErrors,
+			txErrors,
+			timestampMs: now
+		};
+	} catch {}
+	if (IS_DARWIN) try {
+		const stdout = await execAsync("netstat", ["-ib"]);
+		let rxBytes = 0, txBytes = 0, rxPackets = 0, txPackets = 0, rxErrors = 0, txErrors = 0;
+		for (const line of stdout.split("\n")) {
+			const parts = line.trim().split(/\s+/);
+			if (parts.length < 11) continue;
+			if (parts[0] === "lo0" || parts[0] === "Name") continue;
+			if (!parts[2]?.startsWith("Link#")) continue;
+			rxPackets += parseInt(parts[4], 10) || 0;
+			rxErrors += parseInt(parts[5], 10) || 0;
+			rxBytes += parseInt(parts[6], 10) || 0;
+			txPackets += parseInt(parts[7], 10) || 0;
+			txErrors += parseInt(parts[8], 10) || 0;
+			txBytes += parseInt(parts[9], 10) || 0;
 		}
-		return best;
+		return {
+			rxBytes,
+			txBytes,
+			rxPackets,
+			txPackets,
+			rxErrors,
+			txErrors,
+			timestampMs: now
+		};
+	} catch {}
+	return {
+		rxBytes: 0,
+		txBytes: 0,
+		rxPackets: 0,
+		txPackets: 0,
+		rxErrors: 0,
+		txErrors: 0,
+		timestampMs: now
+	};
+}
+async function getCpuTemperatureInternal() {
+	if (IS_LINUX) for (const p of ["/sys/class/thermal/thermal_zone0/temp", "/sys/class/hwmon/hwmon0/temp1_input"]) try {
+		const raw = fs.readFileSync(p, "utf-8").trim();
+		const millideg = parseInt(raw, 10);
+		if (!isNaN(millideg)) return Math.round(millideg / 100) / 10;
+	} catch {
+		continue;
 	}
-	/** Drop `count` whole partitions, least-recently-written first. */
-	evictPartitions(count, protectedNodeId) {
-		const order = [...this.partitions.keys()].filter((nodeId) => nodeId !== protectedNodeId).toSorted((a, b) => (this.lastWriteSeq.get(a) ?? 0) - (this.lastWriteSeq.get(b) ?? 0));
-		let remaining = count;
-		for (const nodeId of order) {
-			if (remaining <= 0) return;
-			this.dropPartition(nodeId);
-			remaining -= 1;
-		}
+	if (IS_DARWIN) try {
+		const match = (await execAsync("sudo", [
+			"-n",
+			"powermetrics",
+			"--samplers",
+			"smc",
+			"-i",
+			"1",
+			"-n",
+			"1"
+		], 3e3)).match(/CPU die temperature:\s+([\d.]+)\s*C/);
+		if (match) return Math.round(parseFloat(match[1]) * 10) / 10;
+	} catch {}
+	return null;
+}
+async function getGpuInfoInternal() {
+	if (IS_DARWIN) try {
+		const utilMatch = (await execAsync("ioreg", [
+			"-r",
+			"-d",
+			"1",
+			"-c",
+			"IOAccelerator"
+		])).match(/"GPU Core Utilization"\s*=\s*(\d+)/);
+		const util = utilMatch ? parseInt(utilMatch[1], 10) : 0;
+		const utilPct = util > 1e3 ? Math.round(util / 1e7) : util;
+		return {
+			utilization: Math.min(100, utilPct),
+			model: "Apple Silicon GPU",
+			memoryUsedBytes: 0,
+			memoryTotalBytes: 0,
+			temperature: null
+		};
+	} catch {}
+	if (IS_LINUX) try {
+		const parts = (await execAsync("nvidia-smi", ["--query-gpu=utilization.gpu,name,memory.used,memory.total,temperature.gpu", "--format=csv,noheader,nounits"])).trim().split(",").map((s) => s.trim());
+		if (parts.length >= 5) return {
+			utilization: parseInt(parts[0], 10) || 0,
+			model: parts[1] ?? "Unknown GPU",
+			memoryUsedBytes: (parseInt(parts[2], 10) || 0) * 1024 * 1024,
+			memoryTotalBytes: (parseInt(parts[3], 10) || 0) * 1024 * 1024,
+			temperature: parseInt(parts[4], 10) || null
+		};
+	} catch {}
+	return null;
+}
+function getProcessResources() {
+	let openFds = 0;
+	let threadCount = 0;
+	if (IS_LINUX) {
+		try {
+			openFds = fs.readdirSync(`/proc/${process.pid}/fd`).length;
+		} catch {}
+		try {
+			const match = fs.readFileSync(`/proc/${process.pid}/status`, "utf-8").match(/Threads:\s+(\d+)/);
+			if (match) threadCount = parseInt(match[1], 10);
+		} catch {}
 	}
-	/** Remove a partition and everything that indexes it. */
-	dropPartition(nodeId) {
-		const partition = this.partitions.get(nodeId);
-		if (partition === void 0) return;
-		this.totalRows -= partition.rowCount();
-		this.partitions.delete(nodeId);
-		this.lastWriteSeq.delete(nodeId);
+	const nodeProcess = process;
+	return {
+		openFds,
+		threadCount,
+		activeHandles: (nodeProcess._getActiveHandles?.() ?? []).length,
+		activeRequests: (nodeProcess._getActiveRequests?.() ?? []).length
+	};
+}
+function getPressure(resource) {
+	if (!IS_LINUX) return null;
+	try {
+		const data = fs.readFileSync(`/proc/pressure/${resource}`, "utf-8");
+		const parseLine = (prefix) => {
+			const match = data.match(new RegExp(`${prefix} avg10=(\\d+\\.\\d+) avg60=(\\d+\\.\\d+) avg300=(\\d+\\.\\d+)`));
+			if (!match) return null;
+			return {
+				avg10: parseFloat(match[1]),
+				avg60: parseFloat(match[2]),
+				avg300: parseFloat(match[3])
+			};
+		};
+		const some = parseLine("some");
+		if (!some) return null;
+		return {
+			some,
+			full: parseLine("full")
+		};
+	} catch {
+		return null;
 	}
-};
+}
+function execAsync(cmd, args, timeoutMs = 5e3) {
+	return new Promise((resolve, reject) => {
+		execFile(cmd, args, { timeout: timeoutMs }, (err, stdout) => {
+			if (err) return reject(err);
+			resolve(stdout);
+		});
+	});
+}
 //#endregion
 //#region src/builtins/native-metrics/load-series-store.ts
 /**
@@ -1733,6 +2548,20 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 	* per sample, to reach that very same table.
 	*/
 	loadStore = null;
+	/**
+	* The container's OWN memory, sampled on the process-snapshot tick.
+	*
+	* It rides that tick rather than a timer of its own so a memory reading and
+	* the process rows it must be compared against carry the SAME timestamp —
+	* the whole question is a subtraction, and two clocks make it an estimate.
+	* Constructed in `onInitialize`, where the logger exists; it resolves the
+	* cgroup once and latches.
+	*/
+	memoryProbe = null;
+	/** Hot tier for the container reading. Bounds in `container-memory-series.ts`. */
+	memoryRing = new ContainerMemoryRing();
+	/** Cold tier, HUB only — same reasoning as `loadStore`. */
+	memoryStore = null;
 	/** The resolved knobs. Re-resolved on every settings write. */
 	loadConfig = {
 		cadenceSec: 10,
@@ -1805,13 +2634,20 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 			dumpHeapSnapshot: (params) => this.dumpHeapSnapshot(params)
 		};
 		this.applyLoadSeriesConfig();
-		if (this.isHub) this.loadStore = new LoadSeriesStore({
-			store: this.ctx.api.settingsStore,
-			logger: this.ctx.logger.child("LoadSeries")
-		});
+		if (this.isHub) {
+			this.loadStore = new LoadSeriesStore({
+				store: this.ctx.api.settingsStore,
+				logger: this.ctx.logger.child("LoadSeries")
+			});
+			this.memoryStore = new ContainerMemoryStore({
+				store: this.ctx.api.settingsStore,
+				logger: this.ctx.logger.child("ContainerMemory")
+			});
+		}
+		this.memoryProbe = new ContainerMemoryProbe({ logger: this.ctx.logger.child("ContainerMemory") });
 		this.snapshotTimer = setInterval(() => this.emitResourcesSnapshot(), METRICS_SNAPSHOT_INTERVAL_MS);
 		this.startProcessSnapshotTimer();
-		this.ctx.addDisposer(this.ctx.eventBus.subscribe({ category: EventCategory.MetricsNodeProcessesSnapshot }, (event) => this.retainSnapshot(event.data.nodeId, event.data.timestamp, event.data.processes)));
+		this.ctx.addDisposer(this.ctx.eventBus.subscribe({ category: EventCategory.MetricsNodeProcessesSnapshot }, (event) => this.retainSnapshot(event.data.nodeId, event.data.timestamp, event.data.processes, event.data.containerMemory)));
 		return [{
 			capability: metricsProviderCapability,
 			provider: composed
@@ -1829,19 +2665,31 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 	* The durable append is fire-and-forget: a storage stall must cost a gap in
 	* the cold window, never a blocked event-bus handler. Every failure logs.
 	*/
-	retainSnapshot(nodeId, atMs, processes) {
+	retainSnapshot(nodeId, atMs, processes, containerMemory) {
 		const retained = processes.map((p) => NativeMetricsAddon.toRetained(p));
 		if (!this.loadRing.record(nodeId, atMs, retained)) return;
 		this.observedRowsByNode.set(nodeId, retained.length);
+		if (containerMemory !== null) this.memoryRing.record(nodeId, atMs, containerMemory);
 		const store = this.loadStore;
 		if (store === null) return;
-		store.append(nodeId, atMs, retained).then(() => store.prune([...this.observedRowsByNode.keys()], this.loadConfig)).catch((err) => {
+		store.append(nodeId, atMs, retained).then(() => store.prune([...this.observedRowsByNode.keys()], this.loadConfig)).then(async (outcome) => {
+			if (outcome === null) return;
+			await this.memoryStore?.prune([...this.observedRowsByNode.keys()], this.loadConfig);
+		}).catch((err) => {
 			this.ctx.logger.warn("durable load series write failed", { meta: {
 				nodeId,
 				atMs,
 				error: err instanceof Error ? err.message : String(err)
 			} });
 		});
+		if (containerMemory === null) return;
+		this.memoryStore?.append(nodeId, atMs, containerMemory).catch((err) => {
+			this.ctx.logger.warn("durable container memory write failed", { meta: {
+				nodeId,
+				atMs,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		});
 	}
 	/**
 	* The ONE reader, over both tiers.
@@ -1870,6 +2718,14 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 		return {
 			nodeId: params.forNodeId,
 			series: merged.series,
+			containerMemory: await this.readContainerMemory({
+				forNodeId: params.forNodeId,
+				sinceMs,
+				...params.sinceMs !== void 0 ? { exclusiveSinceMs: params.sinceMs } : {},
+				bucketMs: merged.bucketMs,
+				cadenceMs,
+				origin: merged.oldestAtMs
+			}),
 			bucketMs: merged.bucketMs,
 			retainedSamples: merged.retainedSamples,
 			oldestAtMs: merged.oldestAtMs,
@@ -1878,6 +2734,24 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 		};
 	}
 	/**
+	* The container's memory over the same window, on the same x-axis.
+	*
+	* Both tiers, merged and deduped on `atMs` like the process series, then
+	* reduced against the SAME `bucketMs` and the SAME origin — otherwise the
+	* two series in one answer would sit on two different axes and the
+	* subtraction they exist for would be an eyeball.
+	*
+	* An EMPTY answer means the node has no cgroup, or nothing has been retained
+	* for it yet. It never means zero.
+	*/
+	async readContainerMemory(params) {
+		const hot = this.memoryRing.read(params.forNodeId, params.exclusiveSinceMs);
+		const store = this.memoryStore;
+		const merged = mergeContainerMemory(store === null ? [] : await store.read(params.forNodeId, params.sinceMs, CONTAINER_MEMORY_MAX_ROWS), hot);
+		if (params.bucketMs <= params.cadenceMs) return merged;
+		return reduceContainerMemory(merged, params.bucketMs, params.origin ?? 0);
+	}
+	/**
 	* Re-resolve the knobs and restate the fixed cadence.
 	*
 	* A REFUSED value (out of 5-60 s, or out of 1-72 h) leaves the previous
@@ -1993,6 +2867,7 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 		const timestamp = Date.now();
 		try {
 			const processes = await this.listNodeProcesses();
+			const containerMemory = this.memoryProbe?.sample() ?? null;
 			eventBus.emit(createEvent(EventCategory.MetricsNodeProcessesSnapshot, {
 				type: "node",
 				id: nodeId,
@@ -2000,7 +2875,8 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 			}, {
 				nodeId,
 				processes,
-				timestamp
+				timestamp,
+				containerMemory
 			}));
 		} catch (err) {
 			this.ctx.logger.warn("process snapshot skipped — this interval will be missing", { meta: {