@danypops/jittor 0.6.0 → 0.7.0

package/README.md

@@ -35,9 +35,11 @@ SQLite runs in WAL mode with versioned migrations, JSON validation, bounded quer
 
 Operations currently include bounded metric recording/query/pruning, benchmark refresh/status/query, context assessment, routing control, telemetry polling, and service checkpointing. Every operation is exposed through the authenticated typed client; benchmark operations also have CLI parity.
 
-Provider adapters currently include official OpenRouter key/usage/model telemetry and an explicitly experimental Codex subscription adapter. The Codex adapter follows the pinned open-source CLI `/wham/usage` payload and `x-codex-*` response-header contracts, accepts additional metered limits, and fails closed on malformed windows or impossible percentages. File credentials must be explicitly configured and private (`0600`); Jittor reads only the access token and account ID, never refreshes credentials, and never logs or persists OAuth secrets. Anthropic has no personal-account polling endpoint (its Admin/Rate Limits API is documented as unavailable for individual accounts), so Jittor instead reads the official `anthropic-ratelimit-*` response headers Pi observes on every Messages API call and fails closed on schema drift the same way. Google Vertex AI has neither a personal polling endpoint nor a documented remaining-quota response header, so Jittor never fabricates a Vertex budget bar; it instead classifies Vertex's `google.rpc.Status` failure shape (quota, authentication, invalid-request, overload, transport, unknown) from Pi's bounded, content-free `errorMessage` and records only a bounded failure-count metric.
+Provider adapters currently include official OpenRouter key/usage/model telemetry and an explicitly experimental Codex subscription adapter. The Codex adapter follows the pinned open-source CLI `/wham/usage` payload and `x-codex-*` response-header contracts, accepts additional metered limits, and fails closed on malformed windows or impossible percentages. File credentials must be explicitly configured and private (`0600`); Jittor reads only the access token and account ID, never refreshes credentials, and never logs or persists OAuth secrets. Anthropic has no personal-account polling endpoint (its Admin/Rate Limits API is documented as unavailable for individual accounts), so Jittor instead reads the official `anthropic-ratelimit-*` response headers Pi observes on every Messages API call and fails closed on schema drift the same way. Google Vertex AI has neither a personal polling endpoint nor a documented remaining-quota response header, so Jittor never fabricates a Vertex budget bar; it instead classifies Vertex's `google.rpc.Status` failure shape (quota, authentication, invalid-request, overload, transport, unknown) from Pi's bounded, content-free `errorMessage` and records only a bounded failure-count metric. Because no budget signal can ever exist for this provider, the footer's `budget` segment is omitted entirely for it rather than showing a permanent `?` placeholder that could never resolve; the `?` placeholder is reserved for providers that can report a budget but simply haven't yet (router not ready, or telemetry not observed on the first turn).
 
-The native Pi extension preflights input and every provider turn, applies model/thinking decisions, records response headers and finalized usage through the daemon, and blocks requests when required telemetry is unsafe. It follows Pi's current authenticated model/provider and synchronizes Pi's available models before every decision, so unavailable catalog routes are never selected. Its responsive integrated footer groups repository and model identity with cumulative usage, a color-coded context-window bar, and current-provider budget telemetry. Codex shows the active model's bounded quota as a draining remaining-budget bar with reset and freshness information. OpenRouter uses the same drain semantics when its official key telemetry exposes a configured limit and remaining balance; keys without a limit remain honest text-only spend and never receive a fabricated denominator. Anthropic shows the same drain semantics from its most-restrictive-in-effect token bucket, falling back to the request bucket when no token telemetry has been observed yet. During Pi compaction, the context bar drains against a learned median duration estimated from the last few completed compactions (bounded to the most recent 20 samples, requiring at least 3 before trusting it); until enough evidence exists it falls back to a fixed-rate cold-start heuristic and says so explicitly ("estimating") rather than claiming a time it does not know. Once learned, the status text reports both elapsed time and an approximate remaining time ("~Ns left"). A liveness dot blinks next to the bar once per render tick in either state so compaction never looks stalled. Run `jittor compaction estimate [--json]` to inspect the current estimate and its confidence directly. Unknown and stale telemetry are marked explicitly. Run `/jittor` for the consolidated Settings TUI (its default action), or `/jittor status` for detailed burn pressure, freshness, route state, and confirmed emergency-halt/override controls.
+The third-party `anthropic-vertex` provider (Anthropic Claude models served through Google Vertex, e.g. via `@twogiants/pi-anthropic-vertex`) is tracked separately from both of the above: it reuses Pi's own Anthropic Messages stream implementation with Anthropic's official `@anthropic-ai/vertex-sdk` client, so its wire shape is Anthropic's, but its quota accounting is Google's. Jittor applies Google Vertex's failure classification to it (real-world reports confirm its 429s still carry GCP's own quota-exceeded shape even through Anthropic's own SDK) and, best-effort, also checks for genuine Anthropic rate-limit response headers on it, since it is unverified whether this specific passthrough ever forwards them. Either way, every metric is tagged `anthropic-vertex`, never blended into direct Anthropic's `anthropic` source or Pi's unrelated native `google-vertex` provider, since each represents a different account/quota pool. Its footer budget (labeled `vtok`/`vreq` when headers are observed) stays `null` (may still resolve) rather than `undefined` (provably impossible) until it's confirmed one way or the other.
+
+The native Pi extension preflights input and every provider turn, applies model/thinking decisions, records response headers and finalized usage through the daemon, and blocks requests when required telemetry is unsafe. It follows Pi's current authenticated model/provider and synchronizes Pi's available models before every decision, so unavailable catalog routes are never selected. Its responsive integrated footer groups repository and model identity with cumulative usage, a color-coded context-window bar, and current-provider budget telemetry. Codex shows the active model's bounded quota as a draining remaining-budget bar with reset and freshness information. OpenRouter uses the same drain semantics when its official key telemetry exposes a configured limit and remaining balance; keys without a limit remain honest text-only spend and never receive a fabricated denominator. Anthropic shows the same drain semantics from its most-restrictive-in-effect token bucket, falling back to the request bucket when no token telemetry has been observed yet. During Pi compaction, the context bar drains against a learned median duration estimated from the last few completed compactions (bounded to the most recent 20 samples, requiring at least 3 before trusting it), in exact sync with a countdown ("compact ~Ns left") — never a count-up, never a fabricated total. Until enough evidence exists, the bar does not drain at all (there is no real rate to drain against) and no timer text is shown; the bar itself simply blinks in place at its starting fill once per render tick so compaction never looks stalled without claiming knowledge it doesn't have. Run `jittor compaction estimate [--json]` to inspect the current estimate and its confidence directly. Unknown and stale telemetry are marked explicitly. Run `/jittor` for the consolidated Settings TUI (its default action), or `/jittor status` for detailed burn pressure, freshness, route state, and confirmed emergency-halt/override controls.
 
 Jittor currently registers no model-callable native tools, so Pi's native model `content` versus renderer `details` contract is explicitly not applicable. Daemon JSON, CLI `--json`, human CLI output, command notifications, panels, and the footer remain separate bounded channels. See [`docs/OUTPUT_CHANNELS.md`](docs/OUTPUT_CHANNELS.md) for the conformance matrix and the requirements that apply if a native tool is introduced later.
 
