@danypops/jittor 0.16.2 → 0.17.0

package/src/otlp/exporter.ts

@@ -0,0 +1,354 @@
+import {
+	OTLP_EXPORT_BATCH_SIZE,
+	OTLP_EXPORT_INTERVAL_MS,
+	OTLP_EXPORT_MAX_QUEUE_SIZE,
+	OTLP_EXPORT_MAX_RETRIES,
+	OTLP_EXPORT_TIMEOUT_MS,
+} from "../constants.ts";
+import type { MetricObservation } from "../observability/metric.ts";
+import type { ObservationExporter, ObservationExportStatus } from "../telemetry-export/exporter.ts";
+
+export const OTLP_GENAI_SEMANTIC_CONVENTIONS = "genai@46d43c8949afb53765a202e89f4534eeb75ca3fa+core-v1.44.0";
+
+export interface OtlpMetricPoint {
+	name: string;
+	unit: string;
+	value: number;
+	observedAt: number;
+	attributes: Record<string, string | number | boolean>;
+}
+
+function bounded(value: unknown): string | undefined {
+	if (typeof value !== "string" || value.length < 1 || value.length > 200 || /\p{Cc}/u.test(value)) return undefined;
+	return value;
+}
+
+function boundedIdentity(value: unknown): string | undefined {
+	const result = bounded(value);
+	return result && /^[a-zA-Z0-9@~][a-zA-Z0-9@~._:+/-]*$/.test(result) && !result.includes("//") ? result : undefined;
+}
+
+function providerName(value: string): string {
+	if (value === "openai-codex") return "openai";
+	if (value === "google" || value === "google-gemini") return "gcp.gemini";
+	if (value === "google-vertex" || value === "anthropic-vertex") return "gcp.vertex_ai";
+	return value;
+}
+
+function identity(observation: MetricObservation): { provider?: string; model?: string } {
+	const provider = boundedIdentity(observation.attributes?.provider);
+	const model = boundedIdentity(observation.attributes?.model);
+	if (provider || model) return { ...(provider ? { provider } : {}), ...(model ? { model } : {}) };
+	const separator = observation.scope.includes(":") ? ":" : observation.scope.includes("/") ? "/" : null;
+	if (!separator) return {};
+	const [scopeProvider, ...modelParts] = observation.scope.split(separator);
+	const scopeModel = modelParts.join(separator);
+	return {
+		...(boundedIdentity(scopeProvider) ? { provider: scopeProvider } : {}),
+		...(boundedIdentity(scopeModel) ? { model: scopeModel } : {}),
+	};
+}
+
+const CUSTOM_ATTRIBUTES: Record<string, string> = {
+	mechanism: "jittor.compaction.mechanism",
+	reason: "jittor.compaction.reason",
+	willRetry: "jittor.compaction.will_retry",
+	threshold: "jittor.compaction.regrowth_threshold",
+	preContextTokens: "jittor.compaction.pre_context_tokens",
+	postContextTokens: "jittor.compaction.post_context_tokens",
+	summaryTokens: "jittor.compaction.summary_tokens",
+	turnsSinceCompaction: "jittor.compaction.turns_since",
+	elapsedSinceCompactionMs: "jittor.compaction.elapsed_since_ms",
+	contextTokens: "jittor.context.tokens",
+	pressure: "jittor.routing.pressure",
+	action: "jittor.routing.action",
+};
+
+const CUSTOM_ATTRIBUTE_VALUES: Record<string, ReadonlySet<string>> = {
+	mechanism: new Set(["pi-native", "provider-side", "extension"]),
+	reason: new Set(["manual", "threshold", "overflow"]),
+	action: new Set(["continue", "warn", "throttle", "downgrade-thinking", "handoff", "halt"]),
+};
+
+function safeCustomAttributes(input: Record<string, unknown> | undefined): Record<string, string | number | boolean> {
+	const result: Record<string, string | number | boolean> = {};
+	if (!input) return result;
+	for (const [source, target] of Object.entries(CUSTOM_ATTRIBUTES)) {
+		const value = input[source];
+		if (typeof value === "boolean" || (typeof value === "number" && Number.isFinite(value))) result[target] = value;
+		else {
+			const text = bounded(value);
+			if (text && CUSTOM_ATTRIBUTE_VALUES[source]?.has(text)) result[target] = text;
+		}
+	}
+	return result;
+}
+
+function safeName(value: string): string {
+	return value
+		.toLowerCase()
+		.replace(/[^a-z0-9_.]+/g, "_")
+		.slice(0, 100);
+}
+
+export function mapObservationToOtlp(observation: MetricObservation): OtlpMetricPoint | null {
+	if (typeof observation.value !== "number" || !Number.isFinite(observation.value) || observation.value < 0) return null;
+	const ids = identity(observation);
+	const requestedOperation = bounded(observation.attributes?.operation);
+	const operation =
+		requestedOperation &&
+		new Set(["chat", "generate_content", "text_completion", "embeddings", "invoke_agent", "invoke_workflow", "execute_tool"]).has(
+			requestedOperation,
+		)
+			? requestedOperation
+			: "chat";
+	const attributes: Record<string, string | number | boolean> = {
+		"gen_ai.operation.name": operation,
+		...safeCustomAttributes(observation.attributes),
+	};
+	if (ids.provider) attributes["gen_ai.provider.name"] = providerName(ids.provider);
+	if (ids.model) attributes["gen_ai.request.model"] = ids.model;
+	const thinking = bounded(observation.attributes?.thinking);
+	if (thinking && new Set(["off", "none", "minimal", "low", "medium", "high", "xhigh", "max"]).has(thinking))
+		attributes["gen_ai.request.reasoning.level"] = thinking;
+	const runId = bounded(observation.attributes?.runId) ?? bounded(observation.attributes?.importIdentity);
+	if (runId && /^[a-zA-Z0-9_-]+$/.test(runId)) attributes["jittor.run.id"] = runId;
+	const conversationId = bounded(observation.attributes?.sessionId) ?? bounded(observation.attributes?.session_id);
+	if (conversationId && conversationId.length >= 32 && /^[a-zA-Z0-9_-]+$/.test(conversationId))
+		attributes["gen_ai.conversation.id"] = conversationId;
+
+	let name: string;
+	let unit: string;
+	let value = observation.value;
+	if (observation.metric === "input-tokens" || observation.metric === "output-tokens") {
+		name = "gen_ai.client.token.usage";
+		unit = "{token}";
+		attributes["gen_ai.token.type"] = observation.metric === "input-tokens" ? "input" : "output";
+	} else if (observation.metric === "cache-read-tokens" || observation.metric === "cache-write-tokens") {
+		name = "jittor.gen_ai.cache.token.usage";
+		unit = "{token}";
+		attributes["jittor.token.type"] = observation.metric === "cache-read-tokens" ? "cache_read" : "cache_write";
+	} else if (observation.metric === "reasoning-tokens") {
+		name = "jittor.gen_ai.reasoning.token.usage";
+		unit = "{token}";
+	} else if (observation.metric === "wall-latency") {
+		name = "gen_ai.client.operation.duration";
+		unit = "s";
+		value /= 1_000;
+	} else if (observation.metric === "ttft") {
+		name = "gen_ai.client.operation.time_to_first_chunk";
+		unit = "s";
+		value /= 1_000;
+	} else if (observation.metric === "output-throughput") {
+		name = "jittor.gen_ai.output.throughput";
+		unit = "{token}/s";
+	} else {
+		name = `jittor.${safeName(observation.source)}.${safeName(observation.metric)}`;
+		unit = observation.unit;
+	}
+	if (observation.metric === "failure" && observation.value > 0) attributes["error.type"] = "_OTHER";
+	return { name, unit, value, observedAt: observation.observedAt, attributes };
+}
+
+function otlpAttribute(key: string, value: string | number | boolean): object {
+	return {
+		key,
+		value:
+			typeof value === "string"
+				? { stringValue: value }
+				: typeof value === "boolean"
+					? { boolValue: value }
+					: Number.isSafeInteger(value)
+						? { intValue: String(value) }
+						: { doubleValue: value },
+	};
+}
+
+export function buildOtlpMetricsRequest(points: OtlpMetricPoint[]): object {
+	const grouped = new Map<string, OtlpMetricPoint[]>();
+	for (const point of points) {
+		const key = `${point.name}\0${point.unit}`;
+		grouped.set(key, [...(grouped.get(key) ?? []), point]);
+	}
+	return {
+		resourceMetrics: [
+			{
+				resource: {
+					attributes: [otlpAttribute("service.name", "jittor"), otlpAttribute("jittor.semconv.version", OTLP_GENAI_SEMANTIC_CONVENTIONS)],
+				},
+				scopeMetrics: [
+					{
+						scope: { name: "@danypops/jittor", version: OTLP_GENAI_SEMANTIC_CONVENTIONS },
+						metrics: [...grouped.values()].map((values) => ({
+							name: values[0]!.name,
+							unit: values[0]!.unit,
+							histogram: {
+								aggregationTemporality: 1,
+								dataPoints: values.map((point) => ({
+									timeUnixNano: String(point.observedAt * 1_000_000),
+									count: "1",
+									sum: point.value,
+									min: point.value,
+									max: point.value,
+									explicitBounds: [],
+									bucketCounts: ["1"],
+									attributes: Object.entries(point.attributes).map(([key, value]) => otlpAttribute(key, value)),
+								})),
+							},
+						})),
+					},
+				],
+			},
+		],
+	};
+}
+
+export type OtlpTransport = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+export interface OtlpObservationExporterOptions {
+	endpoint: string;
+	headers?: Record<string, string>;
+	transport?: OtlpTransport;
+	clock?: () => number;
+	maxQueueSize?: number;
+	batchSize?: number;
+	intervalMs?: number;
+	timeoutMs?: number;
+	maxRetries?: number;
+}
+
+export class OtlpObservationExporter implements ObservationExporter {
+	private readonly endpoint: string;
+	private readonly headers: Record<string, string>;
+	private readonly transport: OtlpTransport;
+	private readonly clock: () => number;
+	private readonly maxQueueSize: number;
+	private readonly batchSize: number;
+	private readonly timeoutMs: number;
+	private readonly maxRetries: number;
+	private readonly queue: OtlpMetricPoint[] = [];
+	private timer: ReturnType<typeof setInterval> | undefined;
+	private flushing: Promise<void> | undefined;
+	private closed = false;
+	private exported = 0;
+	private dropped = 0;
+	private failures = 0;
+	private lastSuccessAt: number | null = null;
+	private lastFailureAt: number | null = null;
+
+	constructor(options: OtlpObservationExporterOptions) {
+		const url = new URL(options.endpoint);
+		if (url.protocol !== "https:" && url.hostname !== "127.0.0.1" && url.hostname !== "localhost")
+			throw new Error("OTLP endpoint must use HTTPS or loopback HTTP");
+		this.endpoint = url.toString();
+		this.headers = { ...(options.headers ?? {}) };
+		this.transport = options.transport ?? fetch;
+		this.clock = options.clock ?? Date.now;
+		this.maxQueueSize = Math.max(1, options.maxQueueSize ?? OTLP_EXPORT_MAX_QUEUE_SIZE);
+		this.batchSize = Math.max(1, options.batchSize ?? OTLP_EXPORT_BATCH_SIZE);
+		this.timeoutMs = Math.max(1, options.timeoutMs ?? OTLP_EXPORT_TIMEOUT_MS);
+		this.maxRetries = Math.max(0, options.maxRetries ?? OTLP_EXPORT_MAX_RETRIES);
+		this.timer = setInterval(() => void this.flush(), Math.max(10, options.intervalMs ?? OTLP_EXPORT_INTERVAL_MS));
+		this.timer.unref?.();
+	}
+
+	enqueue(observation: MetricObservation): void {
+		const point = mapObservationToOtlp(observation);
+		if (!point) return;
+		if (this.closed) {
+			this.dropped += 1;
+			return;
+		}
+		if (this.queue.length >= this.maxQueueSize) {
+			this.queue.shift();
+			this.dropped += 1;
+		}
+		this.queue.push(point);
+		if (this.queue.length >= this.batchSize) queueMicrotask(() => void this.flush());
+	}
+
+	async flush(): Promise<void> {
+		if (this.flushing) return this.flushing;
+		if (this.queue.length === 0) return;
+		this.flushing = (async () => {
+			while (this.queue.length > 0) await this.send(this.queue.splice(0, this.batchSize));
+		})().finally(() => {
+			this.flushing = undefined;
+		});
+		return this.flushing;
+	}
+
+	private async send(points: OtlpMetricPoint[]): Promise<void> {
+		const body = JSON.stringify(buildOtlpMetricsRequest(points));
+		for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+			try {
+				const response = await this.transport(this.endpoint, {
+					method: "POST",
+					headers: { "content-type": "application/json", ...this.headers },
+					body,
+					signal: controller.signal,
+				});
+				if (!response.ok) throw new Error("OTLP collector rejected export");
+				this.exported += points.length;
+				this.lastSuccessAt = this.clock();
+				return;
+			} catch {
+				if (attempt < this.maxRetries) continue;
+				this.failures += 1;
+				this.dropped += points.length;
+				this.lastFailureAt = this.clock();
+			} finally {
+				clearTimeout(timeout);
+			}
+		}
+	}
+
+	status(): ObservationExportStatus {
+		return {
+			enabled: true,
+			semanticConventions: OTLP_GENAI_SEMANTIC_CONVENTIONS,
+			queued: this.queue.length,
+			dropped: this.dropped,
+			exported: this.exported,
+			failures: this.failures,
+			lastSuccessAt: this.lastSuccessAt,
+			lastFailureAt: this.lastFailureAt,
+		};
+	}
+
+	async shutdown(): Promise<void> {
+		this.closed = true;
+		if (this.timer) clearInterval(this.timer);
+		this.timer = undefined;
+		while (this.queue.length > 0) await this.flush();
+		if (this.flushing) await this.flushing;
+	}
+}
+
+function parseHeaders(raw: string | undefined): Record<string, string> {
+	if (!raw) return {};
+	const result: Record<string, string> = {};
+	for (const pair of raw.split(",")) {
+		const separator = pair.indexOf("=");
+		if (separator < 1) continue;
+		const key = pair.slice(0, separator).trim().toLowerCase();
+		if (!/^[a-z0-9-]+$/.test(key)) continue;
+		try {
+			result[key] = decodeURIComponent(pair.slice(separator + 1).trim());
+		} catch {}
+	}
+	return result;
+}
+
+export function otlpExporterFromEnvironment(env: Record<string, string | undefined> = process.env): ObservationExporter | null {
+	let endpoint = env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT;
+	if (!endpoint && env.OTEL_EXPORTER_OTLP_ENDPOINT)
+		endpoint = new URL(
+			"v1/metrics",
+			env.OTEL_EXPORTER_OTLP_ENDPOINT.endsWith("/") ? env.OTEL_EXPORTER_OTLP_ENDPOINT : `${env.OTEL_EXPORTER_OTLP_ENDPOINT}/`,
+		).toString();
+	if (!endpoint) return null;
+	return new OtlpObservationExporter({ endpoint, headers: parseHeaders(env.OTEL_EXPORTER_OTLP_HEADERS) });
+}

