@danypops/jittor 0.6.0 → 0.7.0

package/src/domain/model-observation.ts

@@ -7,8 +7,19 @@ import {
 import { normalizeModelIdentity } from "./benchmark.ts";
 import type { MetricObservation, MetricUnit, StoredMetricObservation } from "./metric.ts";
 
-export const TASK_CLASSES = ["coding", "research", "planning", "general"] as const;
-export type ModelTaskClass = typeof TASK_CLASSES[number];
+/**
+ * Two independent axes, not one flat class: "coding" is a subject-matter domain (which
+ * benchmark quality evidence applies), while "research"/"planning" are activities that can
+ * happen inside any domain (which predict how much reasoning effort a task needs). The prior
+ * single ModelTaskClass conflated them -- an agentic/tool-use benchmark (a type signal) was
+ * being read as if it were a domain-quality signal. Both axes default to "general" when tool
+ * usage carries no distinguishing signal for that axis; a run can score coding on domain and
+ * research on type simultaneously (e.g. reading a file, then searching the web in one turn).
+ */
+export const TASK_DOMAINS = ["coding", "general"] as const;
+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 ExplicitOutcome = "accepted" | "rejected" | "unknown";
 
 export interface ModelRunObservation {
@@ -16,7 +27,8 @@ export interface ModelRunObservation {
 	provider: string;
 	model: string;
 	thinking: string;
-	taskClass: ModelTaskClass;
+	domain: ModelTaskDomain;
+	type: ModelTaskType;
 	startedAt: number;
 	firstTokenAt: number | null;
 	completedAt: number;
@@ -36,7 +48,8 @@ export interface ModelMetricAggregate {
 	provider: string;
 	model: string;
 	thinking: string;
-	taskClass: ModelTaskClass;
+	domain: ModelTaskDomain;
+	type: ModelTaskType;
 	dimension: string;
 	unit: MetricUnit;
 	sampleSize: number;
@@ -54,7 +67,7 @@ export interface ModelAggregateOptions {
 }
 
 const ALLOWED_FIELDS = new Set<keyof ModelRunObservation>([
-	"runId", "provider", "model", "thinking", "taskClass", "startedAt", "firstTokenAt", "completedAt",
+	"runId", "provider", "model", "thinking", "domain", "type", "startedAt", "firstTokenAt", "completedAt",
 	"inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "costUsd", "providerResponses",
 	"toolCalls", "toolFailures", "stopReason", "explicitOutcome",
 ]);
@@ -80,7 +93,8 @@ export function validateModelRunObservation(value: unknown): ModelRunObservation
 	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_CLASSES.includes(input["taskClass"] as ModelTaskClass)) throw new Error("task class is invalid");
+	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);
@@ -89,7 +103,7 @@ export function validateModelRunObservation(value: unknown): ModelRunObservation
 	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"), taskClass: input["taskClass"] as ModelTaskClass,
+		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"),
@@ -100,18 +114,25 @@ export function validateModelRunObservation(value: unknown): ModelRunObservation
 	};
 }
 
