@danypops/jittor 0.13.0 → 0.15.0

package/src/domain/model-ranking.ts

@@ -1,6 +1,6 @@
 import { BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT, MAX_DYNAMIC_ROUTES, MODEL_AGGREGATE_MAX_ROWS } from "../constants.ts";
-import { normalizeModelIdentity, type BenchmarkObservation } from "./benchmark.ts";
-import { TASK_DOMAINS, TASK_TYPES, type ModelMetricAggregate, type ModelTaskDomain, type ModelTaskType } from "./model-observation.ts";
+import { type BenchmarkObservation, normalizeModelIdentity } from "./benchmark.ts";
+import { type ModelMetricAggregate, type ModelTaskDomain, type ModelTaskType, TASK_DOMAINS, TASK_TYPES } from "./model-observation.ts";
 
 export type ScopeAuthority = "exact-session" | "available-models";
 export type UtilityComponentName = "quality" | "cost" | "latency" | "context" | "reliability";
@@ -85,7 +85,8 @@ function finiteBound(value: number, name: string, minimum: number, maximum: numb
 
 function candidateIdentity(candidate: ModelCandidate): string {
 	const identity = normalizeModelIdentity(candidate.provider, candidate.model);
-	if (typeof candidate.thinking !== "string" || candidate.thinking.length === 0 || candidate.thinking.length > 160) throw new Error("candidate thinking level is invalid");
+	if (typeof candidate.thinking !== "string" || candidate.thinking.length === 0 || candidate.thinking.length > 160)
+		throw new Error("candidate thinking level is invalid");
 	return `${identity.canonical}:${candidate.thinking}`;
 }
 
@@ -93,19 +94,48 @@ function average(values: number[]): number {
 	return values.reduce((sum, value) => sum + value, 0) / values.length;
 }
 
-function externalValues(candidate: ModelCandidate, evidence: BenchmarkObservation[], dimensions: string[], now: number): { values: number[]; confidences: number[]; provenance: RankingProvenance[] } {
+function externalValues(
+	candidate: ModelCandidate,
+	evidence: BenchmarkObservation[],
+	dimensions: string[],
+	now: number,
+): { values: number[]; confidences: number[]; provenance: RankingProvenance[] } {
 	const identity = normalizeModelIdentity(candidate.provider, candidate.model);
-	const matching = evidence.filter((item) => (item.model.canonical === identity.canonical || item.model.aliases.includes(identity.canonical)) && dimensions.includes(item.dimension));
+	const matching = evidence.filter(
+		(item) =>
+			(item.model.canonical === identity.canonical || item.model.aliases.includes(identity.canonical)) &&
+			dimensions.includes(item.dimension),
+	);
 	return {
 		values: matching.map((item) => item.value),
 		confidences: matching.map((item) => item.provenance.confidence * (now <= item.provenance.freshUntil ? 1 : 0.25)),
-		provenance: matching.map((item) => ({ sourceId: item.provenance.sourceId, publisher: item.provenance.publisher, url: item.provenance.url, revision: item.provenance.revision, freshness: now <= item.provenance.freshUntil ? "fresh" : "stale" })),
+		provenance: matching.map((item) => ({
+			sourceId: item.provenance.sourceId,
+			publisher: item.provenance.publisher,
+			url: item.provenance.url,
+			revision: item.provenance.revision,
+			freshness: now <= item.provenance.freshUntil ? "fresh" : "stale",
+		})),
 	};
 }
 
-function localValues(candidate: ModelCandidate, domain: ModelTaskDomain, type: ModelTaskType, evidence: ModelMetricAggregate[], dimension: string): ModelMetricAggregate[] {
+function localValues(
+	candidate: ModelCandidate,
+	domain: ModelTaskDomain,
+	type: ModelTaskType,
+	evidence: ModelMetricAggregate[],
+	dimension: string,
+): ModelMetricAggregate[] {
 	const identity = normalizeModelIdentity(candidate.provider, candidate.model);
-	return evidence.filter((item) => item.provider === identity.provider && item.model === identity.model && item.thinking === candidate.thinking && item.domain === domain && item.type === type && item.dimension === dimension);
+	return evidence.filter(
+		(item) =>
+			item.provider === identity.provider &&
+			item.model === identity.model &&
+			item.thinking === candidate.thinking &&
+			item.domain === domain &&
+			item.type === type &&
+			item.dimension === dimension,
+	);
 }
 
 /**
@@ -123,7 +153,10 @@ function qualityDimensions(domain: ModelTaskDomain, type: ModelTaskType): string
 	return dimensions;
 }
 
-function rawComponents(candidate: ModelCandidate, input: ModelRankingInput): { components: Record<UtilityComponentName, RawComponent>; provenance: RankingProvenance[] } {
+function rawComponents(
+	candidate: ModelCandidate,
+	input: ModelRankingInput,
+): { components: Record<UtilityComponentName, RawComponent>; provenance: RankingProvenance[] } {
 	const quality = externalValues(candidate, input.externalEvidence, qualityDimensions(input.domain, input.type), input.now);
 	const priceInput = externalValues(candidate, input.externalEvidence, ["price-input"], input.now);
 	const priceOutput = externalValues(candidate, input.externalEvidence, ["price-output"], input.now);
@@ -139,23 +172,33 @@ function rawComponents(candidate: ModelCandidate, input: ModelRankingInput): { c
 	const latencyValues = localLatency.length > 0 ? localLatency.map((item) => item.median) : latency.values;
 	const latencyConfidences = localLatency.length > 0 ? localLatency.map((item) => item.confidence) : latency.confidences;
 	const reliabilityValues = [...failures.map((item) => 1 - item.median), ...outcomes.map((item) => item.median)];
-	const withEvidence = (values: number[], confidences: number[], lowerIsBetter: boolean, label: string): RawComponent => values.length === 0
-		? { value: null, confidence: 0, evidenceCount: 0, reason: `${label} evidence is missing`, lowerIsBetter }
-		: {
-			value: average(values),
-			confidence: average(confidences) / (1 + ((Math.max(...values) - Math.min(...values)) / Math.max(Math.abs(average(values)), Number.EPSILON))),
-			evidenceCount: values.length,
-			reason: `${values.length} ${label} observation${values.length === 1 ? "" : "s"}`,
-			lowerIsBetter,
-		};
+	const withEvidence = (values: number[], confidences: number[], lowerIsBetter: boolean, label: string): RawComponent =>
+		values.length === 0
+			? { value: null, confidence: 0, evidenceCount: 0, reason: `${label} evidence is missing`, lowerIsBetter }
+			: {
+					value: average(values),
+					confidence:
+						average(confidences) / (1 + (Math.max(...values) - Math.min(...values)) / Math.max(Math.abs(average(values)), Number.EPSILON)),
+					evidenceCount: values.length,
+					reason: `${values.length} ${label} observation${values.length === 1 ? "" : "s"}`,
+					lowerIsBetter,
+				};
 	const components: Record<UtilityComponentName, RawComponent> = {
 		quality: withEvidence(qualityValues, quality.confidences, false, "task quality"),
 		cost: withEvidence(prices, [...priceInput.confidences, ...priceOutput.confidences], true, "price"),
 		latency: withEvidence(latencyValues, latencyConfidences, true, "latency"),
 		context: withEvidence(context.values, context.confidences, false, "context window"),
-		reliability: withEvidence(reliabilityValues, [...failures, ...outcomes].map((item) => item.confidence), false, "local reliability"),
+		reliability: withEvidence(
+			reliabilityValues,
+			[...failures, ...outcomes].map((item) => item.confidence),
+			false,
+			"local reliability",
+		),
+	};
+	return {
+		components,
+		provenance: [...quality.provenance, ...priceInput.provenance, ...priceOutput.provenance, ...latency.provenance, ...context.provenance],
 	};
-	return { components, provenance: [...quality.provenance, ...priceInput.provenance, ...priceOutput.provenance, ...latency.provenance, ...context.provenance] };
 }
 
 function normalizedScore(value: number, values: number[], lowerIsBetter: boolean): number {
@@ -167,55 +210,78 @@ function normalizedScore(value: number, values: number[], lowerIsBetter: boolean
 }
 
 export function rankModelCandidates(value: ModelRankingInput): ModelRankingResult {
-	if (!Array.isArray(value.candidates) || value.candidates.length === 0 || value.candidates.length > MAX_DYNAMIC_ROUTES) throw new Error("candidate count is outside its supported range");
-	if (!Array.isArray(value.externalEvidence) || value.externalEvidence.length > BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT * 4) throw new Error("external evidence exceeds the supported bound");
-	if (!Array.isArray(value.localEvidence) || value.localEvidence.length > MODEL_AGGREGATE_MAX_ROWS) throw new Error("local evidence exceeds the supported bound");
-	if (value.scopeAuthority !== "exact-session" && value.scopeAuthority !== "available-models") throw new Error("scope authority is invalid");
+	if (!Array.isArray(value.candidates) || value.candidates.length === 0 || value.candidates.length > MAX_DYNAMIC_ROUTES)
+		throw new Error("candidate count is outside its supported range");
+	if (!Array.isArray(value.externalEvidence) || value.externalEvidence.length > BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT * 4)
+		throw new Error("external evidence exceeds the supported bound");
+	if (!Array.isArray(value.localEvidence) || value.localEvidence.length > MODEL_AGGREGATE_MAX_ROWS)
+		throw new Error("local evidence exceeds the supported bound");
+	if (value.scopeAuthority !== "exact-session" && value.scopeAuthority !== "available-models")
+		throw new Error("scope authority is invalid");
 	if (!TASK_DOMAINS.includes(value.domain)) throw new Error("task domain is invalid");
 	if (!TASK_TYPES.includes(value.type)) throw new Error("task type is invalid");
 	if (!Number.isSafeInteger(value.now) || value.now <= 0) throw new Error("ranking time is invalid");
 	const budgetPressure = finiteBound(value.budgetPressure, "budget pressure", 0, 2);
-	const weights = Object.fromEntries(COMPONENTS.map((name) => [name, finiteBound(value.weights[name], `${name} weight`, 0, 10)])) as unknown as UtilityWeights;
+	const weights = Object.fromEntries(
+		COMPONENTS.map((name) => [name, finiteBound(value.weights[name], `${name} weight`, 0, 10)]),
+	) as unknown as UtilityWeights;
 	const seen = new Set<string>();
-	const candidates = value.candidates.map((candidate) => ({ ...candidate })).filter((candidate) => {
-		const identity = candidateIdentity(candidate);
-		if (seen.has(identity)) return false;
-		seen.add(identity);
-		return true;
-	});
+	const candidates = value.candidates
+		.map((candidate) => ({ ...candidate }))
+		.filter((candidate) => {
+			const identity = candidateIdentity(candidate);
+			if (seen.has(identity)) return false;
+			seen.add(identity);
+			return true;
+		});
 	const raw = candidates.map((candidate) => rawComponents(candidate, value));
 	const effectiveWeights: UtilityWeights = { ...weights, cost: weights.cost * (1 + budgetPressure) };
-	const ranked = candidates.map((candidate, index): RankedModel => {
-		const source = raw[index]!;
-		const components = COMPONENTS.map((name): UtilityComponent => {
-			const component = source.components[name];
-			const comparable = raw.map((item) => item.components[name].value).filter((item): item is number => item !== null);
+	const ranked = candidates
+		.map((candidate, index): RankedModel => {
+			const source = raw[index]!;
+			const components = COMPONENTS.map((name): UtilityComponent => {
+				const component = source.components[name];
+				const comparable = raw.map((item) => item.components[name].value).filter((item): item is number => item !== null);
+				return {
+					name,
+					score: component.value === null ? null : normalizedScore(component.value, comparable, component.lowerIsBetter),
+					confidence: component.confidence,
+					weight: effectiveWeights[name],
+					evidenceCount: component.evidenceCount,
+					reason: component.reason,
+				};
+			});
+			const known = components.filter(
+				(component): component is UtilityComponent & { score: number } => component.score !== null && component.weight > 0,
+			);
+			const knownWeight = known.reduce((sum, component) => sum + component.weight, 0);
+			const totalWeight = components.reduce((sum, component) => sum + component.weight, 0);
+			const utility =
+				knownWeight === 0 ? null : known.reduce((sum, component) => sum + component.score * component.weight, 0) / knownWeight;
+			const confidence =
+				totalWeight === 0 ? 0 : known.reduce((sum, component) => sum + component.confidence * component.weight, 0) / totalWeight;
+			const provenance = [
+				...new Map(source.provenance.map((item) => [`${item.sourceId}:${item.revision}:${item.url}`, item])).values(),
+			].sort((left, right) => left.sourceId.localeCompare(right.sourceId) || left.revision.localeCompare(right.revision));
 			return {
-				name,
-				score: component.value === null ? null : normalizedScore(component.value, comparable, component.lowerIsBetter),
-				confidence: component.confidence,
-				weight: effectiveWeights[name],
-				evidenceCount: component.evidenceCount,
-				reason: component.reason,
+				candidate,
+				identity: candidateIdentity(candidate),
+				utility,
+				confidence,
+				components,
+				provenance,
+				trace: [
+					`domain ${value.domain}, type ${value.type}`,
+					`budget pressure ${budgetPressure.toFixed(3)} makes cost weight ${effectiveWeights.cost.toFixed(3)}`,
+					`${known.length}/${components.length} utility components have evidence`,
+					`scope authority ${value.scopeAuthority}`,
+				],
 			};
-		});
-		const known = components.filter((component): component is UtilityComponent & { score: number } => component.score !== null && component.weight > 0);
-		const knownWeight = known.reduce((sum, component) => sum + component.weight, 0);
-		const totalWeight = components.reduce((sum, component) => sum + component.weight, 0);
-		const utility = knownWeight === 0 ? null : known.reduce((sum, component) => sum + (component.score * component.weight), 0) / knownWeight;
-		const confidence = totalWeight === 0 ? 0 : known.reduce((sum, component) => sum + (component.confidence * component.weight), 0) / totalWeight;
-		const provenance = [...new Map(source.provenance.map((item) => [`${item.sourceId}:${item.revision}:${item.url}`, item])).values()]
-			.sort((left, right) => left.sourceId.localeCompare(right.sourceId) || left.revision.localeCompare(right.revision));
-		return {
-			candidate,
-			identity: candidateIdentity(candidate),
-			utility,
-			confidence,
-			components,
-			provenance,
-			trace: [`domain ${value.domain}, type ${value.type}`, `budget pressure ${budgetPressure.toFixed(3)} makes cost weight ${effectiveWeights.cost.toFixed(3)}`, `${known.length}/${components.length} utility components have evidence`, `scope authority ${value.scopeAuthority}`],
-		};
-	}).sort((left, right) => (right.utility ?? -1) - (left.utility ?? -1) || right.confidence - left.confidence || left.identity.localeCompare(right.identity));
+		})
+		.sort(
+			(left, right) =>
+				(right.utility ?? -1) - (left.utility ?? -1) || right.confidence - left.confidence || left.identity.localeCompare(right.identity),
+		);
 	const knownComponents = ranked.reduce((sum, item) => sum + item.components.filter((component) => component.score !== null).length, 0);
 	const possibleComponents = ranked.length * COMPONENTS.length;
 	const completeness = knownComponents === 0 ? "insufficient-evidence" : knownComponents === possibleComponents ? "complete" : "partial";

package/src/domain/task-cost.ts

@@ -44,7 +44,15 @@ function attributeText(attributes: Record<string, unknown>, key: string): string
 function entryFor(byTask: Map<string, TaskCostEntry>, taskId: string): TaskCostEntry {
 	const existing = byTask.get(taskId);
 	if (existing) return existing;
-	const created: TaskCostEntry = { taskId, costUsd: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, byModel: [] };
+	const created: TaskCostEntry = {
+		taskId,
+		costUsd: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		byModel: [],
+	};
 	byTask.set(taskId, created);
 	return created;
 }
@@ -53,7 +61,16 @@ function breakdownFor(byModel: Map<string, TaskCostBreakdown>, provider: string,
 	const key = `${provider}\u0000${model}\u0000${thinking}`;
 	const existing = byModel.get(key);
 	if (existing) return existing;
-	const created: TaskCostBreakdown = { provider, model, thinking, costUsd: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+	const created: TaskCostBreakdown = {
+		provider,
+		model,
+		thinking,
+		costUsd: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+	};
 	byModel.set(key, created);
 	return created;
 }
@@ -80,25 +97,49 @@ export function buildTaskCostSummary(rows: StoredMetricObservation[], options: T
 	for (const row of rows) {
 		if (row.source !== "pi" || typeof row.value !== "number" || !Number.isFinite(row.value) || row.value < 0) continue;
 		if (row.observedAt < options.since || row.observedAt > options.until) continue;
-		const taskId = typeof row.attributes["taskId"] === "string" ? row.attributes["taskId"] : undefined;
+		const taskId = typeof row.attributes.taskId === "string" ? row.attributes.taskId : undefined;
 		if (row.metric === "cost" && row.unit === "usd") {
-			if (taskId === undefined) { unattributedCostUsd += row.value; continue; }
+			if (taskId === undefined) {
+				unattributedCostUsd += row.value;
+				continue;
+			}
 			entryFor(byTask, taskId).costUsd += row.value;
 			if (!byTaskModel.has(taskId)) byTaskModel.set(taskId, new Map());
-			breakdownFor(byTaskModel.get(taskId)!, attributeText(row.attributes, "provider"), attributeText(row.attributes, "model"), attributeText(row.attributes, "thinking")).costUsd += row.value;
+			breakdownFor(
+				byTaskModel.get(taskId)!,
+				attributeText(row.attributes, "provider"),
+				attributeText(row.attributes, "model"),
+				attributeText(row.attributes, "thinking"),
+			).costUsd += row.value;
 			continue;
 		}
 		if (taskId === undefined || row.unit !== "tokens" || !TOKEN_METRICS.has(row.metric)) continue;
 		const entry = entryFor(byTask, taskId);
 		if (!byTaskModel.has(taskId)) byTaskModel.set(taskId, new Map());
-		const breakdown = breakdownFor(byTaskModel.get(taskId)!, attributeText(row.attributes, "provider"), attributeText(row.attributes, "model"), attributeText(row.attributes, "thinking"));
-		if (row.metric === "input-tokens") { entry.inputTokens += row.value; breakdown.inputTokens += row.value; }
-		else if (row.metric === "output-tokens") { entry.outputTokens += row.value; breakdown.outputTokens += row.value; }
-		else if (row.metric === "cache-read-tokens") { entry.cacheReadTokens += row.value; breakdown.cacheReadTokens += row.value; }
-		else { entry.cacheWriteTokens += row.value; breakdown.cacheWriteTokens += row.value; }
+		const breakdown = breakdownFor(
+			byTaskModel.get(taskId)!,
+			attributeText(row.attributes, "provider"),
+			attributeText(row.attributes, "model"),
+			attributeText(row.attributes, "thinking"),
+		);
+		if (row.metric === "input-tokens") {
+			entry.inputTokens += row.value;
+			breakdown.inputTokens += row.value;
+		} else if (row.metric === "output-tokens") {
+			entry.outputTokens += row.value;
+			breakdown.outputTokens += row.value;
+		} else if (row.metric === "cache-read-tokens") {
+			entry.cacheReadTokens += row.value;
+			breakdown.cacheReadTokens += row.value;
+		} else {
+			entry.cacheWriteTokens += row.value;
+			breakdown.cacheWriteTokens += row.value;
+		}
 	}
 	for (const [taskId, entry] of byTask) {
-		entry.byModel = [...(byTaskModel.get(taskId)?.values() ?? [])].sort((left, right) => right.costUsd - left.costUsd || left.model.localeCompare(right.model));
+		entry.byModel = [...(byTaskModel.get(taskId)?.values() ?? [])].sort(
+			(left, right) => right.costUsd - left.costUsd || left.model.localeCompare(right.model),
+		);
 	}
 	const entries = [...byTask.values()].sort((left, right) => right.costUsd - left.costUsd || left.taskId.localeCompare(right.taskId));
 	return { since: options.since, until: options.until, entries, unattributedCostUsd, truncated: options.truncated === true };

package/src/domain/task-focus.ts

@@ -16,12 +16,14 @@ const STATUSES = new Set<string>(["focused", "paused", "unpaused", "cleared"]);
 function record(value: unknown): Record<string, unknown> {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("task-focus event must be an object");
 	const result = value as Record<string, unknown>;
-	for (const key of Object.keys(result)) if (!TOP_LEVEL_FIELDS.has(key)) throw new Error(`task-focus event contains unexpected field: ${key}`);
+	for (const key of Object.keys(result))
+		if (!TOP_LEVEL_FIELDS.has(key)) throw new Error(`task-focus event contains unexpected field: ${key}`);
 	return result;
 }
 
 function boundedId(value: unknown, name: string): string {
-	if (typeof value !== "string" || value.length === 0 || value.length > TASK_FOCUS_ID_MAX_LENGTH) throw new Error(`${name} must be a non-empty bounded string`);
+	if (typeof value !== "string" || value.length === 0 || value.length > TASK_FOCUS_ID_MAX_LENGTH)
+		throw new Error(`${name} must be a non-empty bounded string`);
 	return value;
 }
 
@@ -34,16 +36,17 @@ function boundedId(value: unknown, name: string): string {
  */
 export function validateTaskFocusEvent(value: unknown, now = Date.now()): TaskFocusEvent {
 	const input = record(value);
-	if (input["schema"] !== PAPYRUS_TASK_FOCUS_SCHEMA) throw new Error("task-focus event schema is not supported");
-	const status = input["status"];
+	if (input.schema !== PAPYRUS_TASK_FOCUS_SCHEMA) throw new Error("task-focus event schema is not supported");
+	const status = input.status;
 	if (typeof status !== "string" || !STATUSES.has(status)) throw new Error("task-focus event status is not supported");
-	const observedAt = input["observedAt"];
-	if (typeof observedAt !== "number" || !Number.isSafeInteger(observedAt) || observedAt < 0) throw new Error("task-focus event observedAt must be a non-negative integer");
+	const observedAt = input.observedAt;
+	if (typeof observedAt !== "number" || !Number.isSafeInteger(observedAt) || observedAt < 0)
+		throw new Error("task-focus event observedAt must be a non-negative integer");
 	if (Math.abs(now - observedAt) > TASK_FOCUS_EVENT_MAX_AGE_MS) throw new Error("task-focus event is stale");
-	const rawTaskId = input["taskId"];
+	const rawTaskId = input.taskId;
 	const taskId = rawTaskId === null ? null : boundedId(rawTaskId, "taskId");
 	if (taskId === null && status !== "cleared") throw new Error(`task-focus event of status "${status}" requires a taskId`);
-	const rawSessionId = input["sessionId"];
+	const rawSessionId = input.sessionId;
 	const sessionId = rawSessionId === undefined ? undefined : boundedId(rawSessionId, "sessionId");
 	return {
 		schema: PAPYRUS_TASK_FOCUS_SCHEMA,

package/src/domain/usage.ts

@@ -7,9 +7,9 @@ export const USAGE_PERIODS = [
 	{ id: "monthly", label: "Monthly", windowMs: 30 * MILLISECONDS_PER_DAY, bucketCount: 30 },
 	{ id: "quarterly", label: "Quarterly", windowMs: 90 * MILLISECONDS_PER_DAY, bucketCount: 90 },
 ] as const;
-export type UsagePeriod = typeof USAGE_PERIODS[number]["id"];
+export type UsagePeriod = (typeof USAGE_PERIODS)[number]["id"];
 
-export function usagePeriod(period: UsagePeriod): typeof USAGE_PERIODS[number] {
+export function usagePeriod(period: UsagePeriod): (typeof USAGE_PERIODS)[number] {
 	return USAGE_PERIODS.find((candidate) => candidate.id === period)!;
 }
 

package/src/index.ts

@@ -1,51 +1,44 @@
-export * from "./constants.ts";
 export {
+	connectJittorClient,
 	type FetchTransport,
 	JittorClient,
-	connectJittorClient,
 } from "./client.ts";
+export * from "./constants.ts";
 export {
-	EXPECTED_OPERATION_NAMES,
-	InvalidSessionSecretError,
-	JittorService,
-	UnknownOperationError,
-	createApp,
-	type JittorAppOptions,
-	type OperationInputs,
-	type OperationName,
-	type OperationOutputs,
-} from "./service.ts";
-export {
-	type CompactionDurationEstimate,
-	type CompactionStart,
-	CompactionTelemetry,
-	type ContextAssessment,
-	type PapyrusContextInjection,
-	assessContextTelemetry,
-	estimateCompactionDuration,
-	papyrusContextMetric,
-	validatePapyrusContextInjection,
-} from "./domain/context-telemetry.ts";
-export {
-	type TaskFocusEvent,
-	type TaskFocusStatus,
-	applyTaskFocusEvent,
-	validateTaskFocusEvent,
-} from "./domain/task-focus.ts";
+	type CodexFailure,
+	type CodexFailureKind,
+	type CodexFailureMetadata,
+	type CodexRecoveryAttempt,
+	type CodexRecoveryOptions,
+	type CodexRecoveryPlan,
+	CodexRecoveryPolicy,
+	classifyCodexFailure,
+} from "./domain/codex-recovery.ts";
 export {
 	type ContextConfidenceTier,
 	type ContextContribution,
 	type ContextSegment,
 	type ContextSegmentItem,
+	computeToolSchemaLedger,
+	contextContributionMetric,
 	type ToolLedgerEntry,
 	type ToolLedgerSourceUsage,
 	type ToolLedgerToolUsage,
-	computeToolSchemaLedger,
-	contextContributionMetric,
 	toolLedgerSegment,
 	validateContextContribution,
 	validateContextSegment,
 } from "./domain/context-hub.ts";
+export {
+	assessContextTelemetry,
+	type CompactionDurationEstimate,
+	type CompactionStart,
+	CompactionTelemetry,
+	type ContextAssessment,
+	estimateCompactionDuration,
+	type PapyrusContextInjection,
+	papyrusContextMetric,
+	validatePapyrusContextInjection,
+} from "./domain/context-telemetry.ts";
 export {
 	METRIC_UNITS,
 	type MetricObservation,
@@ -55,8 +48,8 @@ export {
 	validateMetricObservation,
 } from "./domain/metric.ts";
 export {
-	TASK_DOMAINS,
-	TASK_TYPES,
+	aggregateModelMetrics,
+	classifyTaskFromTools,
 	type ExplicitOutcome,
 	type ModelAggregateOptions,
 	type ModelMetricAggregate,
@@ -64,9 +57,9 @@ export {
 	type ModelTaskClassification,
 	type ModelTaskDomain,
 	type ModelTaskType,
-	aggregateModelMetrics,
-	classifyTaskFromTools,
 	modelRunMetrics,
+	TASK_DOMAINS,
+	TASK_TYPES,
 	validateModelRunObservation,
 } from "./domain/model-observation.ts";
 export {
@@ -75,17 +68,27 @@ export {
 	type ModelRankingResult,
 	type RankedModel,
 	type RankingProvenance,
+	rankModelCandidates,
 	type ScopeAuthority,
 	type UtilityComponent,
 	type UtilityComponentName,
 	type UtilityWeights,
-	rankModelCandidates,
 } from "./domain/model-ranking.ts";
 export {
-	USAGE_PERIODS,
+	applyTaskFocusEvent,
+	type TaskFocusEvent,
+	type TaskFocusStatus,
+	validateTaskFocusEvent,
+} from "./domain/task-focus.ts";
+export {
+	buildCostGraph,
+	buildUsageGraph,
 	type CostBucket,
 	type CostGraph,
 	type CostSeries,
+	identity,
+	resolveUsageWindow,
+	USAGE_PERIODS,
 	type UsageAggregateRow,
 	type UsageBreakdown,
 	type UsageBucket,
@@ -94,43 +97,13 @@ export {
 	type UsageGraphOptions,
 	type UsagePeriod,
 	type UsageSeries,
-	buildCostGraph,
-	buildUsageGraph,
-	identity,
-	resolveUsageWindow,
 	usageBucketIndex,
 	usagePeriod,
 	usagePeriodStart,
 } from "./domain/usage.ts";
 export {
-	CodexRecoveryPolicy,
-	classifyCodexFailure,
-	type CodexFailure,
-	type CodexFailureKind,
-	type CodexFailureMetadata,
-	type CodexRecoveryAttempt,
-	type CodexRecoveryOptions,
-	type CodexRecoveryPlan,
-} from "./domain/codex-recovery.ts";
-export {
-	hasAnthropicRateLimitHeaders,
-	parseAnthropicRateLimitHeaders,
-	type AnthropicMetricSource,
-	type AnthropicRateLimitSnapshot,
-	type AnthropicRateLimitWindow,
-} from "./providers/anthropic-contracts.ts";
-export { parseCodexRateLimitHeaders } from "./providers/codex.ts";
-export {
-	classifyGoogleVertexFailure,
-	googleVertexFailureMetrics,
-	type GoogleVertexFailure,
-	type GoogleVertexFailureKind,
-	type GoogleVertexFailureMetadata,
-	type GoogleVertexMetricSource,
-} from "./providers/google-vertex-contracts.ts";
-export {
-	evaluateRoutingPolicy,
 	type BudgetWindow,
+	evaluateRoutingPolicy,
 	type PolicyAction,
 	type PolicyConfig,
 	type PolicyDecision,
@@ -140,6 +113,7 @@ export {
 	type Route,
 	type TelemetryFreshness,
 } from "./policy.ts";
+export type { DistinctScopesFilter, MetricStore, UsageAggregateFilter } from "./ports/metric-store.ts";
 export type {
 	RouteOverride,
 	RouterController,
@@ -147,5 +121,31 @@ export type {
 	TelemetryPollResult,
 	TelemetrySourceStatus,
 } from "./ports/router-controller.ts";
-export type { DistinctScopesFilter, MetricStore, UsageAggregateFilter } from "./ports/metric-store.ts";
+export {
+	type AnthropicMetricSource,
+	type AnthropicRateLimitSnapshot,
+	type AnthropicRateLimitWindow,
+	hasAnthropicRateLimitHeaders,
+	parseAnthropicRateLimitHeaders,
+} from "./providers/anthropic-contracts.ts";
+export { parseCodexRateLimitHeaders } from "./providers/codex.ts";
+export {
+	classifyGoogleVertexFailure,
+	type GoogleVertexFailure,
+	type GoogleVertexFailureKind,
+	type GoogleVertexFailureMetadata,
+	type GoogleVertexMetricSource,
+	googleVertexFailureMetrics,
+} from "./providers/google-vertex-contracts.ts";
+export {
+	createApp,
+	EXPECTED_OPERATION_NAMES,
+	InvalidSessionSecretError,
+	type JittorAppOptions,
+	JittorService,
+	type OperationInputs,
+	type OperationName,
+	type OperationOutputs,
+	UnknownOperationError,
+} from "./service.ts";
 export { VERSION as jittorVersion } from "./version.ts";

package/src/log.ts

@@ -8,7 +8,7 @@
  * four daemons. `component`/`level`/`timestamp` and credential-safety (callers still must pass
  * only bounded, non-sensitive fields) are unchanged.
  */
-import { createLogger, type LogLevel as VehicleLogLevel, type Logger } from "@danypops/vehicle-server/logging";
+import { createLogger, type Logger, type LogLevel as VehicleLogLevel } from "@danypops/vehicle-server/logging";
 
 export type LogLevel = Extract<VehicleLogLevel, "info" | "warn" | "error">;
 
@@ -19,7 +19,12 @@ export type LogLevel = Extract<VehicleLogLevel, "info" | "warn" | "error">;
  * `console.error` entirely) so existing tooling/tests that intercept `console.error` keep working.
  */
 export const logger: Logger = createLogger("jittor-daemon", {
-	destination: { write: (chunk: string) => { console.error(chunk.replace(/\n$/, "")); return true; } },
+	destination: {
+		write: (chunk: string) => {
+			console.error(chunk.replace(/\n$/, ""));
+			return true;
+		},
+	},
 });
 
 /** Credential-safe structured daemon event. Callers must pass bounded, non-sensitive fields. */

package/src/operations/benchmark-operations.ts

@@ -5,7 +5,7 @@ import type { OperationHandlerMap } from "./types.ts";
 /** benchmark.* -- every operation whose only collaborator is the benchmark-controller port. */
 export function benchmarkOperations(benchmarks: BenchmarkController): OperationHandlerMap {
 	return {
-		"benchmark.refresh": (input) => benchmarks.refresh(input["force"] === true),
+		"benchmark.refresh": (input) => benchmarks.refresh(input.force === true),
 		"benchmark.status": () => benchmarks.status(),
 		"benchmark.query": (input) => benchmarks.query(input as unknown as BenchmarkQuery),
 	};