@@ -66,6 +68,12 @@ Jittor observes finalized Codex assistant errors through Pi's public message lif
 
 `/usage` is its own top-level command, separate from `/jittor`. Bare `/usage` opens a colored Unicode cumulative graph with X/Y axes, per-provider/model series, and explicit **Hourly**, **Daily**, **Weekly**, **Monthly**, and **Quarterly** periods; `/usage cost` opens the same graph showing aggregated USD spend instead of tokens, reusing the `cost` metric already recorded content-free on every finalized Pi assistant message (no new instrumentation). Left/Right or Tab/Shift+Tab changes the time frame, `v` toggles between the token and cost views, and `r` refreshes.
 
+The graph fetches metrics per distinct provider/model scope (`jittor metrics distinct-scopes`, bounded to 40 scopes, 250 rows each) rather than one flat "most recent rows" query. A flat query lets one heavy, long-running session monopolize the entire row budget with its own most recent activity, silently hiding every other provider from the chart no matter which time frame is selected, since the query would never reach back far enough in time to see anything else. Fetching per scope guarantees every active provider/model gets its own fair share of the query budget instead.
+
+### Cost per Papyrus task
+
+Jittor observes Papyrus's task-focus lifecycle in real time over a shared Pi extension event bus (`papyrus.task-focus.v1`) -- Papyrus never depends on Jittor, it only broadcasts which task is currently focused. Every token/cost metric Jittor already records on a finalized Pi assistant message is tagged with the currently focused task's id the moment it is recorded (no time-window estimation, no new instrumentation). A paused or cleared focus stops tagging; spend recorded with nothing focused is reported separately as unattributed, never dropped or folded into an invented task. Run `jittor metrics cost-by-task --since <ms> --until <ms> [--json]` for a bounded per-task breakdown of cost and input/output/cache tokens.
+
 Series are colored with a categorical palette chosen to avoid this UI's own status colors ("success"/"warning"/"error" already mean something specific elsewhere in this panel, so reusing them for arbitrary model identity would make a model's bar segment look like a warning or a failure) and instead reuses the theme's syntax-highlighting roles, which are already tuned by theme authors to stay mutually distinguishable on screen — the same design problem as a categorical data palette. Once more series are active than there are hues, a series reuses a hue in bold rather than repeating an indistinguishable color. Multiple models active within the same cumulative time frame are rendered as one bar stacked by color, not separate bars.
 
 Token-budget thresholds are optional and must be configured by the user; Jittor never infers a token allowance from Codex or another provider's subscription percentage. Configure or clear one period with `/usage budget <hourly|daily|weekly|monthly|quarterly> <positive-tokens|off>`, and inspect all of them with `/usage budget`. A configured budget appears as a horizontal threshold on the cumulative graph with explicit remaining or **OVER BUDGET** state; the cost view does not yet support a budget threshold. These private settings persist in `$XDG_CONFIG_HOME/jittor/extension.json` (or `~/.config/jittor/extension.json`).