-export function classifyTaskFromTools(toolNames: string[]): ModelTaskClass {
+export interface ModelTaskClassification {
+	domain: ModelTaskDomain;
+	type: ModelTaskType;
+}
+
+/** 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()));
-	if (["edit", "write", "read", "bash", "grep", "find", "ls"].some((name) => names.has(name))) return "coding";
-	if (["web_fetch", "web_search"].some((name) => names.has(name))) return "research";
-	if (["tasks", "papyrus_create", "papyrus_graph"].some((name) => names.has(name))) return "planning";
-	return "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";
+	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, taskClass: run.taskClass, runId: run.runId };
+	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;
@@ -155,16 +176,17 @@ export function aggregateModelMetrics(input: StoredMetricObservation[], options:
 		const provider = row.attributes["provider"];
 		const model = row.attributes["model"];
 		const thinking = row.attributes["thinking"];
-		const taskClass = row.attributes["taskClass"];
-		if (typeof provider !== "string" || typeof model !== "string" || typeof thinking !== "string" || !TASK_CLASSES.includes(taskClass as ModelTaskClass)) continue;
-		const key = JSON.stringify([provider, model, thinking, taskClass, row.metric, row.unit]);
+		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, taskClass, dimension, unit] = JSON.parse(key) as [string, string, string, ModelTaskClass, string, MetricUnit];
+		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);
@@ -172,10 +194,10 @@ export function aggregateModelMetrics(input: StoredMetricObservation[], options:
 		const age = Math.max(0, now - latestAt);
 		const recency = Math.max(0, 1 - (age / freshForMs));
 		return {
-			provider, model, thinking, taskClass, dimension, unit,
+			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.dimension.localeCompare(right.dimension));
+	}).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

@@ -3,12 +3,13 @@ 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 { ModelTaskClass } from "./model-observation.ts";
+import type { ModelTaskDomain, ModelTaskType } from "./model-observation.ts";
 
 export interface ModelRecommendationInput {
 	candidates: ModelCandidate[];
 	scopeAuthority: ScopeAuthority;
-	taskClass: ModelTaskClass;
+	domain: ModelTaskDomain;
+	type: ModelTaskType;
 	budgetPressure: number;
 	weights: UtilityWeights;
 	sourceIds: string[];

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_CLASSES, type ModelMetricAggregate, type ModelTaskClass } from "./model-observation.ts";
+import { TASK_DOMAINS, TASK_TYPES, type ModelMetricAggregate, type ModelTaskDomain, type ModelTaskType } from "./model-observation.ts";
 
 export type ScopeAuthority = "exact-session" | "available-models";
 export type UtilityComponentName = "quality" | "cost" | "latency" | "context" | "reliability";
@@ -22,7 +22,8 @@ export interface UtilityWeights {
 export interface ModelRankingInput {
 	candidates: ModelCandidate[];
 	scopeAuthority: ScopeAuthority;
-	taskClass: ModelTaskClass;
+	domain: ModelTaskDomain;
+	type: ModelTaskType;
 	budgetPressure: number;
 	weights: UtilityWeights;
 	externalEvidence: BenchmarkObservation[];
@@ -60,7 +61,8 @@ export interface RankedModel {
 export interface ModelRankingResult {
 	scopeAuthority: ScopeAuthority;
 	scopeWarning: string | null;
-	taskClass: ModelTaskClass;
+	domain: ModelTaskDomain;
+	type: ModelTaskType;
 	completeness: "complete" | "partial" | "insufficient-evidence";
 	ranked: RankedModel[];
 	automaticSelection: ModelCandidate | null;
@@ -101,22 +103,37 @@ function externalValues(candidate: ModelCandidate, evidence: BenchmarkObservatio
 	};
 }
 
-function localValues(candidate: ModelCandidate, taskClass: ModelTaskClass, 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.taskClass === taskClass && 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);
+}
+
+/**
+ * quality-{domain} is a subject-matter signal (e.g. quality-coding from a coding benchmark);
+ * quality-type-{type} is an activity signal (e.g. quality-type-planning from an agentic/tool-use
+ * benchmark). Both are optional and additive on top of the universal quality-general fallback --
+ * a candidate with no domain- or type-specific evidence still gets ranked on general quality
+ * rather than being treated as having zero evidence.
+ */
+function qualityDimensions(domain: ModelTaskDomain, type: ModelTaskType): string[] {
+	const dimensions: string[] = [];
+	if (domain !== "general") dimensions.push(`quality-${domain}`);
+	if (type !== "general") dimensions.push(`quality-type-${type}`);
+	dimensions.push("quality-general");
+	return dimensions;
 }
 
 function rawComponents(candidate: ModelCandidate, input: ModelRankingInput): { components: Record<UtilityComponentName, RawComponent>; provenance: RankingProvenance[] } {
-	const quality = externalValues(candidate, input.externalEvidence, [`quality-${input.taskClass}`, "quality-general"], input.now);
+	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);
 	const measuredLatency = externalValues(candidate, input.externalEvidence, ["latency"], input.now);
 	const rankedLatency = externalValues(candidate, input.externalEvidence, ["latency-rank", "throughput-rank"], input.now);
 	const latency = measuredLatency.values.length > 0 ? measuredLatency : rankedLatency;
 	const context = externalValues(candidate, input.externalEvidence, ["context-window"], input.now);
-	const localLatency = localValues(candidate, input.taskClass, input.localEvidence, "wall-latency");
-	const failures = localValues(candidate, input.taskClass, input.localEvidence, "failure");
-	const outcomes = localValues(candidate, input.taskClass, input.localEvidence, "outcome-accepted");
+	const localLatency = localValues(candidate, input.domain, input.type, input.localEvidence, "wall-latency");
+	const failures = localValues(candidate, input.domain, input.type, input.localEvidence, "failure");
+	const outcomes = localValues(candidate, input.domain, input.type, input.localEvidence, "outcome-accepted");
 	const qualityValues = quality.values;
 	const prices = [...priceInput.values, ...priceOutput.values];
 	const latencyValues = localLatency.length > 0 ? localLatency.map((item) => item.median) : latency.values;
@@ -154,7 +171,8 @@ export function rankModelCandidates(value: ModelRankingInput): ModelRankingResul
 	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_CLASSES.includes(value.taskClass)) throw new Error("task class 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;
@@ -195,7 +213,7 @@ export function rankModelCandidates(value: ModelRankingInput): ModelRankingResul
 			confidence,
 			components,
 			provenance,
-			trace: [`task class ${value.taskClass}`, `budget pressure ${budgetPressure.toFixed(3)} makes cost weight ${effectiveWeights.cost.toFixed(3)}`, `${known.length}/${components.length} utility components have evidence`, `scope authority ${value.scopeAuthority}`],
+			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));
 	const knownComponents = ranked.reduce((sum, item) => sum + item.components.filter((component) => component.score !== null).length, 0);
