pi-crew 0.1.35 → 0.1.37

package/src/extension/team-tool/api.ts

@@ -19,12 +19,37 @@ import { liveControlRealtimeMessage, publishLiveControlRealtime } from "../../su
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { configRecord, result, type TeamContext } from "./context.ts";
 
+function globMatch(value: string, pattern: string): boolean {
+	const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(`^${escaped}$`).test(value);
+}
+
+function snapshotHasRunId(snapshot: { values?: unknown }, runId: string): boolean {
+	const values = Array.isArray(snapshot.values) ? snapshot.values : [];
+	return values.some((value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+		const labels = (value as { labels?: unknown }).labels;
+		return labels && typeof labels === "object" && !Array.isArray(labels) && (labels as Record<string, unknown>).runId === runId;
+	});
+}
+
 export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	const cfg = configRecord(params.config);
+	const operation = typeof cfg.operation === "string" ? cfg.operation : "read-manifest";
+	if (operation === "metrics-snapshot") {
+		const filter = typeof cfg.filter === "string" ? cfg.filter : undefined;
+		const runIdFilter = typeof cfg.runId === "string" ? cfg.runId : params.runId;
+		const snapshots = ctx.metricRegistry?.snapshot() ?? [];
+		const filtered = snapshots.filter((snapshot) => {
+			if (filter && !globMatch(snapshot.name, filter)) return false;
+			if (runIdFilter && !snapshotHasRunId(snapshot, runIdFilter)) return false;
+			return true;
+		});
+		return result(JSON.stringify(filtered, null, 2), { action: "api", status: "ok", ...(runIdFilter ? { runId: runIdFilter } : {}) });
+	}
 	if (!params.runId) return result("API requires runId.", { action: "api", status: "error" }, true);
 	const loaded = loadRunManifestById(ctx.cwd, params.runId);
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "api", status: "error" }, true);
-	const cfg = configRecord(params.config);
-	const operation = typeof cfg.operation === "string" ? cfg.operation : "read-manifest";
 	if (operation === "read-manifest") {
 		return result(JSON.stringify(loaded.manifest, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 	}

package/src/extension/team-tool/context.ts

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { MetricRegistry } from "../../observability/metric-registry.ts";
 import type { TeamToolDetails } from "../team-tool-types.ts";
 import { toolResult, type PiTeamsToolResult } from "../tool-result.ts";
 
@@ -6,6 +7,7 @@ export type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<Extension
 	modelRegistry?: unknown;
 	sessionManager?: { getBranch?: () => unknown[] };
 	events?: { emit?: (event: string, data: unknown) => void };
+	metricRegistry?: MetricRegistry;
 	signal?: AbortSignal;
 	startForegroundRun?: (runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
 	onRunStarted?: (runId: string) => void;

package/src/extension/team-tool/run.ts

@@ -134,7 +134,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	if (executeWorkers && ctx.startForegroundRun) {
 		ctx.onRunStarted?.(updatedManifest.runId);
 		ctx.startForegroundRun(async (signal) => {
-			await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal });
+			await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry });
 		}, updatedManifest.runId);
 		const text = [
 			`Started foreground pi-crew run ${updatedManifest.runId}.`,
@@ -150,7 +150,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		].join("\n");
 		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot });
 	}
-	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal });
+	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry });
 	const text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
 		`Team: ${team.name}`,

package/src/extension/team-tool.ts

@@ -185,7 +185,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		const loadedConfig = loadConfig(ctx.cwd);
 		const runtime = await resolveCrewRuntime(loadedConfig.config);
 		const executeWorkers = runtime.kind !== "scaffold";
-		const executed = await executeTeamRun({ manifest: resumeManifest, tasks: resetTasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal });
+		const executed = await executeTeamRun({ manifest: resumeManifest, tasks: resetTasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal, reliability: loadedConfig.config.reliability, metricRegistry: ctx.metricRegistry });
 		return result([`Resumed run ${executed.manifest.runId}.`, `Status: ${executed.manifest.status}`, `Tasks: ${executed.tasks.length}`, `Artifacts: ${executed.manifest.artifactsRoot}`].join("\n"), { action: "resume", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
 	});
 }