package/src/pi/session-usage-source.ts

@@ -0,0 +1,203 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import {
+	PI_USAGE_IMPORT_MAX_DURATION_MS,
+	PI_USAGE_IMPORT_MAX_ENTRIES,
+	PI_USAGE_IMPORT_MAX_FILE_BYTES,
+	PI_USAGE_IMPORT_MAX_FILES,
+	PI_USAGE_IMPORT_MAX_RECORDS,
+	PI_USAGE_IMPORT_MAX_TOTAL_BYTES,
+} from "../constants.ts";
+import type { HistoricalUsageRecord, HistoricalUsageScan, HistoricalUsageSource } from "../observability/usage-import.ts";
+
+interface SessionState {
+	provider: string | null;
+	model: string | null;
+	thinking: string | null;
+}
+
+async function opaqueIdentity(...parts: string[]): Promise<string> {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(parts.join("\0")));
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+function object(value: unknown): Record<string, unknown> | null {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
+}
+
+function nonnegativeInteger(value: unknown): number | null {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+function nonnegativeNumber(value: unknown): number | null {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function safeIdentity(value: unknown): string | null {
+	if (typeof value !== "string" || value.length < 1 || value.length > 200 || /\p{Cc}/u.test(value)) return null;
+	return value;
+}
+
+function timestamp(entry: Record<string, unknown>, message?: Record<string, unknown>): number | null {
+	const messageTime = message?.timestamp;
+	if (typeof messageTime === "number" && Number.isSafeInteger(messageTime) && messageTime >= 0) return messageTime;
+	if (typeof entry.timestamp !== "string") return null;
+	const value = Date.parse(entry.timestamp);
+	return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function usageRecord(
+	usageValue: unknown,
+	entry: Record<string, unknown>,
+	state: SessionState,
+	sessionId: string,
+	entryId: string,
+	message?: Record<string, unknown>,
+): Promise<HistoricalUsageRecord | null> | null {
+	const usage = object(usageValue);
+	const provider = safeIdentity(message?.provider) ?? state.provider;
+	const model = safeIdentity(message?.model) ?? state.model;
+	const observedAt = timestamp(entry, message);
+	if (!usage || !provider || !model || observedAt === null) return null;
+	const inputTokens = nonnegativeInteger(usage.input);
+	const outputTokens = nonnegativeInteger(usage.output);
+	const cacheReadTokens = nonnegativeInteger(usage.cacheRead);
+	const cacheWriteTokens = nonnegativeInteger(usage.cacheWrite);
+	const cost = object(usage.cost);
+	const costUsd = nonnegativeNumber(cost?.total);
+	if (inputTokens === null || outputTokens === null || cacheReadTokens === null || cacheWriteTokens === null || costUsd === null)
+		return null;
+	return opaqueIdentity(sessionId, entryId).then((identity) => ({
+		identity,
+		observedAt,
+		provider,
+		model,
+		thinking: state.thinking,
+		inputTokens,
+		outputTokens,
+		cacheReadTokens,
+		cacheWriteTokens,
+		costUsd,
+	}));
+}
+
+export interface PiSessionUsageSourceOptions {
+	maxFiles?: number;
+	maxFileBytes?: number;
+	maxTotalBytes?: number;
+	maxEntries?: number;
+	maxRecords?: number;
+	maxDurationMs?: number;
+	clock?: () => number;
+}
+
+/** Reads Pi's documented v1-v3 JSONL session format and immediately discards all content fields. */
+export class PiSessionUsageSource implements HistoricalUsageSource {
+	private readonly options: Required<PiSessionUsageSourceOptions>;
+
+	constructor(
+		private readonly sessionsRoot: string,
+		options: PiSessionUsageSourceOptions = {},
+	) {
+		this.options = {
+			maxFiles: options.maxFiles ?? PI_USAGE_IMPORT_MAX_FILES,
+			maxFileBytes: options.maxFileBytes ?? PI_USAGE_IMPORT_MAX_FILE_BYTES,
+			maxTotalBytes: options.maxTotalBytes ?? PI_USAGE_IMPORT_MAX_TOTAL_BYTES,
+			maxEntries: options.maxEntries ?? PI_USAGE_IMPORT_MAX_ENTRIES,
+			maxRecords: options.maxRecords ?? PI_USAGE_IMPORT_MAX_RECORDS,
+			maxDurationMs: options.maxDurationMs ?? PI_USAGE_IMPORT_MAX_DURATION_MS,
+			clock: options.clock ?? Date.now,
+		};
+	}
+
+	async scan(canceled: () => boolean): Promise<HistoricalUsageScan> {
+		const startedAt = this.options.clock();
+		let names: string[];
+		try {
+			names = (await readdir(this.sessionsRoot, { recursive: true, encoding: "utf8" })).filter((name) => name.endsWith(".jsonl")).sort();
+		} catch {
+			names = [];
+		}
+		const records: HistoricalUsageRecord[] = [];
+		let filesScanned = 0;
+		let entriesScanned = 0;
+		let bytesScanned = 0;
+		let malformedEntries = 0;
+		let truncated = names.length > this.options.maxFiles;
+		let cursor: string | null = null;
+		for (const name of names.slice(0, this.options.maxFiles)) {
+			if (canceled() || this.options.clock() - startedAt > this.options.maxDurationMs) {
+				truncated = true;
+				break;
+			}
+			const path = `${this.sessionsRoot}/${name}`;
+			const size = (await stat(path)).size;
+			if (size > this.options.maxFileBytes || bytesScanned + size > this.options.maxTotalBytes) {
+				truncated = true;
+				continue;
+			}
+			const lines = (await readFile(path, "utf8")).split("\n");
+			bytesScanned += size;
+			filesScanned += 1;
+			let sessionId: string | null = null;
+			const stateById = new Map<string | null, SessionState>([[null, { provider: null, model: null, thinking: null }]]);
+			for (const line of lines) {
+				if (line.trim().length === 0) continue;
+				if (entriesScanned >= this.options.maxEntries || records.length >= this.options.maxRecords || canceled()) {
+					truncated = true;
+					break;
+				}
+				entriesScanned += 1;
+				let entry: Record<string, unknown> | null;
+				try {
+					entry = object(JSON.parse(line));
+				} catch {
+					entry = null;
+				}
+				if (!entry) {
+					malformedEntries += 1;
+					continue;
+				}
+				if (entry.type === "session") {
+					sessionId = safeIdentity(entry.id);
+					if (sessionId) cursor = await opaqueIdentity(sessionId);
+					continue;
+				}
+				const entryId = safeIdentity(entry.id);
+				const parentId = entry.parentId === null ? null : safeIdentity(entry.parentId);
+				if (!sessionId || !entryId || (entry.parentId !== null && parentId === null)) {
+					malformedEntries += 1;
+					continue;
+				}
+				const inherited = stateById.get(parentId) ?? { provider: null, model: null, thinking: null };
+				const state = { ...inherited };
+				if (entry.type === "model_change") {
+					state.provider = safeIdentity(entry.provider);
+					state.model = safeIdentity(entry.modelId);
+				} else if (entry.type === "thinking_level_change") state.thinking = safeIdentity(entry.thinkingLevel);
+				stateById.set(entryId, state);
+				const message = entry.type === "message" ? object(entry.message) : undefined;
+				const candidate =
+					message?.role === "assistant"
+						? usageRecord(message.usage, entry, state, sessionId, entryId, message)
+						: entry.type === "compaction" || entry.type === "branch_summary"
+							? usageRecord(entry.usage, entry, state, sessionId, entryId)
+							: null;
+				if (candidate) {
+					const resolved = await candidate;
+					if (resolved) records.push(resolved);
+				}
+			}
+			if (truncated) break;
+		}
+		return {
+			records,
+			filesScanned,
+			entriesScanned,
+			bytesScanned,
+			malformedEntries,
+			truncated,
+			canceled: canceled(),
+			cursor,
+		};
+	}
+}

package/src/{session-identity-service.ts → sessions/identity.ts}

@@ -4,7 +4,7 @@ import {
 	releaseSessionIdentity,
 	verifySessionSecret,
 } from "@danypops/vehicle-server/session-identity";
-import type { SessionIdentityStore } from "./ports/session-identity-store.ts";
+import type { SessionIdentityStore } from "./store.ts";
 
 export interface RegisterSessionIdentityResult {
 	sessionId: string;
@@ -21,7 +21,7 @@ function assertValidSessionId(sessionId: string): void {
 /**
  * Wraps daemon-kit's storage-agnostic session-identity primitive against Jittor's own
  * SQLite-backed store, and enforces it at the one place a caller-supplied session_id is
- * behavior-affecting: mutating router.* operations (see ports/router-controller.ts).
+ * behavior-affecting: mutating router.* operations (see optimization/routing/controller.ts).
  *
  * Opt-in armor, not a breaking migration: a session_id that was never registered mutates
  * exactly as before (undefined sessionId included, since that maps to the router's legacy

package/src/{operations/session-scope.ts → sessions/router-authorization.ts}

@@ -1,4 +1,4 @@
-import type { SessionIdentity } from "../session-identity-service.ts";
+import type { SessionIdentity } from "./identity.ts";
 
 /** Shared input parsing for every operation that accepts an optional session_id/session_secret pair. */
 export function routerSessionId(input: Record<string, unknown>): string | undefined {

package/src/{db.ts → sqlite/database.ts}

@@ -1,6 +1,6 @@
 import type { Database } from "bun:sqlite";
 import { openSqliteWithPragmas } from "@danypops/vehicle-server/storage";
-import { SQLITE_BUSY_TIMEOUT_MS } from "./constants.ts";
+import { SQLITE_BUSY_TIMEOUT_MS } from "../constants.ts";
 
 const INITIAL_SCHEMA = `
 CREATE TABLE metric_observations (
@@ -30,6 +30,18 @@ CREATE INDEX session_identities_last_seen_idx
 	ON session_identities(last_seen_at);
 `;
 
+const USAGE_IMPORT_SCHEMA = `
+CREATE TABLE usage_import_identities (
+	identity    TEXT PRIMARY KEY,
+	imported_at INTEGER NOT NULL CHECK(imported_at >= 0)
+);
+CREATE TABLE usage_import_state (
+	id         INTEGER PRIMARY KEY CHECK(id = 1),
+	status     TEXT NOT NULL CHECK(json_valid(status)),
+	updated_at INTEGER NOT NULL CHECK(updated_at >= 0)
+);
+`;
+
 /**
  * Delegates bootstrap (pragmas, migration engine) to `@danypops/vehicle-server/storage`, which
  * generalizes the byte-identical pragma/PRAGMA-user_version skeleton jittor's own db.ts used to
@@ -42,6 +54,7 @@ export function openJittorDb(path: string): Database {
 		migrations: [
 			{ version: 1, up: (db) => db.exec(INITIAL_SCHEMA) },
 			{ version: 2, up: (db) => db.exec(SESSION_IDENTITY_SCHEMA) },
+			{ version: 3, up: (db) => db.exec(USAGE_IMPORT_SCHEMA) },
 		],
 	});
 }

package/src/{adapters/sqlite-metric-store.ts → sqlite/metric-store.ts}

@@ -1,9 +1,9 @@
 import type { Database } from "bun:sqlite";
 import { DEFAULT_QUERY_LIMIT, MAX_QUERY_LIMIT, USAGE_AGGREGATE_MAX_ROWS } from "../constants.ts";
-import type { MetricObservation, MetricQuery, StoredMetricObservation } from "../domain/metric.ts";
-import { validateMetricObservation } from "../domain/metric.ts";
-import type { UsageAggregateRow } from "../domain/usage.ts";
-import type { DistinctScopesFilter, MetricStore, UsageAggregateFilter } from "../ports/metric-store.ts";
+import type { MetricObservation, MetricQuery, StoredMetricObservation } from "../observability/metric.ts";
+import { validateMetricObservation } from "../observability/metric.ts";
+import type { DistinctScopesFilter, MetricStore, UsageAggregateFilter } from "../observability/store.ts";
+import type { UsageAggregateRow } from "../observability/usage.ts";
 
 interface MetricRow {
 	id: number;

package/src/{adapters/sqlite-session-identity-store.ts → sqlite/session-store.ts}

@@ -1,6 +1,6 @@
 import type { Database } from "bun:sqlite";
 import { SESSION_IDENTITY_MAX_ROWS } from "../constants.ts";
-import type { SessionIdentityRecord, SessionIdentityStore } from "../ports/session-identity-store.ts";
+import type { SessionIdentityRecord, SessionIdentityStore } from "../sessions/store.ts";
 
 export class SQLiteSessionIdentityStore implements SessionIdentityStore {
 	constructor(private readonly db: Database) {}