@@ -205,7 +223,8 @@ export function rankModelCandidates(value: ModelRankingInput): ModelRankingResul
 	return {
 		scopeAuthority: value.scopeAuthority,
 		scopeWarning: exact ? null : "Pi available models are not the exact session scope; automatic selection is disabled",
-		taskClass: value.taskClass,
+		domain: value.domain,
+		type: value.type,
 		completeness,
 		ranked,
 		automaticSelection: exact && ranked[0]?.utility !== null ? ranked[0]!.candidate : null,

package/src/domain/task-cost.ts

@@ -0,0 +1,70 @@
+import type { StoredMetricObservation } from "./metric.ts";
+
+export interface TaskCostEntry {
+	taskId: string;
+	costUsd: number;
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+}
+
+export interface TaskCostSummary {
+	since: number;
+	until: number;
+	entries: TaskCostEntry[];
+	unattributedCostUsd: number;
+	truncated: boolean;
+}
+
+export interface TaskCostSummaryOptions {
+	since: number;
+	until: number;
+	truncated?: boolean;
+}
+
+const TOKEN_METRICS = new Set(["input-tokens", "output-tokens", "cache-read-tokens", "cache-write-tokens"]);
+
+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 };
+	byTask.set(taskId, created);
+	return created;
+}
+
+/**
+ * Groups already-recorded "pi" source cost/token metrics by the Papyrus task focused when each was
+ * recorded (see the papyrus.task-focus.v1 real-time tagging in the extension), rather than by
+ * provider/model identity. Rows recorded with nothing focused have no attributes.taskId and are
+ * reported separately as unattributedCostUsd -- they are real spend, just not attributable to any
+ * task, and must never be silently dropped or folded into an invented "unknown" task bucket.
+ *
+ * This queries a single bounded time window without per-task fairness partitioning (unlike
+ * buildUsageGraph/buildCostGraph's per-scope fetch): a task's own working period is typically a far
+ * narrower, more targeted window than "the whole usage dashboard, any period", so one task's volume
+ * crowding another out of the same query is a much smaller risk here. If this does become a problem
+ * in practice, the same per-distinct-value fetch strategy applies, keyed by attributes.taskId.
+ */
+export function buildTaskCostSummary(rows: StoredMetricObservation[], options: TaskCostSummaryOptions): TaskCostSummary {
+	const byTask = new Map<string, TaskCostEntry>();
+	let unattributedCostUsd = 0;
+	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;
+		if (row.metric === "cost" && row.unit === "usd") {
+			if (taskId === undefined) { unattributedCostUsd += row.value; continue; }
+			entryFor(byTask, taskId).costUsd += row.value;
+			continue;
+		}
+		if (taskId === undefined || row.unit !== "tokens" || !TOKEN_METRICS.has(row.metric)) continue;
+		const entry = entryFor(byTask, taskId);
+		if (row.metric === "input-tokens") entry.inputTokens += row.value;
+		else if (row.metric === "output-tokens") entry.outputTokens += row.value;
+		else if (row.metric === "cache-read-tokens") entry.cacheReadTokens += row.value;
+		else entry.cacheWriteTokens += row.value;
+	}
+	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