package/src/observability/correlation.ts

@@ -0,0 +1,35 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export interface CorrelationContext {
+	traceId: string;
+	parentSpanId?: string;
+	spanId: string;
+}
+
+const storage = new AsyncLocalStorage<CorrelationContext>();
+let spanCounter = 0;
+
+export function withCorrelation<T>(ctx: CorrelationContext, fn: () => T): T {
+	return storage.run(ctx, fn);
+}
+
+export function getCurrentContext(): CorrelationContext | undefined {
+	return storage.getStore();
+}
+
+export function newSpanId(runId: string, taskId = "main"): string {
+	spanCounter += 1;
+	return `${runId}:${taskId}:${spanCounter}`;
+}
+
+export function childCorrelation(runId: string, taskId: string): CorrelationContext {
+	const parent = getCurrentContext();
+	const spanId = newSpanId(runId, taskId);
+	return { traceId: parent?.traceId ?? spanId, parentSpanId: parent?.spanId, spanId };
+}
+
+export function correlatedEvent<T extends { runId?: string; data?: Record<string, unknown> }>(event: T): T {
+	const ctx = getCurrentContext();
+	if (!ctx) return event;
+	return { ...event, data: { ...(event.data ?? {}), traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId } };
+}

package/src/observability/event-to-metric.ts