@@ -84,9 +92,9 @@ jittor benchmarks list --source openrouter-models [--model provider/model] [--di
 
 Only complete snapshots are queryable. Query output reports both completeness and freshness. See [`docs/BENCHMARK_SOURCES.md`](docs/BENCHMARK_SOURCES.md) for source authority, provenance, conflict, and redistribution rules.
 
-Jittor separately records content-free local model observations from Pi's public lifecycle: TTFT, wall latency, output throughput, token/cache/cost efficiency, provider retries, tool-loop counts, failures, and task class derived only from bounded tool names. Prompts, responses, tool arguments/results, credentials, and project paths are never retained. `/jittor outcome accepted` or `/jittor outcome rejected` attaches explicit outcome evidence to the latest completed local run; runtime completion alone is not treated as quality success. Robust aggregates report sample size, median, p90, median absolute deviation, recency, and confidence without merging local observations into external benchmark facts.
+Jittor separately records content-free local model observations from Pi's public lifecycle: TTFT, wall latency, output throughput, token/cache/cost efficiency, provider retries, tool-loop counts, failures, and two independent classifications derived only from bounded tool names: domain (subject matter, e.g. `coding`) and type (activity, e.g. `research`, `planning`) -- a run can be domain=coding and type=research at once. Prompts, responses, tool arguments/results, credentials, and project paths are never retained. `/jittor outcome accepted` or `/jittor outcome rejected` attaches explicit outcome evidence to the latest completed local run; runtime completion alone is not treated as quality success. Robust aggregates report sample size, median, p90, median absolute deviation, recency, and confidence without merging local observations into external benchmark facts.
 
-The ranking operation accepts an explicit bounded candidate set and never adds identities found only in evidence. It scores task quality, cost, latency, context, and local reliability with bounded user weights, budget-pressure adjustment, component confidence, freshness, provenance, and deterministic tie-breaking. Missing evidence remains unknown and lowers confidence. Run `/jittor benchmarks [coding|research|planning|general]` for the responsive recommendation panel. Because the released Pi extension API does not expose the exact `/scoped-models` set, the current adapter labels candidates `available-models`; the panel says **ADVISORY** and offers no selection action. Automatic route ordering is allowed only for `exact-session` authority and then narrows/reorders routes already present in the supplied candidate set.
+The ranking operation accepts an explicit bounded candidate set and never adds identities found only in evidence. It scores quality (both a domain-specific dimension, e.g. `quality-coding`, and a type-specific dimension, e.g. `quality-type-planning`, each optional and additive over the universal `quality-general` fallback), cost, latency, context, and local reliability with bounded user weights, budget-pressure adjustment, component confidence, freshness, provenance, and deterministic tie-breaking. Missing evidence remains unknown and lowers confidence. Run `/jittor benchmarks [coding|general] [research|planning|general]` (either order, either or both omitted) for the responsive recommendation panel. Because the released Pi extension API does not expose the exact `/scoped-models` set, the current adapter labels candidates `available-models`; the panel says **ADVISORY** and offers no selection action. Automatic route ordering is allowed only for `exact-session` authority and then narrows/reorders routes already present in the supplied candidate set.
 
 ### Context pressure
 
@@ -102,6 +110,9 @@ Every daemon operation is reachable from the CLI through the authenticated typed
 jittor metrics record --source <s> --scope <s> --metric <s> --value <number|null> --unit <unit> [--observed-at <ms>] [--attributes <json>] [--json]
 jittor metrics query [--source <s>] [--scope <s>] [--metric <s>] [--since <ms>] [--until <ms>] [--limit <n>] [--order asc|desc] [--json]
 jittor metrics prune --before <ms> [--json]
+jittor metrics distinct-scopes --source <s> --since <ms> --until <ms> [--limit 1..40] [--json]
+jittor metrics cost-by-task --since <ms> --until <ms> [--json]
+jittor metrics prune --before <ms> [--force] [--json]  # force required if before is newer than 24h ago
 jittor service checkpoint [--json]
 jittor telemetry poll [--json]
 jittor compaction estimate [--json]

package/docs/PROVIDER_RESEARCH.md

@@ -183,7 +183,20 @@ anthropic-priority-output-tokens-limit / -remaining / -reset  (Priority Tier onl
 
 Unlike Anthropic and OpenRouter, Vertex does not document a per-response rate-limit or remaining-quota header for `generateContent`/Messages-compatible calls. Quota is configured and reported at the Google Cloud project/region level (Service Usage / Quota APIs, Cloud Console "Quotas & System Limits"), which is an account-configuration surface, not a response header Jittor could read before a request is throttled — the same class of limitation Amazon Bedrock has (see Papyrus doc `jittor-provider-survey-which-additional-apis-to-support-0wma`, Tier 2). Failures instead surface as a `google.rpc.Status` shape, `{error: {code, message, status, details[]}}`, with `status` one of the canonical gRPC codes (`RESOURCE_EXHAUSTED`, `PERMISSION_DENIED`, `UNAUTHENTICATED`, `UNAVAILABLE`, `DEADLINE_EXCEEDED`, `INVALID_ARGUMENT`, ...), sometimes with a `google.rpc.RetryInfo.retryDelay` or `google.rpc.QuotaFailure` detail.
 
-Jittor therefore does not fabricate a remaining-budget bar for Vertex. It classifies the bounded, content-free `errorMessage` string Pi already exposes for every provider (the same source `classifyCodexFailure` reads) into a failure kind and transience, and records only a bounded failure-count metric (`source: "google-vertex", scope: "failure", metric: <kind>, unit: "count"`) — never a `ratio` metric implying a known remaining fraction. This is an honest degradation: Jittor surfaces *that* and *what kind of* capacity/auth/request pressure Pi is seeing, without claiming to know how much budget remains.
+Jittor therefore does not fabricate a remaining-budget bar for Vertex from the response path alone. It classifies the bounded, content-free `errorMessage` string Pi already exposes for every provider (the same source `classifyCodexFailure` reads) into a failure kind and transience, and records only a bounded failure-count metric (`source: "google-vertex", scope: "failure", metric: <kind>, unit: "count"`) — never a `ratio` metric implying a known remaining fraction. This is an honest degradation: Jittor surfaces *that* and *what kind of* capacity/auth/request pressure Pi is seeing, without claiming to know how much budget remains.
+
+### A real hot(ish)-path signal exists once quota moves to individual per-user GCP projects
+
+The "no telemetry" conclusion above is specific to a *shared* GCP project, where Google has nothing to key a per-user signal on. Several organizations are migrating Vertex/Claude-on-Vertex access from one shared project to one GCP project per individual user specifically so usage/cost can be attributed per person — and that migration changes the honest answer, because Cloud Billing budgets support **project-scoped access** without any Cloud Billing account IAM role: `resourcemanager.projects.get` + `billing.resourcebudgets.read`/`billing.resourceCosts.get` on the project alone are enough (verified against `docs.cloud.google.com/billing/docs/how-to/budget-api-access-control` and `.../billing/docs/how-to/budgets`, fetched 2026-07-23) — matching a "passwordless/keyless", ADC-only individual-project auth model with no static service-account key.
+
+Two API surfaces matter here, and they answer different questions:
+
+- **`billingAccounts.budgets.get`/`.list`** (REST, project-scoped per above) returns only the budget's *policy* — its cap (`amount`), alert `thresholdRules`, and filters. It does **not** return current spend. Resolving which billing account owns a given project first requires `projects.getBillingInfo` (`cloudbilling.googleapis.com`, also just `resourcemanager.projects.get`/Project Viewer).
+- **Cloud Billing's own programmatic budget notifications**, delivered over Pub/Sub, are the real signal: Google's docs state notifications are "sent to the Pub/Sub topic **multiple times per day** with the current status of your budget" (not only on threshold crossings), each message carrying real dollar figures — `costAmount`, `budgetAmount`, `costIntervalStart`, `currencyCode`, and (only once actually exceeded) `alertThresholdExceeded`/`forecastThresholdExceeded` (schema verified against `docs.cloud.google.com/billing/docs/how-to/budgets-programmatic-notifications#notification-format` and the worked fixture in `.../billing/docs/how-to/listen-to-notifications`, fetched 2026-07-23). Since Jittor is a local, loopback-only daemon with no public inbound endpoint, it **pulls** (never pushes) this topic via a Pub/Sub pull subscription (`pubsub.googleapis.com/v1/{subscription}:pull`), authenticated the same ADC way.
+
+This is still not a fully real-time signal, and the docs are explicit about both caveats Jittor must preserve rather than paper over: (1) "Budgets use estimated Cloud Billing data which is subject to change until your invoice is finalized", and (2) "Pub/Sub only provides at-least-once delivery. You might receive a message multiple times, and messages might arrive out of order." Jittor's `GoogleVertexBudgetTelemetryAdapter` (`src/providers/google-vertex-budget.ts`) selects the freshest pulled message by its own Pub/Sub `publishTime`, fails closed (throws) on any message that doesn't match the documented schema, and reports this signal at a lower confidence (`0.6`, vs. `0.8` for Codex's header-derived windows) than a per-response header would earn. `spend`/`cap` are recorded as real USD metrics and their `spend-fraction` ratio is left unclamped (so a genuine over-cap soft-quota period stays visible); only the policy-facing `BudgetWindow.usedFraction` is clamped to `1.0`, since a known-to-be-≥100% real number floored to the window's documented `[0,1]` invariant is not the same thing as fabricating one from nothing.
+
+Setting this up requires one-time configuration outside Jittor for each individual project: create a Pub/Sub topic, connect it to the project's budget (Project Owner/Editor role, plus Pub/Sub Admin on whichever project holds the topic), and create a pull subscription on it. Jittor only consumes the subscription; it does not provision any of this GCP-side configuration itself.
 
 ## Normalized Jittor model
 
@@ -267,7 +280,13 @@ Required safeguards: hysteresis, cooldown, maximum delay, minimum telemetry fres
 ### Google Vertex AI
 
 - Google Cloud/Gemini API 429 `RESOURCE_EXHAUSTED` error reports and `google.rpc.Status`/`QuotaFailure`/`RetryInfo` detail shapes, cross-checked across multiple live incident reports (fetched 2026-07-21); no official Vertex response header for remaining quota was found
-- Papyrus doc `jittor-provider-survey-which-additional-apis-to-support-0wma`, Tier 2 (Amazon Bedrock entry documents the same account-level-quota-not-header pattern)
+- Amazon Bedrock documents the same account-level-quota-not-header pattern as a cross-check on the general "cloud-vendor AI quota lives at the account/project layer, not a response header" shape
+- https://docs.cloud.google.com/billing/docs/how-to/budget-api-access-control (project-scoped `GetBudget`/`ListBudgets` permissions, fetched 2026-07-23)
+- https://docs.cloud.google.com/billing/docs/how-to/budgets ("Project-scoped billing permissions" / single-project access section, fetched 2026-07-23)
+- https://docs.cloud.google.com/billing/docs/reference/rest/v1/projects/getBillingInfo (fetched 2026-07-23)
+- https://docs.cloud.google.com/billing/docs/how-to/budgets-programmatic-notifications#notification-format (fetched 2026-07-23)
+- https://docs.cloud.google.com/billing/docs/how-to/listen-to-notifications (worked notification fixture used verbatim in `test/google-vertex-budget.test.ts`, fetched 2026-07-23)
+- https://docs.cloud.google.com/billing/docs/reference/budget/rest/v1/billingAccounts.budgets (Budget resource schema — confirms no current-spend field, fetched 2026-07-23)
 
 ### Pi
 

package/extension/src/benchmark-tui.ts

@@ -9,7 +9,7 @@ import {
 	MODEL_RANKING_DEFAULT_QUALITY_WEIGHT,
 	MODEL_RANKING_DEFAULT_RELIABILITY_WEIGHT,
 } from "../../src/constants.ts";
-import type { ModelTaskClass } from "../../src/domain/model-observation.ts";
+import type { ModelTaskDomain, ModelTaskType } from "../../src/domain/model-observation.ts";
 import type { ModelCandidate, ModelRankingResult, RankedModel, UtilityComponentName } from "../../src/domain/model-ranking.ts";
 
 export interface BenchmarkPanelClient {
@@ -52,7 +52,7 @@ export function renderBenchmarkView(result: ModelRankingResult, currentIdentity:
 		theme.fg("borderMuted", "─".repeat(safeWidth)),
 		theme.bold("Jittor Benchmark Recommendations"),
 		result.scopeAuthority === "exact-session" ? "Scope: exact session" : "Scope: available models · ADVISORY (exact session scope unavailable)",
-		`Task: ${result.taskClass} · evidence ${result.completeness}`,
+		`Domain: ${result.domain} · Type: ${result.type} · evidence ${result.completeness}`,
 		reason,
 		...shown.flatMap((item, index) => candidateLines(item, index, currentIdentity)),
 		...(result.ranked.length > shown.length ? [` … ${result.ranked.length - shown.length} more candidates omitted`] : []),
@@ -68,13 +68,15 @@ export async function showBenchmarkPanel(
 	client: BenchmarkPanelClient,
 	candidates: ModelCandidate[],
 	currentIdentity: string,
-	taskClass: ModelTaskClass,
+	domain: ModelTaskDomain,
+	type: ModelTaskType,
 ): Promise<void> {
 	for (;;) {
 		const result = await client.call("models.rank", {
 			candidates,
 			scopeAuthority: "available-models",
-			taskClass,
+			domain,
+			type,
 			budgetPressure: 0,
 			weights: {
 				quality: MODEL_RANKING_DEFAULT_QUALITY_WEIGHT,

package/extension/src/footer.ts

@@ -7,7 +7,6 @@ import {
 	FOOTER_CONTEXT_ACCENT_FRACTION,
 	FOOTER_CONTEXT_ERROR_FRACTION,
 	FOOTER_COMPACTION_BLINK_HALF_PERIOD_MS,
-	FOOTER_COMPACTION_DRAIN_STEP_MS,
 	FOOTER_CONTEXT_WARNING_FRACTION,
 	FOOTER_WIDE_TERMINAL_WIDTH,
 	MILLISECONDS_PER_DAY,
@@ -140,19 +139,18 @@ function fillColor(fraction: number | null): FooterColor {
 /**
  * Once a learned median duration is available (see estimateCompactionDuration / the
  * `compaction.estimate` daemon operation), the bar drains against that real estimate: fraction
- * counts down linearly from 1 to 0 over estimatedMs. Until then — cold start, or the estimate
- * fetch has not resolved yet — it falls back to draining from the context fill at a fixed rate,
- * which is a liveness heuristic only and never labeled as a time estimate (see
- * compactionStatusText, which is what actually communicates cold-start vs learned confidence).
+ * counts down linearly from 1 to 0 over estimatedMs, exactly in step with the countdown shown in
+ * compactionStatusText — same elapsed/estimatedMs ratio drives both. Until then — cold start, or
+ * the estimate fetch has not resolved yet — there is no real duration to drain against, so the
+ * fill holds steady at the fraction observed when compaction started; the blink alone (see
+ * compactionBarGlyph) communicates liveness without fabricating a rate.
  */
 function compactionFraction(progress: CompactionProgress, width: number, now: number): number {
 	if (progress.confidence === "learned" && typeof progress.estimatedMs === "number" && progress.estimatedMs > 0) {
 		const elapsed = Math.max(0, now - progress.startedAt);
 		return Math.max(0, Math.min(1, 1 - (elapsed / progress.estimatedMs)));
 	}
-	const initialFilled = Math.round(Math.min(1, Math.max(0, progress.initialFraction)) * width);
-	const drained = Math.floor(Math.max(0, now - progress.startedAt) / FOOTER_COMPACTION_DRAIN_STEP_MS);
-	return Math.max(0, initialFilled - drained) / width;
+	return Math.min(1, Math.max(0, progress.initialFraction));
 }
 
 /**
@@ -166,18 +164,30 @@ export function compactionBlinkOn(startedAt: number, now: number, halfPeriodMs =
 	return Math.floor(elapsed / halfPeriodMs) % 2 === 0;
 }
 
-function compactionBlinkGlyph(progress: CompactionProgress, now: number): string {
-	return compactionBlinkOn(progress.startedAt, now) ? "●" : "○";
+/**
+ * The compaction signal lives in the bar itself: it blinks between its normal draining fill and a
+ * blank track of the same width, rather than a separate indicator glyph next to it. Off-phase
+ * intentionally renders identically to the "no data" empty track (dim, all "░") so the bar reads
+ * as a single blinking element, not a bar plus a decoration.
+ */
+function compactionBarGlyph(progress: CompactionProgress, theme: FooterTheme, width: number, now: number): string {
+	if (!compactionBlinkOn(progress.startedAt, now)) return theme.fg("dim", "░".repeat(width));
+	const fraction = compactionFraction(progress, width, now);
+	return theme.fg("accent", progressBar(fraction, width));
 }
 
-/** Communicates cold-start uncertainty distinctly from a learned approximate completion time. */
-function compactionStatusText(progress: CompactionProgress, now: number): string {
-	const elapsedSeconds = Math.floor(Math.max(0, now - progress.startedAt) / MILLISECONDS_PER_SECOND);
+/**
+ * A countdown, never a count-up: once a learned estimate exists it reports seconds remaining,
+ * ticking down toward zero in step with the draining bar. Before that (cold start, no estimate
+ * yet) there is nothing true to count down from, so this reports nothing at all rather than a
+ * fabricated elapsed count or a guessed total — the blinking, non-draining bar is the only signal.
+ */
+function compactionStatusText(progress: CompactionProgress, now: number): string | undefined {
 	if (progress.confidence === "learned" && typeof progress.estimatedMs === "number" && progress.estimatedMs > 0) {
 		const remainingSeconds = Math.max(0, Math.ceil((progress.estimatedMs - (now - progress.startedAt)) / MILLISECONDS_PER_SECOND));
-		return `compact ${elapsedSeconds}s (~${remainingSeconds}s left)`;
+		return `compact ~${remainingSeconds}s left`;
 	}
-	return `compact ${elapsedSeconds}s (estimating)`;
+	return undefined;
 }
 
 function contextSegment(
@@ -190,8 +200,9 @@ function contextSegment(
 ): string {
 	const w = barWidth(width);
 	if (compaction) {
-		const fraction = compactionFraction(compaction, w, now);
-		return `ctx ${theme.fg("accent", progressBar(fraction, w))} ${compactionBlinkGlyph(compaction, now)} ${compactionStatusText(compaction, now)}`;
+		const bar = compactionBarGlyph(compaction, theme, w, now);
+		const statusText = compactionStatusText(compaction, now);
+		return statusText === undefined ? `ctx ${bar}` : `ctx ${bar} ${statusText}`;
 	}
 	const usage = context.getContextUsage();
 	const window = usage?.contextWindow ?? context.model?.contextWindow ?? 0;
@@ -211,8 +222,7 @@ function minimalContextSegment(
 ): string {
 	const w = barWidth(width);
 	if (compaction) {
-		const fraction = compactionFraction(compaction, w, now);
-		return `ctx ${theme.fg("accent", progressBar(fraction, w))} ${compactionBlinkGlyph(compaction, now)}`;
+		return `ctx ${compactionBarGlyph(compaction, theme, w, now)}`;
 	}
 	const percent = context.getContextUsage()?.percent;
 	const fraction = percent === null || percent === undefined ? null : percent / 100;
@@ -228,7 +238,13 @@ function resetLabel(resetsAt: number | undefined, now: number): string | undefin
 	return `resets in ${Math.max(1, Math.ceil(remaining / MILLISECONDS_PER_MINUTE))}m`;
 }
 
-function budgetSegment(budget: ProviderBudget | null, theme: FooterTheme, width: number, compact: boolean, now: number): string {
+/**
+ * `undefined` means no budget signal is possible for this provider at all (see buildFooterBudget);
+ * the segment is omitted entirely rather than showing a placeholder that could never resolve.
+ * `null` means not known yet but might resolve, which still earns the `?` placeholder.
+ */
+function budgetSegment(budget: ProviderBudget | null | undefined, theme: FooterTheme, width: number, compact: boolean, now: number): string | undefined {
+	if (budget === undefined) return undefined;
 	const w = barWidth(width);
 	if (!budget) return `budget ${theme.fg("dim", progressBar(null, w))} ?`;
 	const stale = budget.observedAt !== undefined && now - budget.observedAt > TELEMETRY_STALE_AFTER_MS;
@@ -288,7 +304,7 @@ export function renderFooterLines(
 	context: FooterContext,
 	footerData: FooterData,
 	theme: FooterTheme,
-	providerBudget: ProviderBudget | null,
+	providerBudget: ProviderBudget | null | undefined,
 	thinkingLevel: string,
 	width: number,
 	now = Date.now(),
@@ -325,7 +341,7 @@ export function renderFooterLines(
 }
 
 export interface IntegratedFooterState {
-	providerBudget: ProviderBudget | null;
+	providerBudget: ProviderBudget | null | undefined;
 	compaction?: CompactionProgress;
 	requestRender?: () => void;
 }

package/extension/src/index.ts

@@ -10,12 +10,14 @@ import {
 	MILLISECONDS_PER_MINUTE,
 	MILLISECONDS_PER_SECOND,
 	PAPYRUS_CONTEXT_INJECTION_CHANNEL,
+	PAPYRUS_TASK_FOCUS_CHANNEL,
 	CONTEXT_EVENT_DEDUP_LIMIT,
 } from "../../src/constants.ts";
 import { CodexRecoveryPolicy, classifyCodexFailure, type CodexFailureKind, type CodexFailureMetadata } from "../../src/domain/codex-recovery.ts";
 import { CompactionTelemetry, papyrusContextMetric, validatePapyrusContextInjection } from "../../src/domain/context-telemetry.ts";
+import { applyTaskFocusEvent, validateTaskFocusEvent } from "../../src/domain/task-focus.ts";
 import type { MetricObservation, StoredMetricObservation } from "../../src/domain/metric.ts";
-import { classifyTaskFromTools, modelRunMetrics, TASK_CLASSES, type ModelRunObservation, type ModelTaskClass } from "../../src/domain/model-observation.ts";
+import { classifyTaskFromTools, modelRunMetrics, TASK_DOMAINS, TASK_TYPES, type ModelRunObservation, type ModelTaskDomain, type ModelTaskType } from "../../src/domain/model-observation.ts";
 import type { ModelCandidate } from "../../src/domain/model-ranking.ts";
 import { USAGE_PERIODS, type UsagePeriod } from "../../src/domain/usage.ts";
 import type { PolicyDecision, Route } from "../../src/policy.ts";
@@ -228,7 +230,8 @@ async function applyDecision(
 	return halt(ctx, `Jittor could not apply any authenticated Pi route after ${decision.route.provider}/${decision.route.model} became unavailable`);
 }
 
-function assistantUsageMetrics(message: unknown, observedAt: number): MetricObservation[] {
+/** taskId, when a Papyrus task is currently focused in this session, tags the metric for real-time cost-per-task correlation without any new instrumentation surface. */
+function assistantUsageMetrics(message: unknown, observedAt: number, taskId: string | null = null): MetricObservation[] {
 	if (typeof message !== "object" || message === null || Array.isArray(message)) return [];
 	const value = message as Record<string, unknown>;
 	if (value["role"] !== "assistant" || typeof value["usage"] !== "object" || value["usage"] === null) return [];
@@ -236,7 +239,7 @@ function assistantUsageMetrics(message: unknown, observedAt: number): MetricObse
 	const provider = typeof value["provider"] === "string" ? value["provider"] : "unknown";
 	const model = typeof value["model"] === "string" ? value["model"] : "unknown";
 	const scope = `${provider}:${model}`;
-	const attributes = { provider, model };
+	const attributes = { provider, model, ...(taskId === null ? {} : { taskId }) };
 	const metrics: MetricObservation[] = [];
 	for (const [field, metric] of [["input", "input-tokens"], ["output", "output-tokens"], ["cacheRead", "cache-read-tokens"], ["cacheWrite", "cache-write-tokens"]] as const) {
 		const amount = usage[field];
@@ -274,6 +277,21 @@ export function registerJittorExtension(
 			// Reject malformed or stale cross-extension observations without retaining payloads.
 		}
 	});
+	// Real-time cost-per-task correlation: Jittor observes Papyrus's task-focus broadcasts (Papyrus
+	// never depends on Jittor) and tags newly recorded token/cost metrics with the currently focused
+	// task id. Scoped to this Pi session: a focus change in a different concurrent session must not
+	// affect this one's attribution.
+	let currentSessionId: string | undefined;
+	let focusedTaskId: string | null = null;
+	const stopPapyrusTaskFocus = pi.events?.on?.(PAPYRUS_TASK_FOCUS_CHANNEL, (payload) => {
+		try {
+			const event = validateTaskFocusEvent(payload);
+			if (event.sessionId !== undefined && event.sessionId !== currentSessionId) return;
+			focusedTaskId = applyTaskFocusEvent(event);
+		} catch {
+			// Reject malformed or stale cross-extension events without retaining payloads or crashing the extension.
+		}
+	});
 	const recoveryPolicy = new CodexRecoveryPolicy({
 		baseDelayMs: CODEX_RECOVERY_BASE_DELAY_MS,
 		maxDelayMs: CODEX_RECOVERY_MAX_DELAY_MS,
@@ -285,6 +303,11 @@ export function registerJittorExtension(
 	let recoveryCooldown: { until: number; attempt: number; failureKind: CodexFailureKind } | undefined;
 	let lastCodexResponse: CodexFailureMetadata = {};
 	let lastGoogleVertexResponse: GoogleVertexFailureMetadata = {};
+	// The third-party "anthropic-vertex" provider (Anthropic Claude via Google Vertex) is tracked
+	// separately from "google-vertex" (Pi's own, unrelated native Vertex provider): different code
+	// path, different account/quota pool, and its metrics must stay distinguishable -- see
+	// google-vertex-contracts.ts and anthropic-contracts.ts.
+	let lastAnthropicVertexResponse: GoogleVertexFailureMetadata = {};
 	const cancelRecovery = (resetPolicy: boolean): void => {
 		if (recoveryTimer !== undefined) recoveryRuntime.clearTimeout(recoveryTimer);
 		recoveryTimer = undefined;
@@ -417,13 +440,25 @@ export function registerJittorExtension(
 					ctx.ui.notify("No active Pi model is available for benchmark recommendations.", "warning");
 					return;
 				}
-				const requestedTask = action.split(/\s+/)[1] ?? "general";
-				if (!TASK_CLASSES.includes(requestedTask as ModelTaskClass)) {
-					ctx.ui.notify("Usage: /jittor benchmarks [coding|research|planning|general]", "warning");
+				// Domain (subject matter, e.g. coding) and type (activity, e.g. research/planning) are
+				// independent axes -- each positional word is classified against whichever axis it
+				// belongs to, in either order, so "/jittor benchmarks coding research" and
+				// "/jittor benchmarks research coding" both work; an unmatched word is a usage error.
+				const requested = action.split(/\s+/).slice(1);
+				let requestedDomain: ModelTaskDomain | undefined;
+				let requestedType: ModelTaskType | undefined;
+				let malformed = requested.length > 2;
+				for (const word of requested) {
+					if (TASK_DOMAINS.includes(word as ModelTaskDomain) && requestedDomain === undefined) requestedDomain = word as ModelTaskDomain;
+					else if (TASK_TYPES.includes(word as ModelTaskType) && requestedType === undefined) requestedType = word as ModelTaskType;
+					else malformed = true;
+				}
+				if (malformed) {
+					ctx.ui.notify("Usage: /jittor benchmarks [coding|general] [research|planning|general]", "warning");
 					return;
 				}
 				const candidates = benchmarkCandidatesFromPi(ctx.modelRegistry.getAvailable() as PiRouteModel[], pi.getThinkingLevel());
-				await showBenchmarkPanel(ctx, client, candidates, `${ctx.model.provider}/${ctx.model.id}`, requestedTask as ModelTaskClass);
+				await showBenchmarkPanel(ctx, client, candidates, `${ctx.model.provider}/${ctx.model.id}`, requestedDomain ?? "general", requestedType ?? "general");
 				return;
 			}
 			if (action === "outcome accepted" || action === "outcome rejected") {
@@ -534,6 +569,8 @@ export function registerJittorExtension(
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
+		currentSessionId = ctx.sessionManager.getSessionId();
+		focusedTaskId = null;
 		finishCompactionUi();
 		compactionTelemetry = new CompactionTelemetry();
 		activeLocalRun = undefined;
@@ -541,6 +578,7 @@ export function registerJittorExtension(
 		cancelRecovery(true);
 		lastCodexResponse = {};
 		lastGoogleVertexResponse = {};
+		lastAnthropicVertexResponse = {};
 		ctx.ui.setStatus("jittor", undefined);
 		showFooter(ctx);
 		try {
@@ -614,9 +652,11 @@ export function registerJittorExtension(
 	});
 
 	pi.on("turn_start", async (event, ctx) => {
+		currentSessionId = ctx.sessionManager.getSessionId();
 		compactionTelemetry.observeTurn();
 		lastCodexResponse = {};
 		lastGoogleVertexResponse = {};
+		lastAnthropicVertexResponse = {};
 		activeLocalRun = {
 			runId: `local-${event.timestamp}-${++localRunSequence}`,
 			startedAt: event.timestamp,
@@ -664,6 +704,22 @@ export function registerJittorExtension(
 				}
 			}
 		}
+		if (ctx.model?.provider === "anthropic-vertex") {
+			// Best-effort only: unverified whether this passthrough ever forwards Anthropic's own
+			// rate-limit headers. If it doesn't, hasAnthropicRateLimitHeaders is false and nothing is
+			// recorded -- the same honest default as every other unconfirmed signal in this file.
+			const headers = new Headers(event.headers);
+			if (hasAnthropicRateLimitHeaders(headers)) {
+				try {
+					await recordMetrics(client, parseAnthropicRateLimitHeaders(headers, Date.now(), "anthropic-vertex").metrics);
+				} catch {
+					if (enforcement.isEnabled()) ctx.ui.notify(`Jittor detected Anthropic-on-Vertex telemetry schema drift. ${RECOVERY_GUIDANCE}.`, "error");
+				}
+			}
+			// Well-evidenced regardless of headers: GCP's own quota system fronts this transport, so the
+			// same failure classification as google-vertex applies -- see google-vertex-contracts.ts.
+			lastAnthropicVertexResponse = { status: event.status, ...(header(event.headers, "retry-after") ? { retryAfter: header(event.headers, "retry-after") } : {}) };
+		}
 		if (ctx.model?.provider === "google-vertex") {
 			lastGoogleVertexResponse = { status: event.status, ...(header(event.headers, "retry-after") ? { retryAfter: header(event.headers, "retry-after") } : {}) };
 		}
@@ -697,7 +753,7 @@ export function registerJittorExtension(
 			provider: value["provider"],
 			model: value["model"],
 			thinking: pi.getThinkingLevel(),
-			taskClass: classifyTaskFromTools(active.toolNames),
+			...classifyTaskFromTools(active.toolNames),
 			startedAt: active.startedAt,
 			firstTokenAt: active.firstTokenAt,
 			completedAt,
@@ -733,7 +789,14 @@ export function registerJittorExtension(
 			}
 			lastGoogleVertexResponse = {};
 		}
-		const metrics = assistantUsageMetrics(event.message, Date.now());
+		if (event.message.role === "assistant" && event.message.provider === "anthropic-vertex") {
+			if (event.message.stopReason === "error") {
+				const failure = classifyGoogleVertexFailure(event.message.errorMessage, lastAnthropicVertexResponse);
+				await recordMetrics(client, googleVertexFailureMetrics(failure, Date.now(), "anthropic-vertex")).catch(() => undefined);
+			}
+			lastAnthropicVertexResponse = {};
+		}
+		const metrics = assistantUsageMetrics(event.message, Date.now(), focusedTaskId);
 		if (metrics.length > 0) {
 			const amount = (name: string): number => metrics.filter((metric) => metric.metric === name && typeof metric.value === "number").reduce((sum, metric) => sum + (metric.value ?? 0), 0);
 			compactionTelemetry.observeProviderUsage({ input: amount("input-tokens"), output: amount("output-tokens"), cacheRead: amount("cache-read-tokens"), cacheWrite: amount("cache-write-tokens") });
@@ -746,6 +809,7 @@ export function registerJittorExtension(
 		finishCompactionUi();
 		if (compactionTelemetry.hasOpenCompaction()) await recordMetrics(client, [compactionTelemetry.abort(Date.now(), "session-shutdown")]).catch(() => undefined);
 		stopPapyrusContext?.();
+		stopPapyrusTaskFocus?.();
 		cancelRecovery(true);
 		lastCodexResponse = {};
 		activeLocalRun = undefined;

package/extension/src/tui.ts

@@ -63,7 +63,15 @@ function windowName(seconds: number): string {
 	return `${Math.round(seconds / 60)}m`;
 }
 
-export function buildFooterBudget(status: RouterStatus, metrics: StoredMetricObservation[]): ProviderBudget | null {
+/**
+ * `null` means "not known yet, but this provider can report a budget once data arrives" -- router
+ * not ready, or a supported provider whose telemetry hasn't been observed yet; the footer shows a
+ * placeholder that may resolve. `undefined` means "no budget signal is possible for this provider
+ * at all" (e.g. google-vertex, which has no documented rate-limit or quota header/endpoint Jittor
+ * could ever read -- see google-vertex-contracts.ts); the footer omits the segment entirely rather
+ * than showing a `?` that can never resolve.
+ */
+export function buildFooterBudget(status: RouterStatus, metrics: StoredMetricObservation[]): ProviderBudget | null | undefined {
 	if (!status.ready || !status.currentRoute) return null;
 	if (status.currentRoute.provider === "openai-codex") {
 		const codex = codexWindowForModel(metrics, status.currentRoute.model);
@@ -90,6 +98,25 @@ export function buildFooterBudget(status: RouterStatus, metrics: StoredMetricObs
 			...(Number.isFinite(resetsAt) && resetsAt > 0 ? { resetsAt } : {}),
 		};
 	}
+	if (status.currentRoute.provider === "anthropic-vertex") {
+		// Best-effort only (see index.ts): these metrics only exist if Anthropic-style rate-limit
+		// headers were actually observed on this passthrough, which is unverified. Labeled distinctly
+		// ("vtok"/"vreq") from direct Anthropic's "tok"/"req" since they are a different account/quota
+		// pool even if the header shape is identical. If nothing was ever observed, this stays null
+		// (may still resolve later), not undefined (never possible) -- unlike google-vertex, this
+		// provider's transport has not been shown to structurally lack the signal.
+		const anthropicVertex = latest(metrics, (row) => row.source === "anthropic-vertex" && row.metric === "used-fraction" && row.scope === "tokens" && typeof row.value === "number")
+			?? latest(metrics, (row) => row.source === "anthropic-vertex" && row.metric === "used-fraction" && row.scope === "requests" && typeof row.value === "number");
+		if (!anthropicVertex || typeof anthropicVertex.value !== "number") return null;
+		const resetsAt = Number(anthropicVertex.attributes["resetsAt"]);
+		return {
+			kind: "bounded",
+			label: anthropicVertex.scope === "tokens" ? "vtok" : "vreq",
+			remainingFraction: 1 - anthropicVertex.value,
+			observedAt: anthropicVertex.observedAt,
+			...(Number.isFinite(resetsAt) && resetsAt > 0 ? { resetsAt } : {}),
+		};
+	}
 	if (status.currentRoute.provider === "openrouter") {
 		const openRouter = latest(metrics, (row) => row.source === "openrouter" && row.metric === "usage" && typeof row.value === "number");
 		const remaining = latest(metrics, (row) => row.source === "openrouter" && row.metric === "remaining-fraction" && typeof row.value === "number");
@@ -106,7 +133,7 @@ export function buildFooterBudget(status: RouterStatus, metrics: StoredMetricObs
 		if (!openRouter || typeof openRouter.value !== "number") return null;
 		return { kind: "unbounded", label: "spend", valueText: `$${openRouter.value.toFixed(3)}`, observedAt: openRouter.observedAt };
 	}
-	return null;
+	return undefined;
 }
 
 export function formatFooterStatus(status: RouterStatus, metrics: StoredMetricObservation[]): string {

package/extension/src/usage.ts

@@ -1,14 +1,14 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { HUMAN_TEXT_FIELD_MAX_CHARACTERS, USAGE_CHART_HEIGHT, USAGE_RENDER_MAX_SERIES, USAGE_TOKEN_QUERY_LIMIT, USAGE_Y_AXIS_WIDTH } from "../../src/constants.ts";
-import type { StoredMetricObservation } from "../../src/domain/metric.ts";
+import { HUMAN_TEXT_FIELD_MAX_CHARACTERS, USAGE_CHART_HEIGHT, USAGE_MAX_DISTINCT_SCOPES, USAGE_RENDER_MAX_SERIES, USAGE_Y_AXIS_WIDTH } from "../../src/constants.ts";
 import {
 	buildCostGraph,
 	buildUsageGraph,
+	resolveUsageWindow,
 	USAGE_PERIODS,
 	usagePeriod,
-	usagePeriodStart,
 	type CostGraph,
+	type UsageAggregateRow,
 	type UsageGraph,
 	type UsagePeriod,
 } from "../../src/domain/usage.ts";
@@ -254,15 +254,23 @@ export function renderCostGraph(chart: CostGraph, width: number, theme: UsageThe
 export type UsageViewKind = "tokens" | "cost";
 const USAGE_VIEWS: UsageViewKind[] = ["tokens", "cost"];
 
-async function loadPiMetrics(client: JittorPanelClient, period: UsagePeriod, now: number): Promise<{ rows: StoredMetricObservation[]; truncated: boolean }> {
-	const rows = await client.call("metrics.query", {
-		source: "pi",
-		since: usagePeriodStart(period, now),
-		until: now,
-		order: "desc",
-		limit: USAGE_TOKEN_QUERY_LIMIT,
-	}) as StoredMetricObservation[];
-	return { rows, truncated: rows.length >= USAGE_TOKEN_QUERY_LIMIT };
+/**
+ * One bounded round trip: the daemon discovers distinct scopes (still capped at
+ * USAGE_MAX_DISTINCT_SCOPES -- more scopes than that is still a real, honestly-reported
+ * truncation) and SQL-side aggregates every matching observation into (scope, metric, bucket)
+ * sums for the exact window this panel renders. Replaces a per-scope fetch of up to
+ * USAGE_PER_SCOPE_QUERY_LIMIT raw rows each, which fixed a *different* problem (one heavy scope
+ * starving *other* scopes out of a shared row budget) but could still silently truncate a single
+ * heavy scope's *own* older history within the same window -- a real incident: a scope logging
+ * tens of thousands of rows a week had its "weekly" chart built from a few minutes of its most
+ * recent rows alone. Aggregation has no such failure mode: result size scales with (scopes x
+ * metrics x buckets), never with raw event count.
+ */
+async function loadPiMetrics(client: JittorPanelClient, window: ReturnType<typeof resolveUsageWindow>): Promise<{ rows: UsageAggregateRow[]; truncated: boolean }> {
+	const result = await client.call("metrics.usage_series", {
+		source: "pi", since: window.start, until: window.end, bucketSizeMs: window.bucketSizeMs, bucketCount: window.bucketCount, scopeLimit: USAGE_MAX_DISTINCT_SCOPES,
+	}) as { rows: UsageAggregateRow[]; truncated: boolean };
+	return result;
 }
 
 export async function showUsagePanel(
@@ -276,11 +284,12 @@ export async function showUsagePanel(
 	let viewIndex = Math.max(0, USAGE_VIEWS.indexOf(initialView));
 	for (;;) {
 		const period = USAGE_PERIODS[periodIndex]!.id;
+		const window = resolveUsageWindow(period, now);
 		// One bounded query serves both views: token and cost metrics share the same "pi" source rows.
-		const { rows, truncated } = await loadPiMetrics(client, period, now);
+		const { rows, truncated } = await loadPiMetrics(client, window);
 		const view = USAGE_VIEWS[viewIndex]!;
-		const tokenChart = buildUsageGraph(rows, { period, now, truncated });
-		const costChart = buildCostGraph(rows, { period, now, truncated });
+		const tokenChart = buildUsageGraph(rows, window, { period, truncated });
+		const costChart = buildCostGraph(rows, window, { period, truncated });
 		const tokenBudget = budgets.getUsageTokenBudget(period);
 		const renderActive = (width: number, theme: UsageTheme): string[] =>
 			view === "tokens" ? renderUsageGraph(tokenChart, width, theme, tokenBudget) : renderCostGraph(costChart, width, theme);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/jittor",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Just-in-Time Token Optimizing Router for Pi",
   "type": "module",
   "keywords": ["pi-package", "llm-router", "token-budget"],
@@ -22,6 +22,10 @@
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },
+  "dependencies": {
+    "@danypops/daemon-kit": "^0.3.1",
+    "google-auth-library": "^10.9.0"
+  },
   "devDependencies": {
     "bun-types": "latest"
   },

package/src/adapters/openrouter-benchmark-index-source.ts

@@ -83,7 +83,8 @@ export class OpenRouterBenchmarkIndexSource implements BenchmarkSource {
 			return [
 				validateBenchmarkObservation({ ...common, dimension: "quality-coding", value: requiredNumber(row["coding_index"], "coding index"), unit: "ratio", methodology }),
 				validateBenchmarkObservation({ ...common, dimension: "quality-general", value: requiredNumber(row["intelligence_index"], "intelligence index"), unit: "ratio", methodology }),
-				validateBenchmarkObservation({ ...common, dimension: "quality-planning", value: requiredNumber(row["agentic_index"], "agentic index"), unit: "ratio", methodology }),
+				// agentic_index measures tool-use/agentic execution style, an activity (type), not a subject-matter domain.
+				validateBenchmarkObservation({ ...common, dimension: "quality-type-planning", value: requiredNumber(row["agentic_index"], "agentic index"), unit: "ratio", methodology }),
 				validateBenchmarkObservation({ ...common, dimension: "price-input", value: price(pricing["prompt"], "prompt pricing"), unit: "usd", methodology: { ...methodology, basis: "OpenRouter USD per input token" } }),
 				validateBenchmarkObservation({ ...common, dimension: "price-output", value: price(pricing["completion"], "completion pricing"), unit: "usd", methodology: { ...methodology, basis: "OpenRouter USD per output token" } }),
 			];