@@ -0,0 +1,65 @@
+import { PAPYRUS_TASK_FOCUS_SCHEMA, TASK_FOCUS_EVENT_MAX_AGE_MS, TASK_FOCUS_ID_MAX_LENGTH } from "../constants.ts";
+
+export type TaskFocusStatus = "focused" | "paused" | "unpaused" | "cleared";
+
+export interface TaskFocusEvent {
+	schema: typeof PAPYRUS_TASK_FOCUS_SCHEMA;
+	taskId: string | null;
+	sessionId?: string;
+	status: TaskFocusStatus;
+	observedAt: number;
+}
+
+const TOP_LEVEL_FIELDS = new Set(["schema", "taskId", "sessionId", "status", "observedAt"]);
+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}`);
+	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`);
+	return value;
+}
+
+/**
+ * Validates the papyrus.task-focus.v1 shared-bus payload independently of whatever Papyrus itself
+ * guarantees -- this is a cross-extension trust boundary, so Jittor never trusts an unvalidated
+ * shape. Fails closed (throws) on schema drift, an unrecognized status, or a stale observation,
+ * mirroring validatePapyrusContextInjection's pattern for the same reason: a malformed or
+ * out-of-order cross-extension event must never silently corrupt Jittor's own state.
+ */
+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 (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");
+	if (Math.abs(now - observedAt) > TASK_FOCUS_EVENT_MAX_AGE_MS) throw new Error("task-focus event is stale");
+	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 sessionId = rawSessionId === undefined ? undefined : boundedId(rawSessionId, "sessionId");
+	return {
+		schema: PAPYRUS_TASK_FOCUS_SCHEMA,
+		taskId,
+		status: status as TaskFocusStatus,
+		observedAt,
+		...(sessionId === undefined ? {} : { sessionId }),
+	};
+}
+
+/**
+ * Applies a validated event to the currently tracked focused task id. "paused" and "cleared" both
+ * mean "no task is actively being worked on right now" for cost-attribution purposes, even though
+ * Papyrus itself keeps a paused task's focus state around for later resumption -- Jittor only
+ * cares about whether to keep tagging new metrics, not about Papyrus's own pause bookkeeping.
+ */
+export function applyTaskFocusEvent(event: TaskFocusEvent): string | null {
+	return event.status === "focused" || event.status === "unpaused" ? event.taskId : null;
+}

package/src/domain/usage.ts

@@ -1,5 +1,4 @@
 import { MAX_USAGE_BUCKETS, MILLISECONDS_PER_DAY, MILLISECONDS_PER_HOUR } from "../constants.ts";