@@ -0,0 +1,54 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { MetricRegistry } from "./metric-registry.ts";
+
+function recordValue(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function stringValue(value: unknown, fallback: string): string {
+	return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+
+function numberValue(value: unknown, fallback = 0): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+export interface EventToMetricSubscription {
+	dispose(): void;
+}
+
+export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, registry: MetricRegistry): EventToMetricSubscription {
+	const runCount = registry.counter("crew.run.count", "Total runs by status");
+	const taskCount = registry.counter("crew.task.count", "Total tasks by status");
+	const subagentCount = registry.counter("crew.subagent.count", "Total subagent records by status");
+	const mailboxCount = registry.counter("crew.mailbox.count", "Total mailbox messages by direction");
+	registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
+	registry.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds");
+	const runDuration = registry.histogram("crew.run.duration_ms", "Run end-to-end duration, milliseconds");
+	const taskDuration = registry.histogram("crew.task.duration_ms", "Task duration, milliseconds");
+	registry.histogram("crew.task.retry_count", "Retries per task", [0, 1, 2, 3, 5, 10]);
+	const tokenUsage = registry.histogram("crew.task.tokens_total", "Token usage per task");
+
+	const handlers: Array<[string, (data: unknown) => void]> = [
+		["crew.run.completed", (data) => { const item = recordValue(data); runCount.inc({ status: "completed" }); runDuration.observe({ team: stringValue(item.team, "unknown") }, numberValue(item.durationMs)); }],
+		["crew.run.failed", () => runCount.inc({ status: "failed" })],
+		["crew.run.cancelled", () => runCount.inc({ status: "cancelled" })],
+		["crew.task.completed", (data) => { const item = recordValue(data); taskCount.inc({ status: "completed" }); taskDuration.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.durationMs)); tokenUsage.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.tokens)); }],
+		["crew.task.failed", () => taskCount.inc({ status: "failed" })],
+		["crew.task.retry_attempt", (data) => { const item = recordValue(data); taskCount.inc({ status: "retry" }); registry.counter("crew.task.retry_attempt_total", "Retry attempts by run and task").inc({ runId: stringValue(item.runId, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
+		["crew.task.deadletter", (data) => { const item = recordValue(data); registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason").inc({ reason: stringValue(item.reason, "unknown") }); }],
+		["crew.subagent.completed", (data) => { const item = recordValue(data); subagentCount.inc({ status: stringValue(item.status, "completed") }); }],
+		["crew.subagent.failed", () => subagentCount.inc({ status: "failed" })],
+		["crew.mailbox.message", (data) => { const item = recordValue(data); mailboxCount.inc({ direction: stringValue(item.direction, "unknown") }); }],
+	];
+
+	const unsubscribers: Array<() => void> = [];
+	for (const [event, handler] of handlers) {
+		const unsubscribe = events?.on?.(event, (data: unknown) => {
+			try { handler(data); } catch { /* metric handlers must never break event delivery */ }
+		});
+		if (typeof unsubscribe === "function") unsubscribers.push(unsubscribe);
+	}
+	let disposed = false;
+	return { dispose() { if (disposed) return; disposed = true; for (const unsubscribe of unsubscribers.splice(0)) unsubscribe(); } };
+}

package/src/observability/exporters/adapter.ts

@@ -0,0 +1,24 @@
+import type { MetricSnapshot } from "../metrics-primitives.ts";
+
+export interface MetricExporter {
+	name: string;
+	push(snapshots: MetricSnapshot[]): Promise<void>;
+	dispose(): void;
+}
+
+export class CompositeExporter implements MetricExporter {
+	name = "composite";
+	private readonly exporters: MetricExporter[];
+
+	constructor(exporters: MetricExporter[]) {
+		this.exporters = exporters;
+	}
+
+	async push(snapshots: MetricSnapshot[]): Promise<void> {
+		await Promise.allSettled(this.exporters.map((exporter) => exporter.push(snapshots)));
+	}
+
+	dispose(): void {
+		for (const exporter of this.exporters) exporter.dispose();
+	}
+}

package/src/observability/exporters/otlp-exporter.ts

@@ -0,0 +1,65 @@
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { MetricRegistry } from "../metric-registry.ts";
+import type { MetricSnapshot } from "../metrics-primitives.ts";
+import type { MetricExporter } from "./adapter.ts";
+
+export interface OTLPExporterOptions {
+	endpoint: string;
+	headers?: Record<string, string>;
+	intervalMs?: number;
+	timeoutMs?: number;
+}
+
+function pointValues(snapshot: MetricSnapshot): unknown[] {
+	return snapshot.values.map((value) => ({ attributes: Object.entries(value.labels).map(([key, item]) => ({ key, value: { stringValue: String(item) } })), asDouble: "value" in value ? value.value : undefined, count: "count" in value ? value.count : undefined, sum: "sum" in value ? value.sum : undefined }));
+}
+
+export function convertToOTLP(snapshots: MetricSnapshot[]): unknown {
+	return {
+		resourceMetrics: [{
+			resource: { attributes: [{ key: "service.name", value: { stringValue: "pi-crew" } }] },
+			scopeMetrics: [{
+				scope: { name: "pi-crew" },
+				metrics: snapshots.map((snapshot) => ({ name: snapshot.name, description: snapshot.description, [snapshot.type === "histogram" ? "histogram" : snapshot.type === "gauge" ? "gauge" : "sum"]: { dataPoints: pointValues(snapshot) } })),
+			}],
+		}],
+	};
+}
+
+export class OTLPExporter implements MetricExporter {
+	name = "otlp";
+	private timer?: ReturnType<typeof setInterval>;
+	private readonly opts: OTLPExporterOptions;
+	private readonly registry: MetricRegistry;
+
+	constructor(opts: OTLPExporterOptions, registry: MetricRegistry) {
+		this.opts = opts;
+		this.registry = registry;
+	}
+
+	start(): void {
+		this.dispose();
+		this.timer = setInterval(() => { void this.push(this.registry.snapshot()); }, this.opts.intervalMs ?? 60_000);
+		this.timer.unref?.();
+	}
+
+	async push(snapshots: MetricSnapshot[]): Promise<void> {
+		try {
+			const timeoutMs = this.opts.timeoutMs ?? 10_000;
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), timeoutMs);
+			try {
+				await fetch(this.opts.endpoint, { method: "POST", headers: { "content-type": "application/json", ...(this.opts.headers ?? {}) }, body: JSON.stringify(convertToOTLP(snapshots)), signal: controller.signal });
+			} finally {
+				clearTimeout(timer);
+			}
+		} catch (error) {
+			logInternalError("otlp-export", error);
+		}
+	}
+
+	dispose(): void {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = undefined;
+	}
+}

package/src/observability/exporters/prometheus-exporter.ts

@@ -0,0 +1,47 @@
+import type { HistogramPoint, MetricLabels, MetricPoint, MetricSnapshot } from "../metrics-primitives.ts";
+
+function prometheusName(name: string): string {
+	return name.replace(/\./g, "_");
+}
+
+function escapeLabel(value: string): string {
+	return value.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, "\\\"");
+}
+
+function labelsText(labels: MetricLabels): string {
+	const entries = Object.entries(labels);
+	if (!entries.length) return "";
+	return `{${entries.map(([key, value]) => `${key}="${escapeLabel(String(value))}"`).join(",")}}`;
+}
+
+function metricType(type: MetricSnapshot["type"]): string {
+	return type === "histogram" ? "histogram" : type === "gauge" ? "gauge" : "counter";
+}
+
+function isHistogramPoint(value: MetricPoint | HistogramPoint): value is HistogramPoint {
+	return "buckets" in value && "counts" in value;
+}
+
+export function formatPrometheus(snapshots: MetricSnapshot[]): string {
+	const lines: string[] = [];
+	for (const snapshot of snapshots) {
+		const name = prometheusName(snapshot.name);
+		lines.push(`# HELP ${name} ${snapshot.description}`);
+		lines.push(`# TYPE ${name} ${metricType(snapshot.type)}`);
+		for (const value of snapshot.values) {
+			if (isHistogramPoint(value)) {
+				let cumulative = 0;
+				for (let index = 0; index < value.buckets.length; index += 1) {
+					cumulative += value.counts[index] ?? 0;
+					const le = Number.isFinite(value.buckets[index]) ? String(value.buckets[index]) : "+Inf";
+					lines.push(`${name}_bucket${labelsText({ ...value.labels, le })} ${cumulative}`);
+				}
+				lines.push(`${name}_sum${labelsText(value.labels)} ${value.sum}`);
+				lines.push(`${name}_count${labelsText(value.labels)} ${value.count}`);
+			} else {
+				lines.push(`${name}${labelsText(value.labels)} ${value.value}`);
+			}
+		}
+	}
+	return `${lines.join("\n")}\n`;
+}

package/src/observability/metric-registry.ts

@@ -0,0 +1,72 @@
+import { Counter, Gauge, Histogram, type Metric, type MetricSnapshot } from "./metrics-primitives.ts";
+
+const METRIC_NAME_PATTERN = /^crew\.[a-z]+\.[a-z][a-z_]*$/;
+
+function assertMetricName(name: string): void {
+	if (!METRIC_NAME_PATTERN.test(name)) throw new Error(`Invalid metric name '${name}'. Expected crew.<domain>.<measure>.`);
+}
+
+export class MetricRegistry {
+	private metrics = new Map<string, Metric>();
+
+	registerCounter(name: string, description: string): Counter {
+		assertMetricName(name);
+		if (this.metrics.has(name)) throw new Error(`Metric '${name}' is already registered.`);
+		const metric = new Counter(name, description);
+		this.metrics.set(name, metric);
+		return metric;
+	}
+
+	registerGauge(name: string, description: string): Gauge {
+		assertMetricName(name);
+		if (this.metrics.has(name)) throw new Error(`Metric '${name}' is already registered.`);
+		const metric = new Gauge(name, description);
+		this.metrics.set(name, metric);
+		return metric;
+	}
+
+	registerHistogram(name: string, description: string, buckets?: number[]): Histogram {
+		assertMetricName(name);
+		if (this.metrics.has(name)) throw new Error(`Metric '${name}' is already registered.`);
+		const metric = new Histogram(name, description, buckets);
+		this.metrics.set(name, metric);
+		return metric;
+	}
+
+	counter(name: string, description: string): Counter {
+		const existing = this.metrics.get(name);
+		if (existing instanceof Counter) return existing;
+		if (existing) throw new Error(`Metric '${name}' is not a counter.`);
+		return this.registerCounter(name, description);
+	}
+
+	gauge(name: string, description: string): Gauge {
+		const existing = this.metrics.get(name);
+		if (existing instanceof Gauge) return existing;
+		if (existing) throw new Error(`Metric '${name}' is not a gauge.`);
+		return this.registerGauge(name, description);
+	}
+
+	histogram(name: string, description: string, buckets?: number[]): Histogram {
+		const existing = this.metrics.get(name);
+		if (existing instanceof Histogram) return existing;
+		if (existing) throw new Error(`Metric '${name}' is not a histogram.`);
+		return this.registerHistogram(name, description, buckets);
+	}
+
+	get(name: string): Metric | undefined {
+		return this.metrics.get(name);
+	}
+
+	snapshot(): MetricSnapshot[] {
+		return [...this.metrics.values()].map((metric) => metric.snapshot());
+	}
+
+	dispose(): void {
+		this.metrics.clear();
+	}
+}
+
+export function createMetricRegistry(): MetricRegistry {
+	return new MetricRegistry();
+}

package/src/observability/metric-retention.ts

@@ -0,0 +1,46 @@
+import { labelKey, type MetricLabels } from "./metrics-primitives.ts";
+
+interface WindowEvent {
+	timestamp: number;
+	labels: MetricLabels;
+	delta: number;
+}
+
+export class TimeWindowedCounter {
+	private events: WindowEvent[] = [];
+	private readonly windowMs: number;
+	private readonly now: () => number;
+
+	constructor(windowMs = 3_600_000, now: () => number = () => Date.now()) {
+		this.windowMs = windowMs;
+		this.now = now;
+	}
+
+	inc(labels: MetricLabels = {}, delta = 1): void {
+		if (!Number.isFinite(delta)) return;
+		this.events.push({ timestamp: this.now(), labels: { ...labels }, delta });
+		this.prune();
+	}
+
+	count(labels: MetricLabels = {}, durationMs = this.windowMs): number {
+		this.prune();
+		const key = labelKey(labels);
+		const cutoff = this.now() - durationMs;
+		return this.events.filter((event) => event.timestamp >= cutoff && labelKey(event.labels) === key).reduce((sum, event) => sum + event.delta, 0);
+	}
+
+	rate(labels: MetricLabels = {}, durationMs = this.windowMs): number {
+		if (durationMs <= 0) return 0;
+		return this.count(labels, durationMs) / (durationMs / 1000);
+	}
+
+	size(): number {
+		this.prune();
+		return this.events.length;
+	}
+
+	private prune(): void {
+		const cutoff = this.now() - this.windowMs;
+		this.events = this.events.filter((event) => event.timestamp >= cutoff);
+	}
+}

package/src/observability/metric-sink.ts

@@ -0,0 +1,51 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { redactSecrets } from "../runtime/diagnostic-export.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+import type { MetricRegistry } from "./metric-registry.ts";
+import type { MetricSnapshot } from "./metrics-primitives.ts";
+
+export interface MetricSink {
+	writeSnapshot(snapshots: MetricSnapshot[]): void;
+	dispose(): void;
+}
+
+export interface MetricFileSinkOptions {
+	crewRoot: string;
+	registry: MetricRegistry;
+	retentionDays?: number;
+	intervalMs?: number;
+}
+
+function rotateOldFiles(dir: string, retentionDays: number, now = Date.now()): void {
+	if (!fs.existsSync(dir)) return;
+	const maxAge = retentionDays * 24 * 60 * 60 * 1000;
+	for (const file of fs.readdirSync(dir)) {
+		if (!file.endsWith(".jsonl")) continue;
+		const fullPath = path.join(dir, file);
+		try {
+			if (now - fs.statSync(fullPath).mtimeMs > maxAge) fs.unlinkSync(fullPath);
+		} catch (error) {
+			logInternalError("metric-sink.rotate", error, fullPath);
+		}
+	}
+}
+
+export function createMetricFileSink(opts: MetricFileSinkOptions): MetricSink {
+	const dir = path.join(opts.crewRoot, "state", "metrics");
+	const retentionDays = opts.retentionDays ?? 7;
+	const writeSnapshot = (snapshots: MetricSnapshot[]): void => {
+		try {
+			const date = new Date().toISOString().slice(0, 10);
+			fs.mkdirSync(dir, { recursive: true });
+			rotateOldFiles(dir, retentionDays);
+			const redacted = redactSecrets(snapshots) as MetricSnapshot[];
+			fs.appendFileSync(path.join(dir, `${date}.jsonl`), `${JSON.stringify({ exportedAt: new Date().toISOString(), snapshots: redacted })}\n`, "utf-8");
+		} catch (error) {
+			logInternalError("metric-sink.write", error);
+		}
+	};
+	const timer = setInterval(() => writeSnapshot(opts.registry.snapshot()), opts.intervalMs ?? 60_000);
+	timer.unref?.();
+	return { writeSnapshot, dispose: () => clearInterval(timer) };
+}

package/src/observability/metrics-primitives.ts

@@ -0,0 +1,166 @@
+export type MetricLabelValue = string | number;
+export type MetricLabels = Record<string, MetricLabelValue>;
+
+export interface MetricPoint {
+	labels: MetricLabels;
+	value: number;
+}
+
+export interface HistogramPoint {
+	labels: MetricLabels;
+	buckets: number[];
+	counts: number[];
+	sum: number;
+	count: number;
+	quantiles: Record<string, number>;
+}
+
+export interface MetricSnapshot {
+	type: "counter" | "gauge" | "histogram";
+	name: string;
+	description: string;
+	values: MetricPoint[] | HistogramPoint[];
+}
+
+interface StoredValue {
+	labels: MetricLabels;
+	value: number;
+}
+
+interface StoredHistogram {
+	labels: MetricLabels;
+	counts: number[];
+	sum: number;
+	count: number;
+}
+
+export const DEFAULT_HISTOGRAM_BUCKETS = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000] as const;
+
+function normalizeLabels(labels: MetricLabels = {}): MetricLabels {
+	const normalized: MetricLabels = {};
+	for (const [key, value] of Object.entries(labels).sort(([left], [right]) => left.localeCompare(right))) normalized[key] = value;
+	return normalized;
+}
+
+export function labelKey(labels: MetricLabels = {}): string {
+	return JSON.stringify(normalizeLabels(labels));
+}
+
+function cloneLabels(labels: MetricLabels): MetricLabels {
+	return { ...labels };
+}
+
+export abstract class Metric {
+	readonly name: string;
+	readonly description: string;
+
+	constructor(name: string, description: string) {
+		this.name = name;
+		this.description = description;
+	}
+
+	abstract snapshot(): MetricSnapshot;
+}
+
+export class Counter extends Metric {
+	private values = new Map<string, StoredValue>();
+
+	inc(labels: MetricLabels = {}, delta = 1): void {
+		if (!Number.isFinite(delta)) return;
+		const key = labelKey(labels);
+		const current = this.values.get(key) ?? { labels: normalizeLabels(labels), value: 0 };
+		this.values.set(key, { labels: current.labels, value: current.value + delta });
+	}
+
+	value(labels: MetricLabels = {}): number {
+		return this.values.get(labelKey(labels))?.value ?? 0;
+	}
+
+	snapshot(): MetricSnapshot {
+		return { type: "counter", name: this.name, description: this.description, values: [...this.values.values()].map((entry) => ({ labels: cloneLabels(entry.labels), value: entry.value })) };
+	}
+}
+
+export class Gauge extends Metric {
+	private values = new Map<string, StoredValue>();
+
+	set(labels: MetricLabels = {}, value: number): void {
+		if (!Number.isFinite(value)) return;
+		this.values.set(labelKey(labels), { labels: normalizeLabels(labels), value });
+	}
+
+	add(labels: MetricLabels = {}, delta: number): void {
+		if (!Number.isFinite(delta)) return;
+		this.set(labels, this.value(labels) + delta);
+	}
+
+	value(labels: MetricLabels = {}): number {
+		return this.values.get(labelKey(labels))?.value ?? 0;
+	}
+
+	snapshot(): MetricSnapshot {
+		return { type: "gauge", name: this.name, description: this.description, values: [...this.values.values()].map((entry) => ({ labels: cloneLabels(entry.labels), value: entry.value })) };
+	}
+}
+
+export class Histogram extends Metric {
+	private readonly buckets: number[];
+	private observations = new Map<string, StoredHistogram>();
+
+	constructor(name: string, description: string, buckets?: number[]) {
+		super(name, description);
+		const source = buckets?.length ? buckets : [...DEFAULT_HISTOGRAM_BUCKETS];
+		this.buckets = [...new Set(source.filter((bucket) => Number.isFinite(bucket)).sort((left, right) => left - right))];
+	}
+
+	observe(labels: MetricLabels = {}, value: number): void {
+		if (!Number.isFinite(value)) return;
+		const key = labelKey(labels);
+		const current = this.observations.get(key) ?? { labels: normalizeLabels(labels), counts: new Array(this.buckets.length + 1).fill(0) as number[], sum: 0, count: 0 };
+		const bucketIndex = this.buckets.findIndex((bucket) => value <= bucket);
+		current.counts[bucketIndex === -1 ? this.buckets.length : bucketIndex] = (current.counts[bucketIndex === -1 ? this.buckets.length : bucketIndex] ?? 0) + 1;
+		current.sum += value;
+		current.count += 1;
+		this.observations.set(key, current);
+	}
+
+	quantile(labels: MetricLabels = {}, q: number): number {
+		const obs = this.observations.get(labelKey(labels));
+		if (!obs || obs.count === 0 || !Number.isFinite(q)) return Number.NaN;
+		const bounded = Math.min(1, Math.max(0, q));
+		const target = Math.max(1, bounded * obs.count);
+		let cumulative = 0;
+		for (let index = 0; index < obs.counts.length; index += 1) {
+			const count = obs.counts[index] ?? 0;
+			cumulative += count;
+			if (cumulative >= target) {
+				const previous = cumulative - count;
+				const lower = index === 0 ? 0 : this.buckets[index - 1] ?? this.buckets.at(-1) ?? 0;
+				const upper = index < this.buckets.length ? this.buckets[index] ?? lower : Math.max(lower, obs.sum / Math.max(1, obs.count));
+				const fraction = count === 0 ? 0 : (target - previous) / Math.max(1, count);
+				return lower + fraction * (upper - lower);
+			}
+		}
+		return this.buckets.at(-1) ?? Number.NaN;
+	}
+
+	count(labels: MetricLabels = {}): number {
+		return this.observations.get(labelKey(labels))?.count ?? 0;
+	}
+
+	snapshot(): MetricSnapshot {
+		return {
+			type: "histogram",
+			name: this.name,
+			description: this.description,
+			values: [...this.observations.values()].map((entry) => ({
+				labels: cloneLabels(entry.labels),
+				buckets: [...this.buckets, Number.POSITIVE_INFINITY],
+				counts: [...entry.counts],
+				sum: entry.sum,
+				count: entry.count,
+				quantiles: { p50: this.quantile(entry.labels, 0.5), p95: this.quantile(entry.labels, 0.95), p99: this.quantile(entry.labels, 0.99) },
+			})),
+		};
+	}
+}