pi-crew 0.9.53 → 0.9.55

package/src/runtime/loop-gates.ts

@@ -0,0 +1,128 @@
+/**
+ * Dual-gate loop control — determines whether a task should auto-resume
+ * based on meaningful progress and turn limits.
+ *
+ * Gate 1: At least one signal of meaningful progress must be true.
+ * Gate 2: The auto-resume turn count must be below the maximum.
+ *
+ * Distilled from pi-autoresearch's dual-gate loop pattern.
+ */
+import * as fs from "node:fs";
+import type { TeamTaskState } from "../state/types.ts";
+
+/**
+ * Signal indicating what kind of progress a task has made.
+ */
+export interface TaskProgressSignal {
+	/** Whether the task has edited files or produced non-empty results. */
+	editedFiles: boolean;
+	/** Whether the task has produced artifacts in the artifacts directory. */
+	producedArtifacts: boolean;
+	/** Whether the task has run tests (detected via result text). */
+	ranTests: boolean;
+}
+
+/**
+ * Runtime state for auto-resume turn tracking.
+ */
+export interface AutoResumeRuntime {
+	/** Current number of auto-resume turns taken. */
+	autoResumeTurns: number;
+	/** Maximum allowed auto-resume turns. */
+	maxTurns: number;
+}
+
+/** Keywords in result text that indicate tests were run. */
+const TEST_KEYWORDS = [
+	"test passed",
+	"test failed",
+	"tests passed",
+	"tests failed",
+	"test results",
+	"jest",
+	"vitest",
+	"mocha",
+	"pytest",
+	"npx test",
+	"npm test",
+	"cargo test",
+	"all tests",
+	"test suite",
+	"✓",
+	"✗",
+	"PASS ",
+	" FAIL ",
+] as const;
+
+/**
+ * Determine whether a task should auto-resume based on dual-gate logic.
+ *
+ * Gate 1 (meaningful progress): at least one of editedFiles, producedArtifacts,
+ *   or ranTests must be true.
+ * Gate 2 (turn limit): autoResumeTurns must be strictly less than maxTurns.
+ *
+ * Both gates must pass for auto-resume to be allowed.
+ */
+export function shouldAutoResume(runtime: AutoResumeRuntime, taskProgress: TaskProgressSignal): boolean {
+	// Gate 2: Turn limit check (check first — cheaper)
+	if (runtime.autoResumeTurns >= runtime.maxTurns) {
+		return false;
+	}
+
+	// Gate 1: Meaningful progress check
+	const hasProgress = taskProgress.editedFiles || taskProgress.producedArtifacts || taskProgress.ranTests;
+	if (!hasProgress) {
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Compute the task progress signal from a task's state and artifacts directory.
+ *
+ * - editedFiles: true if task has artifact files or a non-empty result
+ * - producedArtifacts: true if artifacts directory contains task-specific files
+ * - ranTests: true if result text contains test-related keywords
+ *
+ * @param task - The task state to analyze
+ * @param artifactsDir - Path to the artifacts directory
+ * @returns TaskProgressSignal indicating what progress was made
+ */
+export function computeTaskProgressSignal(task: TeamTaskState, artifactsDir: string): TaskProgressSignal {
+	// editedFiles: check if task has artifact descriptors or a non-empty result
+	const hasResultArtifact = task.resultArtifact !== undefined;
+	const hasNonEmptyResult = task.resultArtifact?.path !== undefined;
+	const editedFiles = hasResultArtifact || hasNonEmptyResult;
+
+	// producedArtifacts: check artifacts directory for task-specific files
+	let producedArtifacts = false;
+	if (artifactsDir && fs.existsSync(artifactsDir)) {
+		try {
+			const entries = fs.readdirSync(artifactsDir);
+			// Look for files/directories that START with the task ID prefix.
+			// Using startsWith instead of includes to avoid false positives
+			// from short task IDs like "01" matching unrelated entries.
+			const taskPrefix = task.id.replace(/[^a-zA-Z0-9_-]/g, "");
+			producedArtifacts = entries.some((entry) => {
+				const baseName = entry.split(".")[0] ?? entry;
+				return baseName.startsWith(taskPrefix);
+			});
+		} catch {
+			producedArtifacts = false;
+		}
+	}
+
+	// ranTests: check if result-related fields contain test keywords
+	let ranTests = false;
+	const textToSearch = [
+		task.error ?? "",
+		task.terminalEvidence ? JSON.stringify(task.terminalEvidence) : "",
+		task.diagnostics ? JSON.stringify(task.diagnostics) : "",
+	].join(" ");
+
+	const lowerText = textToSearch.toLowerCase();
+	ranTests = TEST_KEYWORDS.some((keyword) => lowerText.includes(keyword.toLowerCase()));
+
+	return { editedFiles, producedArtifacts, ranTests };
+}

package/src/runtime/manifest-cache.ts

@@ -0,0 +1,375 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DEFAULT_CACHE, DEFAULT_PATHS } from "../config/defaults.ts";
+import { activeRunEntries } from "../state/active-run-registry.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+import { closeWatcher, watchWithErrorHandler } from "../utils/fs-watch.ts";
+import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
+import { isSafePathId, resolveContainedRelativePath, resolveRealContainedPath } from "../utils/safe-paths.ts";
+
+export interface ManifestCache {
+	list(limit?: number): TeamRunManifest[];
+	/**
+	 * Return ONLY running manifests, capped only by `limit`.
+	 *
+	 * RT-F3: unlike `list(limit)`, this filters `status === "running"` BEFORE
+	 * the limit is applied so stale orphaned runs that have been pushed past
+	 * the top-N by recent activity are not silently hidden from crash-recovery
+	 * and zombie-detection scans.
+	 */
+	listActive(limit: number): TeamRunManifest[];
+	get(runId: string): TeamRunManifest | undefined;
+	clear(runId?: string): void;
+	dispose(): void;
+}
+
+interface CachedManifest {
+	path: string;
+	manifest: TeamRunManifest;
+	mtimeMs: number;
+	size: number;
+	loadedAtMs: number;
+}
+
+interface CachedList {
+	runs: TeamRunManifest[];
+	limit?: number;
+	expireAtMs: number;
+}
+
+export interface ManifestCacheOptions {
+	debounceMs?: number;
+	watch?: boolean;
+	maxEntries?: number;
+}
+
+const DEFAULT_TTL_MS = 500;
+
+interface ParsedEntry {
+	runId: string;
+	path: string;
+	manifest?: TeamRunManifest;
+}
+
+function manifestPathForRun(root: string, runId: string): string | undefined {
+	if (!isSafePathId(runId)) return undefined;
+	try {
+		return path.join(resolveRealContainedPath(root, runId), DEFAULT_PATHS.state.manifestFile);
+	} catch {
+		return undefined;
+	}
+}
+
+function parseManifest(filePath: string): TeamRunManifest | undefined {
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8")) as TeamRunManifest;
+	} catch {
+		return undefined;
+	}
+}
+
+function sameFilesystemPath(left: string, right: string): boolean {
+	if (path.resolve(left) === path.resolve(right)) return true;
+	try {
+		return fs.realpathSync.native(left) === fs.realpathSync.native(right);
+	} catch {
+		return false;
+	}
+}
+
+function validateManifestForRoot(root: string, runId: string, manifest: TeamRunManifest): boolean {
+	try {
+		if (!isSafePathId(runId)) return false;
+		const stateRoot = resolveContainedRelativePath(root, runId, "runId");
+		const crewRoot = path.dirname(path.dirname(root));
+		const artifactsRoot = resolveContainedRelativePath(path.join(crewRoot, DEFAULT_PATHS.state.artifactsSubdir), runId, "runId");
+		if (
+			manifest.runId !== runId ||
+			!sameFilesystemPath(manifest.stateRoot, stateRoot) ||
+			!sameFilesystemPath(manifest.tasksPath, path.join(stateRoot, DEFAULT_PATHS.state.tasksFile)) ||
+			!sameFilesystemPath(manifest.eventsPath, path.join(stateRoot, DEFAULT_PATHS.state.eventsFile)) ||
+			!sameFilesystemPath(manifest.artifactsRoot, artifactsRoot)
+		)
+			return false;
+		if (fs.existsSync(artifactsRoot)) {
+			if (fs.lstatSync(artifactsRoot).isSymbolicLink()) return false;
+			resolveRealContainedPath(path.dirname(artifactsRoot), path.basename(artifactsRoot));
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function parseManifestIfChanged(root: string, runId: string, filePath: string, previous?: CachedManifest): CachedManifest | undefined {
+	let stat: fs.Stats;
+	try {
+		stat = fs.statSync(filePath);
+	} catch {
+		return undefined;
+	}
+	if (previous && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size) {
+		return validateManifestForRoot(root, runId, previous.manifest) ? previous : undefined;
+	}
+	const manifest = parseManifest(filePath);
+	if (!manifest || !validateManifestForRoot(root, runId, manifest)) return undefined;
+	return {
+		path: filePath,
+		manifest,
+		mtimeMs: stat.mtimeMs,
+		size: stat.size,
+		loadedAtMs: Date.now(),
+	};
+}
+
+function listRunRoots(cwd: string): string[] {
+	const roots = new Set<string>();
+	// Always include user-level runs (fast-fix, direct-agent, etc. write here)
+	roots.add(path.join(userCrewRoot(), DEFAULT_PATHS.state.runsSubdir));
+	const projectRoot = findRepoRoot(cwd);
+	if (projectRoot) roots.add(path.join(projectCrewRoot(cwd), DEFAULT_PATHS.state.runsSubdir));
+	return [...roots];
+}
+
+function collectRoots(root: string): ParsedEntry[] {
+	if (!fs.existsSync(root)) return [];
+	let entries: string[];
+	try {
+		entries = fs.readdirSync(root);
+	} catch {
+		return [];
+	}
+	return entries
+		.filter((entry) => entry.length > 0 && isSafePathId(entry))
+		.map((entry) => ({
+			runId: entry,
+			path: manifestPathForRun(root, entry),
+		}))
+		.filter((entry): entry is ParsedEntry => entry.path !== undefined);
+}
+
+export function createManifestCache(cwd: string, options: ManifestCacheOptions = {}): ManifestCache {
+	const ttlMs = options.debounceMs ?? DEFAULT_TTL_MS;
+	const maxEntries = options.maxEntries ?? DEFAULT_CACHE.manifestMaxEntries;
+	const roots = listRunRoots(cwd);
+	const manifestIndex = new Map<string, CachedManifest>();
+	const listCache = new Map<number, CachedList>();
+	let listTimer: ReturnType<typeof setTimeout> | undefined;
+	let watchers: fs.FSWatcher[] = [];
+
+	function invalidate(runId?: string): void {
+		if (runId) {
+			manifestIndex.delete(runId);
+		} else {
+			manifestIndex.clear();
+		}
+		listCache.clear();
+		invalidateListActive();
+	}
+
+	function scheduleListRefresh(): void {
+		if (listTimer) {
+			clearTimeout(listTimer);
+		}
+		listTimer = setTimeout(() => {
+			const timer = listTimer;
+			listTimer = undefined;
+			listCache.clear();
+			invalidateListActive();
+			timer?.unref();
+		}, ttlMs);
+		// Unref immediately so the timer never blocks process exit (defense in
+		// depth: the in-callback unref above may not run if shutdown happens
+		// before the timer fires).
+		listTimer.unref();
+		// FIND-03: invalidate the listActive() cache eagerly on every watcher
+		// tick. The TTL is the fallback for missed events; the watcher-driven
+		// path gives the tightest possible invalidation.
+		invalidateListActive();
+	}
+
+	function loadManifest(runId: string, rootsToCheck: string[]): CachedManifest | undefined {
+		const cached = manifestIndex.get(runId);
+		if (!isSafePathId(runId)) return undefined;
+		const activeEntry = activeRunEntries().find((entry) => entry.runId === runId);
+		if (activeEntry) {
+			const activeRoot = path.dirname(activeEntry.stateRoot);
+			const parsed = parseManifestIfChanged(activeRoot, runId, activeEntry.manifestPath, cached);
+			if (parsed) {
+				manifestIndex.set(runId, parsed);
+				return parsed;
+			}
+		}
+		for (const root of rootsToCheck) {
+			const manifestPath = manifestPathForRun(root, runId);
+			if (!manifestPath) continue;
+			const parsed = parseManifestIfChanged(root, runId, manifestPath, cached);
+			if (parsed) {
+				if (!cached || parsed.mtimeMs !== cached.mtimeMs || parsed.size !== cached.size) {
+					manifestIndex.set(runId, parsed);
+					if (manifestIndex.size > maxEntries) {
+						const oldest = [...manifestIndex.values()].sort((a, b) => a.loadedAtMs - b.loadedAtMs)[0];
+						if (oldest) manifestIndex.delete(oldest.manifest.runId);
+					}
+				}
+				return manifestIndex.get(runId);
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 * NOTE (RT-F10): This function performs a full FS scan + JSON.parse of all
+	 * manifests on every TTL expiry (default 500ms). This is a known performance
+	 * tradeoff: fs.watch provides real-time invalidation (see constructor above)
+	 * so the TTL cache is only consulted when the watcher fires, but the list()
+	 * call itself still re-reads all entries to pick up changes. Incremental
+	 * updates via fs.watch-driven delta tracking are planned for a future
+	 * iteration to avoid the full scan on each expiry.
+	 */
+	function list(limit = DEFAULT_CACHE.manifestMaxEntries): TeamRunManifest[] {
+		const now = Date.now();
+		const cached = listCache.get(limit);
+		if (cached && cached.expireAtMs > now) {
+			return cached.runs;
+		}
+		const parsedEntries = [
+			...roots.flatMap((root) => collectRoots(root)),
+			...activeRunEntries().map((entry) => ({
+				runId: entry.runId,
+				path: entry.manifestPath,
+			})),
+		];
+		const unique = new Map<string, CachedManifest | undefined>();
+		for (const entry of parsedEntries) {
+			if (entry.runId.length === 0) continue;
+			let cached = manifestIndex.get(entry.runId);
+			const root = path.dirname(path.dirname(entry.path));
+			const parsed = parseManifestIfChanged(root, entry.runId, entry.path, cached);
+			if (parsed) {
+				cached = parsed;
+				manifestIndex.set(entry.runId, cached);
+			}
+			if (cached) unique.set(entry.runId, cached);
+		}
+
+		const runs = [...unique.values()].filter((value): value is CachedManifest => value !== undefined).map((value) => value.manifest);
+		const sorted = runs.sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
+		const limited = sorted.slice(0, Math.max(0, limit));
+		if (manifestIndex.size > maxEntries) {
+			const removeCount = manifestIndex.size - maxEntries;
+			const oldest = [...manifestIndex.values()].sort((a, b) => a.loadedAtMs - b.loadedAtMs).slice(0, removeCount);
+			for (const entry of oldest) manifestIndex.delete(entry.manifest.runId);
+		}
+		const result = limited;
+		listCache.set(limit, { runs: result, limit, expireAtMs: now + ttlMs });
+		return result;
+	}
+
+	function get(runId: string): TeamRunManifest | undefined {
+		const cached = loadManifest(runId, roots);
+		if (cached) return cached.manifest;
+		return undefined;
+	}
+
+	// FIND-03: short-TTL cache for listActive(). Mirrors the listCache pattern
+	// used by list(): we cache the un-capped running set and apply the caller's
+	// `limit` post-hoc on every return. Storing the full set (not a
+	// limit-sliced array) is what preserves the RT-F3 contract — callers with
+	// different `limit` values all see the same underlying "every running run"
+	// result, never a top-N createdAt-filtered view.
+	let listActiveCache: { result: TeamRunManifest[] | null; expiresAt: number } = { result: null, expiresAt: 0 };
+
+	function invalidateListActive(): void {
+		listActiveCache = { result: null, expiresAt: 0 };
+	}
+
+	/**
+	 * RT-F3: filter to `status === "running"` BEFORE applying the limit so an
+	 * orphaned run that has been pushed past the top-N by recent successful
+	 * runs is still surfaced to crash-recovery. The cap is the LIMIT, not the
+	 * "top-N most recent"; callers (e.g. zombie detection) explicitly want
+	 * EVERY currently-running run, in any order.
+	 *
+	 * Internally performs a full scan (NOT via list()) so the cap doesn't
+	 * silently drop "running" runs that fell past the top-N createdAt cutoff.
+	 * Still goes through parseManifestIfChanged for stat+size memoization, so
+	 * the per-run I/O cost is the same as list().
+	 *
+	 * FIND-03 perf: the full scan is memoized behind a 500ms TTL (same TTL as
+	 * list()). fs.watch-driven scheduleListRefresh() invalidates the cache
+	 * immediately so the next call re-scans. The cap is applied AFTER the
+	 * cache lookup so a cached scan result can be sliced to ANY limit without
+	 * re-scanning.
+	 */
+	function listActive(limit: number): TeamRunManifest[] {
+		const cap = Math.max(0, limit);
+		const now = Date.now();
+		if (listActiveCache.result !== null && listActiveCache.expiresAt > now) {
+			return listActiveCache.result.slice(0, cap);
+		}
+		const parsedEntries = [
+			...roots.flatMap((root) => collectRoots(root)),
+			...activeRunEntries().map((entry) => ({
+				runId: entry.runId,
+				path: entry.manifestPath,
+			})),
+		];
+		const unique = new Map<string, CachedManifest | undefined>();
+		for (const entry of parsedEntries) {
+			if (entry.runId.length === 0) continue;
+			let cached = manifestIndex.get(entry.runId);
+			const root = path.dirname(path.dirname(entry.path));
+			const parsed = parseManifestIfChanged(root, entry.runId, entry.path, cached);
+			if (parsed) {
+				cached = parsed;
+				manifestIndex.set(entry.runId, cached);
+			}
+			if (cached) unique.set(entry.runId, cached);
+		}
+		const running = [...unique.values()]
+			.filter((value): value is CachedManifest => value !== undefined)
+			.map((value) => value.manifest)
+			.filter((manifest) => manifest.status === "running");
+		listActiveCache = { result: running, expiresAt: now + ttlMs };
+		return running.slice(0, cap);
+	}
+
+	if (options.watch ?? true) {
+		for (const root of roots) {
+			const watcher = watchWithErrorHandler(
+				root,
+				() => {
+					scheduleListRefresh();
+				},
+				() => {
+					scheduleListRefresh();
+				},
+			);
+			if (watcher) {
+				watcher.unref();
+				watchers.push(watcher);
+			}
+		}
+	}
+
+	return {
+		list,
+		listActive,
+		get,
+		clear(runId) {
+			invalidate(runId);
+		},
+		dispose() {
+			if (listTimer) {
+				clearTimeout(listTimer);
+				listTimer = undefined;
+			}
+			for (const watcher of watchers) closeWatcher(watcher);
+			watchers = [];
+			manifestIndex.clear();
+			listCache.clear();
+			invalidateListActive();
+		},
+	};
+}

package/src/runtime/mcp-proxy.ts

@@ -0,0 +1,105 @@
+/**
+ * G2: MCP Proxy for live-session workers.
+ *
+ * When the parent process has MCP servers configured, live-session workers
+ * can reuse those connections instead of establishing their own. This module
+ * discovers MCP tools available in the parent environment and creates proxy
+ * tool definitions that forward calls through the parent's connections.
+ *
+ * Strategy:
+ * 1. If the Pi SDK session has MCP tools after bindExtensions → use them directly
+ * 2. If not → create proxy custom tools that wrap MCP calls
+ * 3. If no MCP config exists → disable MCP in the session
+ *
+ * The Pi SDK's `createAgentSession` accepts a `customTools` array for injecting
+ * proxy tools. The session also accepts `enableMCP: false` to skip MCP discovery
+ * when proxying from the parent.
+ */
+
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { TSchema } from "@sinclair/typebox";
+
+export interface McpProxyConfig {
+	/** Whether to enable MCP in the child session. */
+	enableMcp: boolean;
+	/** Proxy tools to inject via customTools (replaces MCP connection). */
+	proxyTools: Array<ToolDefinition<TSchema, unknown>>;
+	/** Names of MCP tools available (for metadata/tracking). */
+	proxyToolNames: string[];
+}
+
+/**
+ * Build MCP proxy configuration for a live-session worker.
+ *
+ * @param options.parentMcpTools — MCP tool names from the parent session (if available)
+ * @param options.shareMcp — Whether to share MCP connections (default: true)
+ */
+export function buildMcpProxyConfig(options: { parentMcpTools?: string[]; shareMcp?: boolean }): McpProxyConfig {
+	if (options.shareMcp === false) {
+		return { enableMcp: true, proxyTools: [], proxyToolNames: [] };
+	}
+
+	const parentTools = options.parentMcpTools ?? [];
+	if (parentTools.length === 0) {
+		// No MCP tools in parent — let session discover on its own
+		return { enableMcp: true, proxyTools: [], proxyToolNames: [] };
+	}
+
+	// MCP tools exist in parent — try to create proxy tools.
+	// If proxy tools are not available (stub), keep enableMcp: true
+	// so the child session can self-discover MCP instead of losing all access.
+	const proxyTools = createMcpProxyTools(parentTools);
+	if (proxyTools.length === 0) {
+		// No proxy tools available — let child discover MCP on its own
+		return { enableMcp: true, proxyTools: [], proxyToolNames: parentTools };
+	}
+	return {
+		enableMcp: false,
+		proxyTools,
+		proxyToolNames: parentTools,
+	};
+}
+
+/**
+ * Create lightweight proxy tools that represent MCP tools from the parent.
+ *
+ * These tools tell the model that the MCP tools are available, but actual
+ * execution is forwarded through the parent's MCP connections. Since we
+ * can't directly access the parent's MCP manager from a child session,
+ * the tools return a message indicating the model should use them normally.
+ *
+ * In a future iteration, these can be wired to the actual MCP connections
+ * via an inter-process bridge.
+ */
+function createMcpProxyTools(toolNames: string[]): Array<ToolDefinition<TSchema, unknown>> {
+	// For now, we don't create individual proxy tools because we can't
+	// forward MCP calls without the parent's MCP manager reference.
+	//
+	// Instead, we let the child session discover MCP on its own (enableMcp: true)
+	// or share the parent's MCP config directory.
+	//
+	// This will be enhanced when we add inter-process MCP call forwarding.
+	return [];
+}
+
+/**
+ * Discover MCP tool names from a live session's active tools.
+ * MCP tools typically have names containing "__" (e.g., "mcp__filesystem__read_file").
+ */
+export function discoverMcpToolNames(activeToolNames: string[]): string[] {
+	return activeToolNames.filter(
+		(name) => name.startsWith("mcp__") || name.startsWith("mcp-") || (name.includes("__") && !name.startsWith("submit_result")),
+	);
+}
+
+/**
+ * Build MCP proxy config from a real Pi SDK session's active tools.
+ * This is the preferred way — inspect what the parent session has available.
+ */
+export function buildMcpProxyFromSession(activeToolNames: string[], options?: { shareMcp?: boolean }): McpProxyConfig {
+	const mcpTools = discoverMcpToolNames(activeToolNames);
+	return buildMcpProxyConfig({
+		parentMcpTools: mcpTools,
+		shareMcp: options?.shareMcp,
+	});
+}

package/src/runtime/metric-parser.ts

@@ -0,0 +1,36 @@
+/**
+ * Metric names that are denied to prevent prototype pollution.
+ */
+export const DENIED_METRIC_NAMES: ReadonlySet<string> = new Set(["__proto__", "constructor", "prototype"]);
+
+const METRIC_LINE_RE = /^CREW_METRIC\s+(\w+)=(\S+)$/;
+
+/**
+ * Parse CREW_METRIC lines from worker stdout.
+ *
+ * Lines must match the pattern: `CREW_METRIC name=value`
+ * - `name` must be a word character sequence (alphanumeric + underscore)
+ * - `value` must parse as a valid finite number
+ * - Denied names (__proto__, constructor, prototype) are silently skipped
+ *
+ * @param output - Raw worker stdout text
+ * @returns Map of metric name → numeric value
+ */
+export function parseMetricLines(output: string): Record<string, number> {
+	const metrics: Record<string, number> = {};
+
+	for (const line of output.split("\n")) {
+		const match = METRIC_LINE_RE.exec(line);
+		if (!match) continue;
+
+		const [, name, rawValue] = match;
+		if (DENIED_METRIC_NAMES.has(name)) continue;
+
+		const value = Number(rawValue);
+		if (!Number.isFinite(value)) continue;
+
+		metrics[name] = value;
+	}
+
+	return metrics;
+}