pi-crew 0.9.50 → 0.9.52

package/src/runtime/loop-gates.ts

@@ -1,128 +0,0 @@
-/**
- * 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

@@ -1,375 +0,0 @@
-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

@@ -1,105 +0,0 @@
-/**
- * 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

@@ -1,36 +0,0 @@
-/**
- * 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;
-}