-import type { StoredMetricObservation } from "./metric.ts";
 
 export const USAGE_PERIODS = [
 	{ id: "hourly", label: "Hourly", windowMs: MILLISECONDS_PER_HOUR, bucketCount: 12 },
@@ -14,6 +13,52 @@ export function usagePeriod(period: UsagePeriod): typeof USAGE_PERIODS[number] {
 	return USAGE_PERIODS.find((candidate) => candidate.id === period)!;
 }
 
+export function usagePeriodStart(period: UsagePeriod, now: number): number {
+	return Math.max(0, now - usagePeriod(period).windowMs);
+}
+
+/**
+ * The bucket boundaries a chart period actually renders. Shared, byte-identical, by both sides of
+ * the wire: the daemon computes the SAME window from the same (period, now[, bucketCount]) before
+ * running its SQL-side GROUP BY, so a pre-aggregated bucket sum always lands in exactly the bucket
+ * the chart expects -- there is no second, independent bucketing pass left to disagree with it.
+ */
+export interface UsageBucketWindow {
+	start: number;
+	end: number;
+	bucketCount: number;
+	bucketSizeMs: number;
+}
+
+export function resolveUsageWindow(period: UsagePeriod, now: number, bucketCount?: number): UsageBucketWindow {
+	const end = now;
+	const start = usagePeriodStart(period, end);
+	const requested = bucketCount ?? usagePeriod(period).bucketCount;
+	const count = Math.max(1, Math.min(MAX_USAGE_BUCKETS, Math.floor(requested)));
+	const bucketSizeMs = Math.max(1, (end - start) / count);
+	return { start, end, bucketCount: count, bucketSizeMs };
+}
+
+/** Mirrors the SQL-side `MIN(CAST((observed_at - start) / bucketSizeMs AS INTEGER), bucketCount - 1)` grouping exactly. */
+export function usageBucketIndex(observedAt: number, window: UsageBucketWindow): number {
+	return Math.min(window.bucketCount - 1, Math.max(0, Math.floor((observedAt - window.start) / window.bucketSizeMs)));
+}
+
+/**
+ * One already-summed (scope, metric, bucket) cell -- what the daemon's SQL-side GROUP BY returns,
+ * replacing a bounded-but-still-truncatable fetch of raw per-observation rows. Result size scales
+ * with (distinct scopes x distinct metrics x bucket count), never with raw event count, so a
+ * heavy scope's full history is represented exactly regardless of how many observations it made
+ * (a real incident: a scope with 49,270 rows in a week had its "weekly" chart built from the 250
+ * most recent rows alone -- 3.3 minutes of real activity mislabeled as a full week).
+ */
+export interface UsageAggregateRow {
+	scope: string;
+	metric: string;
+	bucketIndex: number;
+	sum: number;
+}
+
 export interface UsageSeries {
 	key: string;
 	provider: string;
@@ -48,8 +93,6 @@ export interface UsageGraph {
 
 export interface UsageGraphOptions {
 	period: UsagePeriod;
-	now: number;
-	bucketCount?: number;
 	truncated?: boolean;
 }
 
@@ -60,69 +103,52 @@ const BREAKDOWN_KEYS = {
 	"cache-write-tokens": "cacheWrite",
 } as const satisfies Record<string, keyof UsageBreakdown>;
 
-export function usagePeriodStart(period: UsagePeriod, now: number): number {
-	return Math.max(0, now - usagePeriod(period).windowMs);
-}
-
-export function identity(row: StoredMetricObservation): { key: string; provider: string; model: string } {
-	const separator = row.scope.indexOf(":");
-	const fallbackProvider = separator >= 0 ? row.scope.slice(0, separator) : row.scope;
-	const fallbackModel = separator >= 0 ? row.scope.slice(separator + 1) : "unknown";
-	const provider = typeof row.attributes["provider"] === "string" ? row.attributes["provider"] : fallbackProvider;
-	const model = typeof row.attributes["model"] === "string" ? row.attributes["model"] : fallbackModel;
+/**
+ * Derives provider/model from `scope` alone (`"${provider}:${model}"`, see assistantUsageMetrics),
+ * rather than needing a row's `attributes.provider`/`attributes.model` -- source "pi" always
+ * constructs `scope` from those exact same two values, so the two are equivalent for this source,
+ * and an aggregated bucket sum has no per-row attributes left to read anyway.
+ */
+export function identity(scope: string): { key: string; provider: string; model: string } {
+	const separator = scope.indexOf(":");
+	const provider = separator >= 0 ? scope.slice(0, separator) : scope;
+	const model = separator >= 0 ? scope.slice(separator + 1) : "unknown";
 	return { key: `${provider}/${model}`, provider, model };
 }
 
-interface BucketWindow { start: number; end: number; bucketCount: number; bucketSize: number }
-
-function bucketWindow(options: UsageGraphOptions): BucketWindow {
-	const end = options.now;
-	const start = usagePeriodStart(options.period, end);
-	const requestedBuckets = options.bucketCount ?? usagePeriod(options.period).bucketCount;
-	const bucketCount = Math.max(1, Math.min(MAX_USAGE_BUCKETS, Math.floor(requestedBuckets)));
-	const bucketSize = Math.max(1, (end - start) / bucketCount);
-	return { start, end, bucketCount, bucketSize };
-}
-
-function emptyBuckets(window: BucketWindow): { start: number; end: number; total: number; series: Record<string, number> }[] {
+function emptyBuckets(window: UsageBucketWindow): { start: number; end: number; total: number; series: Record<string, number> }[] {
 	return Array.from({ length: window.bucketCount }, (_, index) => ({
-		start: window.start + index * window.bucketSize,
-		end: index === window.bucketCount - 1 ? window.end : window.start + (index + 1) * window.bucketSize,
+		start: window.start + index * window.bucketSizeMs,
+		end: index === window.bucketCount - 1 ? window.end : window.start + (index + 1) * window.bucketSizeMs,
 		total: 0,
 		series: {},
 	}));
 }
 
-function bucketIndexFor(observedAt: number, window: BucketWindow): number {
-	return Math.min(window.bucketCount - 1, Math.floor((observedAt - window.start) / window.bucketSize));
-}
-
-export function buildUsageGraph(rows: StoredMetricObservation[], options: UsageGraphOptions): UsageGraph {
-	const window = bucketWindow(options);
-	const { start, end } = window;
+export function buildUsageGraph(rows: UsageAggregateRow[], window: UsageBucketWindow, options: UsageGraphOptions): UsageGraph {
 	const buckets: UsageBucket[] = emptyBuckets(window);
 	const breakdown: UsageBreakdown = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 	const identities = new Map<string, UsageSeries>();
 
 	for (const row of rows) {
 		const breakdownKey = BREAKDOWN_KEYS[row.metric as keyof typeof BREAKDOWN_KEYS];
-		if (row.source !== "pi" || row.unit !== "tokens" || !breakdownKey || typeof row.value !== "number" || row.value < 0) continue;
-		if (row.observedAt < start || row.observedAt > end) continue;
-		const bucket = buckets[bucketIndexFor(row.observedAt, window)]!;
-		const series = identity(row);
-		bucket.total += row.value;
-		bucket.series[series.key] = (bucket.series[series.key] ?? 0) + row.value;
-		breakdown[breakdownKey] += row.value;
+		if (!breakdownKey || !Number.isFinite(row.sum) || row.sum < 0) continue;
+		if (!Number.isInteger(row.bucketIndex) || row.bucketIndex < 0 || row.bucketIndex >= buckets.length) continue;
+		const bucket = buckets[row.bucketIndex]!;
+		const series = identity(row.scope);
+		bucket.total += row.sum;
+		bucket.series[series.key] = (bucket.series[series.key] ?? 0) + row.sum;
+		breakdown[breakdownKey] += row.sum;
 		const current = identities.get(series.key) ?? { ...series, total: 0 };
-		current.total += row.value;
+		current.total += row.sum;
 		identities.set(series.key, current);
 	}
 
 	const series = [...identities.values()].sort((left, right) => right.total - left.total || left.key.localeCompare(right.key));
 	return {
 		period: options.period,
-		start,
-		end,
+		start: window.start,
+		end: window.end,
 		buckets,
 		series,
 		totalTokens: buckets.reduce((sum, bucket) => sum + bucket.total, 0),
@@ -162,29 +188,27 @@ export interface CostGraph {
  * surface from day one (alongside raw token counts), since token counts alone do not reflect that
  * output tokens and premium models cost disproportionately more per token.
  */
-export function buildCostGraph(rows: StoredMetricObservation[], options: UsageGraphOptions): CostGraph {
-	const window = bucketWindow(options);
-	const { start, end } = window;
+export function buildCostGraph(rows: UsageAggregateRow[], window: UsageBucketWindow, options: UsageGraphOptions): CostGraph {
 	const buckets: CostBucket[] = emptyBuckets(window);
 	const identities = new Map<string, CostSeries>();
 
 	for (const row of rows) {
-		if (row.source !== "pi" || row.unit !== "usd" || row.metric !== "cost" || typeof row.value !== "number" || row.value < 0) continue;
-		if (row.observedAt < start || row.observedAt > end) continue;
-		const bucket = buckets[bucketIndexFor(row.observedAt, window)]!;
-		const series = identity(row);
-		bucket.total += row.value;
-		bucket.series[series.key] = (bucket.series[series.key] ?? 0) + row.value;
+		if (row.metric !== "cost" || !Number.isFinite(row.sum) || row.sum < 0) continue;
+		if (!Number.isInteger(row.bucketIndex) || row.bucketIndex < 0 || row.bucketIndex >= buckets.length) continue;
+		const bucket = buckets[row.bucketIndex]!;
+		const series = identity(row.scope);
+		bucket.total += row.sum;
+		bucket.series[series.key] = (bucket.series[series.key] ?? 0) + row.sum;
 		const current = identities.get(series.key) ?? { ...series, total: 0 };
-		current.total += row.value;
+		current.total += row.sum;
 		identities.set(series.key, current);
 	}
 
 	const series = [...identities.values()].sort((left, right) => right.total - left.total || left.key.localeCompare(right.key));
 	return {
 		period: options.period,
-		start,
-		end,
+		start: window.start,
+		end: window.end,
 		buckets,
 		series,
 		totalUsd: buckets.reduce((sum, bucket) => sum + bucket.total, 0),

package/src/log.ts

@@ -0,0 +1,28 @@
+/**
+ * Structured daemon logging, now backed by `@danypops/daemon-kit/logging` (pino) instead of a
+ * hand-rolled `console.error(JSON.stringify(...))` -- daemon-kit's own module doc explains why:
+ * level ordering/filtering/child-scoping is exactly the kind of thing worth one shared,
+ * dependency-backed implementation instead of four independent hand-rolled ones. One deliberate,
+ * disclosed shape change from jittor's old bespoke format: the event name is now pino's `msg`
+ * field rather than a separate `event` field, matching daemon-kit's shared convention across all
+ * four daemons. `component`/`level`/`timestamp` and credential-safety (callers still must pass
+ * only bounded, non-sensitive fields) are unchanged.
+ */
+import { createLogger, type LogLevel as DaemonKitLogLevel, type Logger } from "@danypops/daemon-kit/logging";
+
+export type LogLevel = Extract<DaemonKitLogLevel, "info" | "warn" | "error">;
+
+/**
+ * Also passed directly as `StartDaemonOptions.logger` so daemon-kit's own maintenance-task
+ * failure logging shares this same sink/shape. `destination` is pinned to `console.error` rather
+ * than daemon-kit's own default (a raw fd 2 write via `pino.destination(2)`, which bypasses
+ * `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; } },
+});
+
+/** Credential-safe structured daemon event. Callers must pass bounded, non-sensitive fields. */
+export function logEvent(level: LogLevel, event: string, fields: Record<string, unknown> = {}): void {
+	logger[level](event, fields);
+}