@danypops/jittor 0.14.0 → 0.16.0

package/src/domain/context-telemetry.ts

@@ -8,7 +8,10 @@ import {
 } from "../constants.ts";
 import type { MetricObservation, StoredMetricObservation } from "./metric.ts";
 
-interface PayloadSize { characters: number; bytes: number }
+interface PayloadSize {
+	characters: number;
+	bytes: number;
+}
 
 export interface PapyrusContextInjection {
 	schema: typeof PAPYRUS_CONTEXT_INJECTION_SCHEMA;
@@ -26,7 +29,21 @@ export interface PapyrusContextInjection {
 	unchanged: boolean;
 }
 
-const TOP_LEVEL_FIELDS = new Set(["schema", "observedAt", "sequence", "producerId", "before", "rules", "tasks", "injected", "after", "estimatedTokens", "share", "fingerprint", "unchanged"]);
+const TOP_LEVEL_FIELDS = new Set([
+	"schema",
+	"observedAt",
+	"sequence",
+	"producerId",
+	"before",
+	"rules",
+	"tasks",
+	"injected",
+	"after",
+	"estimatedTokens",
+	"share",
+	"fingerprint",
+	"unchanged",
+]);
 const SIZE_FIELDS = new Set(["characters", "bytes"]);
 const RULE_SIZE_FIELDS = new Set(["characters", "bytes", "count"]);
 
@@ -38,44 +55,46 @@ function record(value: unknown, name: string, fields: Set<string>): Record<strin
 }
 
 function integer(value: unknown, name: string, maximum = Number.MAX_SAFE_INTEGER): number {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > maximum) throw new Error(`${name} must be a bounded non-negative integer`);
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > maximum)
+		throw new Error(`${name} must be a bounded non-negative integer`);
 	return value;
 }
 
 function size(value: unknown, name: string, fields = SIZE_FIELDS): PayloadSize {
 	const input = record(value, name, fields);
 	return {
-		characters: integer(input["characters"], `${name}.characters`, CONTEXT_OBSERVATION_MAX_CHARACTERS),
-		bytes: integer(input["bytes"], `${name}.bytes`, CONTEXT_OBSERVATION_MAX_CHARACTERS * 4),
+		characters: integer(input.characters, `${name}.characters`, CONTEXT_OBSERVATION_MAX_CHARACTERS),
+		bytes: integer(input.bytes, `${name}.bytes`, CONTEXT_OBSERVATION_MAX_CHARACTERS * 4),
 	};
 }
 
 export function validatePapyrusContextInjection(value: unknown, now = Date.now()): PapyrusContextInjection {
 	const input = record(value, "context injection", TOP_LEVEL_FIELDS);
-	if (input["schema"] !== PAPYRUS_CONTEXT_INJECTION_SCHEMA) throw new Error("context injection schema is not supported");
-	const observedAt = integer(input["observedAt"], "observedAt");
+	if (input.schema !== PAPYRUS_CONTEXT_INJECTION_SCHEMA) throw new Error("context injection schema is not supported");
+	const observedAt = integer(input.observedAt, "observedAt");
 	if (Math.abs(now - observedAt) > CONTEXT_OBSERVATION_MAX_AGE_MS) throw new Error("context injection observation is stale");
-	const producerId = input["producerId"];
-	if (typeof producerId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(producerId)) throw new Error("producerId must be a UUID");
-	const before = size(input["before"], "before");
-	const rulesInput = record(input["rules"], "rules", RULE_SIZE_FIELDS);
-	const rules = { ...size(rulesInput, "rules", RULE_SIZE_FIELDS), count: integer(rulesInput["count"], "rules.count") };
-	const tasks = size(input["tasks"], "tasks");
-	const injected = size(input["injected"], "injected");
-	const after = size(input["after"], "after");
+	const producerId = input.producerId;
+	if (typeof producerId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(producerId))
+		throw new Error("producerId must be a UUID");
+	const before = size(input.before, "before");
+	const rulesInput = record(input.rules, "rules", RULE_SIZE_FIELDS);
+	const rules = { ...size(rulesInput, "rules", RULE_SIZE_FIELDS), count: integer(rulesInput.count, "rules.count") };
+	const tasks = size(input.tasks, "tasks");
+	const injected = size(input.injected, "injected");
+	const after = size(input.after, "after");
 	if (injected.characters !== rules.characters + tasks.characters || after.characters !== before.characters + injected.characters) {
 		throw new Error("context injection sizes are inconsistent");
 	}
-	const estimatedTokens = integer(input["estimatedTokens"], "estimatedTokens", CONTEXT_OBSERVATION_MAX_CHARACTERS);
-	const share = input["share"];
+	const estimatedTokens = integer(input.estimatedTokens, "estimatedTokens", CONTEXT_OBSERVATION_MAX_CHARACTERS);
+	const share = input.share;
 	if (typeof share !== "number" || !Number.isFinite(share) || share < 0 || share > 1) throw new Error("share must be a ratio");
-	const fingerprint = input["fingerprint"];
+	const fingerprint = input.fingerprint;
 	if (typeof fingerprint !== "string" || !/^[a-f0-9]{64}$/.test(fingerprint)) throw new Error("fingerprint must be a SHA-256 hex digest");
-	if (typeof input["unchanged"] !== "boolean") throw new Error("unchanged must be boolean");
+	if (typeof input.unchanged !== "boolean") throw new Error("unchanged must be boolean");
 	return {
 		schema: PAPYRUS_CONTEXT_INJECTION_SCHEMA,
 		observedAt,
-		sequence: integer(input["sequence"], "sequence"),
+		sequence: integer(input.sequence, "sequence"),
 		producerId,
 		before,
 		rules,
@@ -85,7 +104,7 @@ export function validatePapyrusContextInjection(value: unknown, now = Date.now()
 		estimatedTokens,
 		share,
 		fingerprint,
-		unchanged: input["unchanged"],
+		unchanged: input.unchanged,
 	};
 }
 
@@ -121,7 +140,9 @@ export interface CompactionStart {
 	contextTokens?: number;
 }
 
-interface OpenCompaction extends CompactionStart { startedAt: number }
+interface OpenCompaction extends CompactionStart {
+	startedAt: number;
+}
 interface UsageCounters {
 	turns: number;
 	injectedCharacters: number;
@@ -140,8 +161,12 @@ export class CompactionTelemetry {
 	private counters = emptyCounters();
 	private previousCompletedAt: number | undefined;
 
-	hasOpenCompaction(): boolean { return this.open !== undefined; }
-	observeTurn(): void { this.counters.turns += 1; }
+	hasOpenCompaction(): boolean {
+		return this.open !== undefined;
+	}
+	observeTurn(): void {
+		this.counters.turns += 1;
+	}
 	observeInjection(characters: number, estimatedTokens: number): void {
 		this.counters.injectedCharacters += Math.max(0, characters);
 		this.counters.estimatedInjectedTokens += Math.max(0, estimatedTokens);
@@ -154,26 +179,68 @@ export class CompactionTelemetry {
 
 	begin(input: CompactionStart, now = Date.now()): MetricObservation {
 		this.open = { ...input, startedAt: now };
-		return { source: "pi-context", scope: "compaction", metric: "compaction-started", value: 1, unit: "count", observedAt: now, attributes: { ...input } };
+		return {
+			source: "pi-context",
+			scope: "compaction",
+			metric: "compaction-started",
+			value: 1,
+			unit: "count",
+			observedAt: now,
+			attributes: { ...input },
+		};
 	}
 
 	complete(input: Pick<CompactionStart, "reason" | "willRetry">, now = Date.now()): MetricObservation {
-		if (!this.open) return { source: "pi-context", scope: "compaction", metric: "compaction-unmatched", value: 1, unit: "count", observedAt: now, attributes: { ...input } };
+		if (!this.open)
+			return {
+				source: "pi-context",
+				scope: "compaction",
+				metric: "compaction-unmatched",
+				value: 1,
+				unit: "count",
+				observedAt: now,
+				attributes: { ...input },
+			};
 		const open = this.open;
 		this.open = undefined;
 		const attributes = this.intervalAttributes(open, now);
 		this.previousCompletedAt = now;
 		this.counters = emptyCounters();
-		return { source: "pi-context", scope: "compaction", metric: "compaction-duration", value: Math.max(0, now - open.startedAt), unit: "milliseconds", observedAt: now, attributes: { ...attributes, reason: input.reason, willRetry: input.willRetry } };
+		return {
+			source: "pi-context",
+			scope: "compaction",
+			metric: "compaction-duration",
+			value: Math.max(0, now - open.startedAt),
+			unit: "milliseconds",
+			observedAt: now,
+			attributes: { ...attributes, reason: input.reason, willRetry: input.willRetry },
+		};
 	}
 
 	abort(now = Date.now(), abortReason = "aborted"): MetricObservation {
 		const open = this.open;
 		this.open = undefined;
-		if (!open) return { source: "pi-context", scope: "compaction", metric: "compaction-unmatched", value: 1, unit: "count", observedAt: now, attributes: { abortReason } };
+		if (!open)
+			return {
+				source: "pi-context",
+				scope: "compaction",
+				metric: "compaction-unmatched",
+				value: 1,
+				unit: "count",
+				observedAt: now,
+				attributes: { abortReason },
+			};
 		const attributes = this.intervalAttributes(open, now);
 		this.counters = emptyCounters();
-		return { source: "pi-context", scope: "compaction", metric: "compaction-aborted", value: 1, unit: "count", observedAt: now, attributes: { ...attributes, reason: open.reason, abortReason, durationMs: Math.max(0, now - open.startedAt) } };
+		return {
+			source: "pi-context",
+			scope: "compaction",
+			metric: "compaction-aborted",
+			value: 1,
+			unit: "count",
+			observedAt: now,
+			attributes: { ...attributes, reason: open.reason, abortReason, durationMs: Math.max(0, now - open.startedAt) },
+		};
 	}
 
 	private intervalAttributes(open: OpenCompaction, now: number): Record<string, unknown> {
@@ -226,8 +293,12 @@ function numericAttribute(row: StoredMetricObservation, key: string): number | n
 	const value = row.attributes[key];
 	return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-function average(values: number[]): number | null { return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length; }
-function sum(values: number[]): number { return values.reduce((total, value) => total + value, 0); }
+function average(values: number[]): number | null {
+	return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function sum(values: number[]): number {
+	return values.reduce((total, value) => total + value, 0);
+}
 function percentile(values: number[], percentage: number): number | null {
 	if (values.length === 0) return null;
 	const sorted = [...values].sort((left, right) => left - right);
@@ -239,14 +310,14 @@ export function assessContextTelemetry(
 	compactions: StoredMetricObservation[],
 	options: { since: number; until: number; truncated: boolean },
 ): ContextAssessment {
-	const injectionValues = injections.flatMap((row) => typeof row.value === "number" ? [row.value] : []);
+	const injectionValues = injections.flatMap((row) => (typeof row.value === "number" ? [row.value] : []));
 	const shares = injections.flatMap((row) => numericAttribute(row, "share") ?? []);
-	const unchanged = injections.filter((row) => row.attributes["unchanged"] === true).length;
+	const unchanged = injections.filter((row) => row.attributes.unchanged === true).length;
 	const completed = compactions.filter((row) => row.metric === "compaction-duration" && typeof row.value === "number");
 	const aborted = compactions.filter((row) => row.metric === "compaction-aborted");
 	const reasons = { manual: 0, threshold: 0, overflow: 0 };
 	for (const row of completed) {
-		const reason = row.attributes["reason"];
+		const reason = row.attributes.reason;
 		if (reason === "manual" || reason === "threshold" || reason === "overflow") reasons[reason] += 1;
 	}
 	const windowMs = Math.max(0, options.until - options.since);
@@ -302,7 +373,7 @@ export function estimateCompactionDuration(compactions: StoredMetricObservation[
 		.filter((row) => row.source === "pi-context" && row.scope === "compaction" && row.metric === "compaction-duration")
 		.sort((left, right) => right.observedAt - left.observedAt || right.id - left.id)
 		.slice(0, COMPACTION_DURATION_ESTIMATE_MAX_SAMPLES)
-		.flatMap((row) => typeof row.value === "number" && Number.isFinite(row.value) && row.value >= 0 ? [row.value] : []);
+		.flatMap((row) => (typeof row.value === "number" && Number.isFinite(row.value) && row.value >= 0 ? [row.value] : []));
 	if (durations.length < COMPACTION_DURATION_ESTIMATE_MIN_SAMPLES) {
 		return { ms: null, confidence: "cold-start", sampleSize: durations.length, observedAt: now };
 	}

package/src/domain/metric.ts

@@ -1,7 +1,7 @@
 import { METRIC_ATTRIBUTES_MAX_DEPTH, METRIC_ATTRIBUTES_MAX_SERIALIZED_CHARACTERS, METRIC_IDENTITY_MAX_CHARACTERS } from "../constants.ts";
 
 export const METRIC_UNITS = ["ratio", "usd", "tokens", "tokens-per-second", "requests", "milliseconds", "count", "elo"] as const;
-export type MetricUnit = typeof METRIC_UNITS[number];
+export type MetricUnit = (typeof METRIC_UNITS)[number];
 
 export interface MetricObservation {
 	source: string;
@@ -75,21 +75,21 @@ export function validateMetricObservation(value: unknown): MetricObservation {
 		if (typeof input[key] !== "string" || input[key].trim().length === 0) throw new Error(`${key} is required`);
 		if (input[key].length > METRIC_IDENTITY_MAX_CHARACTERS) throw new Error(`${key} exceeds the length limit`);
 	}
-	if (!METRIC_UNITS.includes(input["unit"] as MetricUnit)) throw new Error("unit is not supported");
-	if (input["value"] !== null && (typeof input["value"] !== "number" || !Number.isFinite(input["value"]))) {
+	if (!METRIC_UNITS.includes(input.unit as MetricUnit)) throw new Error("unit is not supported");
+	if (input.value !== null && (typeof input.value !== "number" || !Number.isFinite(input.value))) {
 		throw new Error("value must be finite or null");
 	}
-	if (typeof input["observedAt"] !== "number" || !Number.isSafeInteger(input["observedAt"]) || input["observedAt"] < 0) {
+	if (typeof input.observedAt !== "number" || !Number.isSafeInteger(input.observedAt) || input.observedAt < 0) {
 		throw new Error("observedAt must be a non-negative integer timestamp");
 	}
-	const attributes = validateAttributes(input["attributes"]);
+	const attributes = validateAttributes(input.attributes);
 	return {
-		source: input["source"] as string,
-		scope: input["scope"] as string,
-		metric: input["metric"] as string,
-		value: input["value"] as number | null,
-		unit: input["unit"] as MetricUnit,
-		observedAt: input["observedAt"] as number,
+		source: input.source as string,
+		scope: input.scope as string,
+		metric: input.metric as string,
+		value: input.value as number | null,
+		unit: input.unit as MetricUnit,
+		observedAt: input.observedAt as number,
 		attributes,
 	};
 }

package/src/domain/model-observation.ts

@@ -17,9 +17,9 @@ import type { MetricObservation, MetricUnit, StoredMetricObservation } from "./m
  * research on type simultaneously (e.g. reading a file, then searching the web in one turn).
  */
 export const TASK_DOMAINS = ["coding", "design", "math", "general"] as const;
-export type ModelTaskDomain = typeof TASK_DOMAINS[number];
+export type ModelTaskDomain = (typeof TASK_DOMAINS)[number];
 export const TASK_TYPES = ["research", "planning", "general"] as const;
-export type ModelTaskType = typeof TASK_TYPES[number];
+export type ModelTaskType = (typeof TASK_TYPES)[number];
 export type ExplicitOutcome = "accepted" | "rejected" | "unknown";
 
 export interface ModelRunObservation {
@@ -67,50 +67,80 @@ export interface ModelAggregateOptions {
 }
 
 const ALLOWED_FIELDS = new Set<keyof ModelRunObservation>([
-	"runId", "provider", "model", "thinking", "domain", "type", "startedAt", "firstTokenAt", "completedAt",
-	"inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "costUsd", "providerResponses",
-	"toolCalls", "toolFailures", "stopReason", "explicitOutcome",
+	"runId",
+	"provider",
+	"model",
+	"thinking",
+	"domain",
+	"type",
+	"startedAt",
+	"firstTokenAt",
+	"completedAt",
+	"inputTokens",
+	"outputTokens",
+	"cacheReadTokens",
+	"cacheWriteTokens",
+	"costUsd",
+	"providerResponses",
+	"toolCalls",
+	"toolFailures",
+	"stopReason",
+	"explicitOutcome",
 ]);
 const STOP_REASONS = new Set<ModelRunObservation["stopReason"]>(["stop", "length", "toolUse", "error", "aborted", "unknown"]);
 const OUTCOMES = new Set<ExplicitOutcome>(["accepted", "rejected", "unknown"]);
 
 function text(value: unknown, name: string): string {
-	if (typeof value !== "string" || value.length === 0 || value.length > MODEL_OBSERVATION_IDENTITY_MAX_CHARACTERS || /\p{Cc}/u.test(value)) throw new Error(`${name} is invalid`);
+	if (typeof value !== "string" || value.length === 0 || value.length > MODEL_OBSERVATION_IDENTITY_MAX_CHARACTERS || /\p{Cc}/u.test(value))
+		throw new Error(`${name} is invalid`);
 	return value;
 }
 
 function nonNegative(value: unknown, name: string, integer = false): number {
-	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || (integer && !Number.isSafeInteger(value))) throw new Error(`${name} is invalid`);
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || (integer && !Number.isSafeInteger(value)))
+		throw new Error(`${name} is invalid`);
 	return value;
 }
 
 export function validateModelRunObservation(value: unknown): ModelRunObservation {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("model run observation must be an object");
 	const input = value as Record<string, unknown>;
-	for (const key of Object.keys(input)) if (!ALLOWED_FIELDS.has(key as keyof ModelRunObservation)) throw new Error(`unsupported field: ${key}`);
-	const identity = normalizeModelIdentity(text(input["provider"], "provider"), text(input["model"], "model"));
-	const startedAt = nonNegative(input["startedAt"], "start time", true);
-	const completedAt = nonNegative(input["completedAt"], "completion time", true);
-	const firstTokenAt = input["firstTokenAt"] === null ? null : nonNegative(input["firstTokenAt"], "first-token time", true);
-	if (completedAt < startedAt || (firstTokenAt !== null && (firstTokenAt < startedAt || firstTokenAt > completedAt))) throw new Error("model run timestamps are not ordered");
-	if (!TASK_DOMAINS.includes(input["domain"] as ModelTaskDomain)) throw new Error("task domain is invalid");
-	if (!TASK_TYPES.includes(input["type"] as ModelTaskType)) throw new Error("task type is invalid");
-	if (!STOP_REASONS.has(input["stopReason"] as ModelRunObservation["stopReason"])) throw new Error("stop reason is invalid");
-	if (!OUTCOMES.has(input["explicitOutcome"] as ExplicitOutcome)) throw new Error("explicit outcome is invalid");
-	const providerResponses = nonNegative(input["providerResponses"], "provider response count", true);
-	const toolCalls = nonNegative(input["toolCalls"], "tool call count", true);
-	const toolFailures = nonNegative(input["toolFailures"], "tool failure count", true);
+	for (const key of Object.keys(input))
+		if (!ALLOWED_FIELDS.has(key as keyof ModelRunObservation)) throw new Error(`unsupported field: ${key}`);
+	const identity = normalizeModelIdentity(text(input.provider, "provider"), text(input.model, "model"));
+	const startedAt = nonNegative(input.startedAt, "start time", true);
+	const completedAt = nonNegative(input.completedAt, "completion time", true);
+	const firstTokenAt = input.firstTokenAt === null ? null : nonNegative(input.firstTokenAt, "first-token time", true);
+	if (completedAt < startedAt || (firstTokenAt !== null && (firstTokenAt < startedAt || firstTokenAt > completedAt)))
+		throw new Error("model run timestamps are not ordered");
+	if (!TASK_DOMAINS.includes(input.domain as ModelTaskDomain)) throw new Error("task domain is invalid");
+	if (!TASK_TYPES.includes(input.type as ModelTaskType)) throw new Error("task type is invalid");
+	if (!STOP_REASONS.has(input.stopReason as ModelRunObservation["stopReason"])) throw new Error("stop reason is invalid");
+	if (!OUTCOMES.has(input.explicitOutcome as ExplicitOutcome)) throw new Error("explicit outcome is invalid");
+	const providerResponses = nonNegative(input.providerResponses, "provider response count", true);
+	const toolCalls = nonNegative(input.toolCalls, "tool call count", true);
+	const toolFailures = nonNegative(input.toolFailures, "tool failure count", true);
 	if (providerResponses < 1 || toolFailures > toolCalls) throw new Error("model run counters are inconsistent");
 	return {
-		runId: text(input["runId"], "run id"), provider: identity.provider, model: identity.model,
-		thinking: text(input["thinking"], "thinking level"), domain: input["domain"] as ModelTaskDomain, type: input["type"] as ModelTaskType,
-		startedAt, firstTokenAt, completedAt,
-		inputTokens: nonNegative(input["inputTokens"], "input tokens"),
-		outputTokens: nonNegative(input["outputTokens"], "output tokens"),
-		cacheReadTokens: nonNegative(input["cacheReadTokens"], "cache read tokens"),
-		cacheWriteTokens: nonNegative(input["cacheWriteTokens"], "cache write tokens"),
-		costUsd: nonNegative(input["costUsd"], "cost"), providerResponses, toolCalls, toolFailures,
-		stopReason: input["stopReason"] as ModelRunObservation["stopReason"], explicitOutcome: input["explicitOutcome"] as ExplicitOutcome,
+		runId: text(input.runId, "run id"),
+		provider: identity.provider,
+		model: identity.model,
+		thinking: text(input.thinking, "thinking level"),
+		domain: input.domain as ModelTaskDomain,
+		type: input.type as ModelTaskType,
+		startedAt,
+		firstTokenAt,
+		completedAt,
+		inputTokens: nonNegative(input.inputTokens, "input tokens"),
+		outputTokens: nonNegative(input.outputTokens, "output tokens"),
+		cacheReadTokens: nonNegative(input.cacheReadTokens, "cache read tokens"),
+		cacheWriteTokens: nonNegative(input.cacheWriteTokens, "cache write tokens"),
+		costUsd: nonNegative(input.costUsd, "cost"),
+		providerResponses,
+		toolCalls,
+		toolFailures,
+		stopReason: input.stopReason as ModelRunObservation["stopReason"],
+		explicitOutcome: input.explicitOutcome as ExplicitOutcome,
 	};
 }
 
@@ -122,18 +152,37 @@ export interface ModelTaskClassification {
 /** Domain and type are independent: a run can be domain=coding and type=research at once (e.g. reading a file, then searching the web in the same turn). */
 export function classifyTaskFromTools(toolNames: string[]): ModelTaskClassification {
 	const names = new Set(toolNames.slice(0, 100).map((name) => name.toLowerCase()));
-	const domain: ModelTaskDomain = ["edit", "write", "read", "bash", "grep", "find", "ls"].some((name) => names.has(name)) ? "coding" : "general";
+	const domain: ModelTaskDomain = ["edit", "write", "read", "bash", "grep", "find", "ls"].some((name) => names.has(name))
+		? "coding"
+		: "general";
 	const type: ModelTaskType = ["web_fetch", "web_search"].some((name) => names.has(name))
 		? "research"
-		: ["tasks", "papyrus_create", "papyrus_graph"].some((name) => names.has(name)) ? "planning" : "general";
+		: ["tasks", "papyrus_create", "papyrus_graph"].some((name) => names.has(name))
+			? "planning"
+			: "general";
 	return { domain, type };
 }
 
 export function modelRunMetrics(value: ModelRunObservation): MetricObservation[] {
 	const run = validateModelRunObservation(value);
 	const scope = `${run.provider}/${run.model}`;
-	const attributes = { provider: run.provider, model: run.model, thinking: run.thinking, domain: run.domain, type: run.type, runId: run.runId };
-	const metric = (name: string, amount: number, unit: MetricUnit): MetricObservation => ({ source: "local-model", scope, metric: name, value: amount, unit, observedAt: run.completedAt, attributes });
+	const attributes = {
+		provider: run.provider,
+		model: run.model,
+		thinking: run.thinking,
+		domain: run.domain,
+		type: run.type,
+		runId: run.runId,
+	};
+	const metric = (name: string, amount: number, unit: MetricUnit): MetricObservation => ({
+		source: "local-model",
+		scope,
+		metric: name,
+		value: amount,
+		unit,
+		observedAt: run.completedAt,
+		attributes,
+	});
 	const wallMs = run.completedAt - run.startedAt;
 	const totalInput = run.inputTokens + run.cacheReadTokens;
 	const metrics: MetricObservation[] = [];
@@ -169,35 +218,70 @@ function median(sorted: number[]): number {
 export function aggregateModelMetrics(input: StoredMetricObservation[], options: ModelAggregateOptions = {}): ModelMetricAggregate[] {
 	const now = options.now ?? Date.now();
 	const freshForMs = options.freshForMs ?? MODEL_OBSERVATION_FRESH_MS;
-	if (!Number.isSafeInteger(now) || now < 0 || !Number.isSafeInteger(freshForMs) || freshForMs <= 0) throw new Error("aggregate time bounds are invalid");
+	if (!Number.isSafeInteger(now) || now < 0 || !Number.isSafeInteger(freshForMs) || freshForMs <= 0)
+		throw new Error("aggregate time bounds are invalid");
 	const groups = new Map<string, StoredMetricObservation[]>();
 	for (const row of input.slice(0, MODEL_AGGREGATE_MAX_ROWS)) {
 		if (row.source !== "local-model" || typeof row.value !== "number" || !Number.isFinite(row.value)) continue;
-		const provider = row.attributes["provider"];
-		const model = row.attributes["model"];
-		const thinking = row.attributes["thinking"];
-		const domain = row.attributes["domain"];
-		const type = row.attributes["type"];
-		if (typeof provider !== "string" || typeof model !== "string" || typeof thinking !== "string" || !TASK_DOMAINS.includes(domain as ModelTaskDomain) || !TASK_TYPES.includes(type as ModelTaskType)) continue;
+		const provider = row.attributes.provider;
+		const model = row.attributes.model;
+		const thinking = row.attributes.thinking;
+		const domain = row.attributes.domain;
+		const type = row.attributes.type;
+		if (
+			typeof provider !== "string" ||
+			typeof model !== "string" ||
+			typeof thinking !== "string" ||
+			!TASK_DOMAINS.includes(domain as ModelTaskDomain) ||
+			!TASK_TYPES.includes(type as ModelTaskType)
+		)
+			continue;
 		const key = JSON.stringify([provider, model, thinking, domain, type, row.metric, row.unit]);
 		if (!groups.has(key) && groups.size >= MODEL_AGGREGATE_MAX_GROUPS) continue;
 		const rows = groups.get(key) ?? [];
 		rows.push(row);
 		groups.set(key, rows);
 	}
-	return [...groups.entries()].map(([key, rows]) => {
-		const [provider, model, thinking, domain, type, dimension, unit] = JSON.parse(key) as [string, string, string, ModelTaskDomain, ModelTaskType, string, MetricUnit];
-		const values = rows.map((row) => row.value as number).sort((left, right) => left - right);
-		const center = median(values);
-		const deviations = values.map((value) => Math.abs(value - center)).sort((left, right) => left - right);
-		const latestAt = Math.max(...rows.map((row) => row.observedAt));
-		const age = Math.max(0, now - latestAt);
-		const recency = Math.max(0, 1 - (age / freshForMs));
-		return {
-			provider, model, thinking, domain, type, dimension, unit,
-			sampleSize: values.length, median: center, p90: percentile(values, 0.9), medianAbsoluteDeviation: median(deviations), latestAt,
-			freshness: age <= freshForMs ? "fresh" as const : "stale" as const,
-			confidence: Math.min(1, Math.sqrt(values.length / 20)) * recency,
-		};
-	}).sort((left, right) => left.provider.localeCompare(right.provider) || left.model.localeCompare(right.model) || left.domain.localeCompare(right.domain) || left.type.localeCompare(right.type) || left.dimension.localeCompare(right.dimension));
+	return [...groups.entries()]
+		.map(([key, rows]) => {
+			const [provider, model, thinking, domain, type, dimension, unit] = JSON.parse(key) as [
+				string,
+				string,
+				string,
+				ModelTaskDomain,
+				ModelTaskType,
+				string,
+				MetricUnit,
+			];
+			const values = rows.map((row) => row.value as number).sort((left, right) => left - right);
+			const center = median(values);
+			const deviations = values.map((value) => Math.abs(value - center)).sort((left, right) => left - right);
+			const latestAt = Math.max(...rows.map((row) => row.observedAt));
+			const age = Math.max(0, now - latestAt);
+			const recency = Math.max(0, 1 - age / freshForMs);
+			return {
+				provider,
+				model,
+				thinking,
+				domain,
+				type,
+				dimension,
+				unit,
+				sampleSize: values.length,
+				median: center,
+				p90: percentile(values, 0.9),
+				medianAbsoluteDeviation: median(deviations),
+				latestAt,
+				freshness: age <= freshForMs ? ("fresh" as const) : ("stale" as const),
+				confidence: Math.min(1, Math.sqrt(values.length / 20)) * recency,
+			};
+		})
+		.sort(
+			(left, right) =>
+				left.provider.localeCompare(right.provider) ||
+				left.model.localeCompare(right.model) ||
+				left.domain.localeCompare(right.domain) ||
+				left.type.localeCompare(right.type) ||
+				left.dimension.localeCompare(right.dimension),
+		);
 }

package/src/domain/model-ranking-service.ts

@@ -1,9 +1,15 @@
 import { MODEL_AGGREGATE_MAX_ROWS, MODEL_OBSERVATION_FRESH_MS, MODEL_RANKING_MAX_SOURCES } from "../constants.ts";
 import type { BenchmarkStore } from "../ports/benchmark-store.ts";
 import type { MetricStore } from "../ports/metric-store.ts";
-import { aggregateModelMetrics } from "./model-observation.ts";
-import { rankModelCandidates, type ModelCandidate, type ModelRankingResult, type ScopeAuthority, type UtilityWeights } from "./model-ranking.ts";
 import type { ModelTaskDomain, ModelTaskType } from "./model-observation.ts";
+import { aggregateModelMetrics } from "./model-observation.ts";
+import {
+	type ModelCandidate,
+	type ModelRankingResult,
+	rankModelCandidates,
+	type ScopeAuthority,
+	type UtilityWeights,
+} from "./model-ranking.ts";
 
 export interface ModelRecommendationInput {
 	candidates: ModelCandidate[];
@@ -27,7 +33,11 @@ export class EvidenceModelRanker implements ModelRanker {
 	) {}
 
 	rank(input: ModelRecommendationInput): ModelRankingResult {
-		if (!Array.isArray(input.sourceIds) || input.sourceIds.length > MODEL_RANKING_MAX_SOURCES || !input.sourceIds.every((sourceId) => typeof sourceId === "string" && sourceId.length > 0 && sourceId.length <= 160)) {
+		if (
+			!Array.isArray(input.sourceIds) ||
+			input.sourceIds.length > MODEL_RANKING_MAX_SOURCES ||
+			!input.sourceIds.every((sourceId) => typeof sourceId === "string" && sourceId.length > 0 && sourceId.length <= 160)
+		) {
 			throw new Error("benchmark source selection is invalid");
 		}
 		const sourceIds = [...new Set(input.sourceIds)];