@danypops/jittor 0.5.1 → 0.7.0

package/extension/src/index.ts

@@ -10,16 +10,23 @@ 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_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";
 import type { RouterStatus } from "../../src/ports/router-controller.ts";
+import { hasAnthropicRateLimitHeaders, parseAnthropicRateLimitHeaders } from "../../src/providers/anthropic-contracts.ts";
 import { parseCodexRateLimitHeaders } from "../../src/providers/codex.ts";
-import { installIntegratedFooter, type IntegratedFooterState } from "./footer.ts";
+import { classifyGoogleVertexFailure, googleVertexFailureMetrics, type GoogleVertexFailureMetadata } from "../../src/providers/google-vertex-contracts.ts";
+import { showBenchmarkPanel } from "./benchmark-tui.ts";
+import { installIntegratedFooter, type CompactionProgress, type IntegratedFooterState } from "./footer.ts";
 import { callJittor } from "./service-client.ts";
 import { persistentEnforcementControl, type CodexRecoveryControl, type EnforcementControl, type UsageBudgetControl } from "./settings.ts";
 import { showSettingsPanel } from "./settings-tui.ts";
@@ -83,6 +90,16 @@ async function recordMetrics(client: JittorExtensionClient, metrics: MetricObser
 	for (const metric of metrics) await client.call("metrics.record", metric);
 }
 
+interface ActiveLocalModelRun {
+	runId: string;
+	startedAt: number;
+	firstTokenAt: number | null;
+	providerResponses: number;
+	toolNames: string[];
+	toolCalls: number;
+	toolFailures: number;
+}
+
 async function refreshFooter(client: JittorExtensionClient, state: IntegratedFooterState): Promise<void> {
 	const status = await client.call("router.status", {}) as RouterStatus;
 	const provider = status.currentRoute?.provider;
@@ -139,6 +156,17 @@ function modelCost(model: PiRouteModel): number {
 	return (model.cost?.input ?? 0) + (model.cost?.output ?? 0);
 }
 
+export function benchmarkCandidatesFromPi(models: PiRouteModel[], thinking: string): ModelCandidate[] {
+	const candidates: ModelCandidate[] = [];
+	for (const model of models) {
+		if (!model.provider || !model.id || candidates.some((candidate) => candidate.provider === model.provider && candidate.model === model.id)) continue;
+		const level = supportsThinking(model, thinking) ? thinking : "off";
+		candidates.push({ provider: model.provider, model: model.id, thinking: level });
+		if (candidates.length >= MAX_DYNAMIC_ROUTES) break;
+	}
+	return candidates;
+}
+
 export function routesFromPi(models: PiRouteModel[], current: PiRouteModel, thinking: string): Route[] {
 	const sameProvider = models
 		.filter((model) => model.provider === current.provider)
@@ -202,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 [];
@@ -210,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];
@@ -231,6 +260,9 @@ export function registerJittorExtension(
 	const footerState: IntegratedFooterState = { providerBudget: null };
 	const usageBudgets = usageBudgetControl(enforcement);
 	let compactionTelemetry = new CompactionTelemetry();
+	let localRunSequence = 0;
+	let activeLocalRun: ActiveLocalModelRun | undefined;
+	let lastCompletedLocalRun: ModelRunObservation | undefined;
 	const contextObservations = new Set<string>();
 	const stopPapyrusContext = pi.events?.on?.(PAPYRUS_CONTEXT_INJECTION_CHANNEL, (payload) => {
 		try {
@@ -245,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,
@@ -255,6 +302,12 @@ export function registerJittorExtension(
 	let recoveryTimer: unknown;
 	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;
@@ -314,10 +367,21 @@ export function registerJittorExtension(
 	const beginCompactionUi = (ctx: ExtensionContext, signal: AbortSignal): void => {
 		finishCompactionUi();
 		const usage = ctx.getContextUsage();
-		footerState.compaction = {
+		const compaction: CompactionProgress = {
 			startedAt: Date.now(),
 			initialFraction: usage?.percent === null || usage?.percent === undefined ? 1 : usage.percent / 100,
+			estimatedMs: null,
+			confidence: "cold-start",
 		};
+		footerState.compaction = compaction;
+		// Non-blocking: compaction UI starts immediately as cold-start; if a learned estimate resolves
+		// before this compaction finishes (and this is still the active compaction, not a later one),
+		// upgrade the same progress object in place so the drain bar and status text switch to "learned".
+		void client.call("compaction.estimate", {}).then((estimate) => {
+			if (footerState.compaction !== compaction || estimate.confidence !== "learned" || estimate.ms === null) return;
+			footerState.compaction = { ...compaction, estimatedMs: estimate.ms, confidence: "learned" };
+			footerState.requestRender?.();
+		}).catch(() => undefined);
 		compactionTimer = setInterval(() => footerState.requestRender?.(), FOOTER_COMPACTION_RENDER_INTERVAL_MS);
 		signal.addEventListener("abort", finishCompactionUi, { once: true });
 		if (signal.aborted) finishCompactionUi();
@@ -353,9 +417,62 @@ export function registerJittorExtension(
 	};
 
 	pi.registerCommand("jittor", {
-		description: "Inspect or control Jittor routing, budgets, and usage",
+		description: "Jittor settings, routing status, benchmarks, and Codex recovery controls",
 		handler: async (args, ctx) => {
 			const action = args.trim().toLowerCase();
+			if (action === "" || action === "settings") {
+				await showSettingsPanel(ctx, enforcement, codexRecovery, usageBudgets, {
+					setEnforcement: async (enabled) => enabled ? enable(ctx) : disable(ctx),
+					setFooter: async (enabled) => {
+						enforcement.setFooterEnabled(enabled);
+						showFooter(ctx);
+						if (enabled) await refreshFooter(client, footerState).catch(() => undefined);
+					},
+					setRecovery: (enabled) => {
+						if (!enabled) cancelRecovery(true);
+						codexRecovery.setCodexRecoveryEnabled(enabled);
+					},
+				});
+				return;
+			}
+			if (action === "benchmarks" || action.startsWith("benchmarks ")) {
+				if (!ctx.model) {
+					ctx.ui.notify("No active Pi model is available for benchmark recommendations.", "warning");
+					return;
+				}
+				// 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}`, requestedDomain ?? "general", requestedType ?? "general");
+				return;
+			}
+			if (action === "outcome accepted" || action === "outcome rejected") {
+				if (!lastCompletedLocalRun) {
+					ctx.ui.notify("No completed local model run is available for an explicit outcome.", "warning");
+					return;
+				}
+				const explicitOutcome = action.endsWith("accepted") ? "accepted" as const : "rejected" as const;
+				const outcomeMetric = modelRunMetrics({ ...lastCompletedLocalRun, explicitOutcome }).find((metric) => metric.metric === "outcome-accepted")!;
+				outcomeMetric.observedAt = Date.now();
+				await recordMetrics(client, [outcomeMetric]);
+				ctx.ui.notify(`Recorded explicit ${explicitOutcome} outcome for the latest local model run.`, "info");
+				return;
+			}
 			if (action === "recovery" || action === "recovery status") {
 				ctx.ui.notify(recoveryStatusText(), "info");
 				return;
@@ -403,23 +520,22 @@ export function registerJittorExtension(
 				].join("\n"), "info");
 				return;
 			}
-			if (action === "settings") {
-				await showSettingsPanel(ctx, enforcement, codexRecovery, usageBudgets, {
-					setEnforcement: async (enabled) => enabled ? enable(ctx) : disable(ctx),
-					setFooter: async (enabled) => {
-						enforcement.setFooterEnabled(enabled);
-						showFooter(ctx);
-						if (enabled) await refreshFooter(client, footerState).catch(() => undefined);
-					},
-					setRecovery: (enabled) => {
-						if (!enabled) cancelRecovery(true);
-						codexRecovery.setCodexRecoveryEnabled(enabled);
-					},
-				});
+			// Reached only for the explicit "status" keyword or any other unrecognized text; bare "" is
+			// handled above by the settings branch, so this always has a non-empty, non-settings action.
+			if (!enforcement.isEnabled()) {
+				ctx.ui.notify("Jittor is monitor-only. Run /jittor on to re-enable blocking.", "info");
 				return;
 			}
-			if (action === "usage budget" || action.startsWith("usage budget ")) {
-				const [, , periodText, valueText] = action.split(/\s+/);
+			await showJittorPanel(ctx, client);
+		},
+	});
+
+	pi.registerCommand("usage", {
+		description: "Cumulative token/cost usage graph with hourly/daily/weekly/monthly/quarterly views",
+		handler: async (args, ctx) => {
+			const action = args.trim().toLowerCase();
+			if (action === "budget" || action.startsWith("budget ")) {
+				const [, periodText, valueText] = action.split(/\s+/);
 				const period = USAGE_PERIODS.some((candidate) => candidate.id === periodText) ? periodText as UsagePeriod : undefined;
 				if (!period) {
 					const values = USAGE_PERIODS.map(({ id, label }) => `${label}: ${usageBudgets.getUsageTokenBudget(id)?.toLocaleString() ?? "not configured"}`).join(" · ");
@@ -437,30 +553,32 @@ export function registerJittorExtension(
 				}
 				const tokens = Number(valueText.replaceAll(",", ""));
 				if (!Number.isFinite(tokens) || tokens <= 0) {
-					ctx.ui.notify("Usage: /jittor usage budget <hourly|daily|weekly|monthly> <positive-tokens|off>", "warning");
+					ctx.ui.notify("Usage: /usage budget <hourly|daily|weekly|monthly|quarterly> <positive-tokens|off>", "warning");
 					return;
 				}
 				usageBudgets.setUsageTokenBudget(period, tokens);
 				ctx.ui.notify(`${USAGE_PERIODS.find((candidate) => candidate.id === period)!.label} token budget set to ${tokens.toLocaleString()} tokens.`, "info");
 				return;
 			}
-			if (action === "usage") {
-				await showUsagePanel(ctx, client, usageBudgets);
-				return;
-			}
-			if (!enforcement.isEnabled()) {
-				ctx.ui.notify("Jittor is monitor-only. Run /jittor on to re-enable blocking.", "info");
+			if (action !== "" && action !== "cost" && action !== "tokens") {
+				ctx.ui.notify("Usage: /usage [cost] | /usage budget <hourly|daily|weekly|monthly|quarterly> <positive-tokens|off>", "warning");
 				return;
 			}
-			await showJittorPanel(ctx, client);
+			await showUsagePanel(ctx, client, usageBudgets, Date.now(), action === "cost" ? "cost" : "tokens");
 		},
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
+		currentSessionId = ctx.sessionManager.getSessionId();
+		focusedTaskId = null;
 		finishCompactionUi();
 		compactionTelemetry = new CompactionTelemetry();
+		activeLocalRun = undefined;
+		lastCompletedLocalRun = undefined;
 		cancelRecovery(true);
 		lastCodexResponse = {};
+		lastGoogleVertexResponse = {};
+		lastAnthropicVertexResponse = {};
 		ctx.ui.setStatus("jittor", undefined);
 		showFooter(ctx);
 		try {
@@ -533,9 +651,21 @@ export function registerJittorExtension(
 		await syncCurrentRoute(pi, client, ctx, ctx.model, event.level).catch(() => undefined);
 	});
 
-	pi.on("turn_start", async (_event, ctx) => {
+	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,
+			firstTokenAt: null,
+			providerResponses: 0,
+			toolNames: [],
+			toolCalls: 0,
+			toolFailures: 0,
+		};
 		if (!enforcement.isEnabled()) return;
 		try {
 			await syncCurrentRoute(pi, client, ctx);
@@ -547,20 +677,100 @@ export function registerJittorExtension(
 		}
 	});
 
+	pi.on("message_update", async (event) => {
+		if (!activeLocalRun || activeLocalRun.firstTokenAt !== null) return;
+		if (["text_delta", "thinking_delta", "toolcall_delta"].includes(event.assistantMessageEvent.type)) activeLocalRun.firstTokenAt = Date.now();
+	});
+
+	pi.on("tool_execution_end", async (event) => {
+		if (!activeLocalRun) return;
+		activeLocalRun.toolCalls += 1;
+		if (event.isError) activeLocalRun.toolFailures += 1;
+		if (activeLocalRun.toolNames.length < 100) activeLocalRun.toolNames.push(event.toolName);
+	});
+
 	pi.on("after_provider_response", async (event, ctx) => {
+		if (activeLocalRun) activeLocalRun.providerResponses += 1;
 		if (ctx.model?.provider === "openai-codex") {
 			lastCodexResponse = { status: event.status, ...(header(event.headers, "retry-after") ? { retryAfter: header(event.headers, "retry-after") } : {}) };
 		}
-		if (!Object.keys(event.headers).some((name) => name.toLowerCase().startsWith("x-codex-"))) return;
-		try {
-			const updates = parseCodexRateLimitHeaders(new Headers(event.headers), Date.now());
-			await recordMetrics(client, updates.flatMap((update) => update.metrics));
-		} catch {
-			if (enforcement.isEnabled()) ctx.ui.notify(`Jittor detected Codex telemetry schema drift. ${RECOVERY_GUIDANCE}.`, "error");
+		if (ctx.model?.provider === "anthropic") {
+			const headers = new Headers(event.headers);
+			if (hasAnthropicRateLimitHeaders(headers)) {
+				try {
+					await recordMetrics(client, parseAnthropicRateLimitHeaders(headers, Date.now()).metrics);
+				} catch {
+					if (enforcement.isEnabled()) ctx.ui.notify(`Jittor detected Anthropic telemetry schema drift. ${RECOVERY_GUIDANCE}.`, "error");
+				}
+			}
+		}
+		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") } : {}) };
+		}
+		if (Object.keys(event.headers).some((name) => name.toLowerCase().startsWith("x-codex-"))) {
+			try {
+				const updates = parseCodexRateLimitHeaders(new Headers(event.headers), Date.now());
+				await recordMetrics(client, updates.flatMap((update) => update.metrics));
+			} catch {
+				if (enforcement.isEnabled()) ctx.ui.notify(`Jittor detected Codex telemetry schema drift. ${RECOVERY_GUIDANCE}.`, "error");
+			}
 		}
 		if (enforcement.isFooterEnabled()) await refreshFooter(client, footerState).catch(() => undefined);
 	});
 
+	pi.on("turn_end", async (event) => {
+		const active = activeLocalRun;
+		activeLocalRun = undefined;
+		const message = event.message as unknown;
+		if (!active || typeof message !== "object" || message === null || Array.isArray(message)) return;
+		const value = message as Record<string, unknown>;
+		if (value["role"] !== "assistant" || typeof value["provider"] !== "string" || typeof value["model"] !== "string") return;
+		const usage = typeof value["usage"] === "object" && value["usage"] !== null ? value["usage"] as Record<string, unknown> : {};
+		const amount = (name: string): number => typeof usage[name] === "number" && Number.isFinite(usage[name]) ? usage[name] as number : 0;
+		const cost = typeof usage["cost"] === "object" && usage["cost"] !== null && typeof (usage["cost"] as Record<string, unknown>)["total"] === "number"
+			? (usage["cost"] as Record<string, number>)["total"] ?? 0 : 0;
+		const stopReason = ["stop", "length", "toolUse", "error", "aborted"].includes(String(value["stopReason"]))
+			? value["stopReason"] as ModelRunObservation["stopReason"] : "unknown";
+		const completedAt = Math.max(Date.now(), active.firstTokenAt ?? active.startedAt, active.startedAt);
+		lastCompletedLocalRun = {
+			runId: active.runId,
+			provider: value["provider"],
+			model: value["model"],
+			thinking: pi.getThinkingLevel(),
+			...classifyTaskFromTools(active.toolNames),
+			startedAt: active.startedAt,
+			firstTokenAt: active.firstTokenAt,
+			completedAt,
+			inputTokens: amount("input"),
+			outputTokens: amount("output"),
+			cacheReadTokens: amount("cacheRead"),
+			cacheWriteTokens: amount("cacheWrite"),
+			costUsd: Number.isFinite(cost) && cost >= 0 ? cost : 0,
+			providerResponses: Math.max(1, active.providerResponses),
+			toolCalls: active.toolCalls,
+			toolFailures: active.toolFailures,
+			stopReason,
+			explicitOutcome: "unknown",
+		};
+		await recordMetrics(client, modelRunMetrics(lastCompletedLocalRun)).catch(() => undefined);
+	});
+
 	pi.on("message_end", async (event, _ctx) => {
 		if (event.message.role === "assistant" && event.message.provider === "openai-codex") {
 			if (event.message.stopReason === "error") {
@@ -572,7 +782,21 @@ export function registerJittorExtension(
 			}
 			lastCodexResponse = {};
 		}
-		const metrics = assistantUsageMetrics(event.message, Date.now());
+		if (event.message.role === "assistant" && event.message.provider === "google-vertex") {
+			if (event.message.stopReason === "error") {
+				const failure = classifyGoogleVertexFailure(event.message.errorMessage, lastGoogleVertexResponse);
+				await recordMetrics(client, googleVertexFailureMetrics(failure, Date.now())).catch(() => undefined);
+			}
+			lastGoogleVertexResponse = {};
+		}
+		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") });
@@ -585,8 +809,11 @@ 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;
+		lastCompletedLocalRun = undefined;
 		ctx.ui.setStatus("jittor", undefined);
 		ctx.ui.setFooter(undefined);
 	});

package/extension/src/tui.ts

@@ -1,5 +1,6 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import { HUMAN_STATUS_MAX_SOURCES, HUMAN_TEXT_FIELD_MAX_CHARACTERS } from "../../src/constants.ts";
 import type { StoredMetricObservation } from "../../src/domain/metric.ts";
 import type { PolicyAction, Route } from "../../src/policy.ts";
 import type { RouterStatus } from "../../src/ports/router-controller.ts";
@@ -16,7 +17,11 @@ function latest(rows: StoredMetricObservation[], predicate: (row: StoredMetricOb
 }
 
 function sanitizedText(value: string): string {
-	return value.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+	return value.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim().slice(0, HUMAN_TEXT_FIELD_MAX_CHARACTERS);
+}
+
+function routeText(route: Route): string {
+	return `${sanitizedText(route.provider)}/${sanitizedText(route.model)} · ${sanitizedText(route.thinking)}`;
 }
 
 function normalizedIdentity(value: unknown): string {
@@ -58,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);
@@ -72,6 +85,38 @@ export function buildFooterBudget(status: RouterStatus, metrics: StoredMetricObs
 			...(Number.isFinite(resetsAtSeconds) && resetsAtSeconds > 0 ? { resetsAt: resetsAtSeconds * 1_000 } : {}),
 		};
 	}
+	if (status.currentRoute.provider === "anthropic") {
+		const anthropic = latest(metrics, (row) => row.source === "anthropic" && row.metric === "used-fraction" && row.scope === "tokens" && typeof row.value === "number")
+			?? latest(metrics, (row) => row.source === "anthropic" && row.metric === "used-fraction" && row.scope === "requests" && typeof row.value === "number");
+		if (!anthropic || typeof anthropic.value !== "number") return null;
+		const resetsAt = Number(anthropic.attributes["resetsAt"]);
+		return {
+			kind: "bounded",
+			label: anthropic.scope === "tokens" ? "tok" : "req",
+			remainingFraction: 1 - anthropic.value,
+			observedAt: anthropic.observedAt,
+			...(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");
@@ -88,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 {
@@ -135,15 +180,22 @@ export function buildStatusView(status: RouterStatus, metrics: StoredMetricObser
 		? latest(metrics, (row) => row.source === "openrouter" && row.metric === "usage" && typeof row.value === "number")
 		: undefined;
 	if (openRouter && typeof openRouter.value === "number") lines.push(`OpenRouter spend: $${openRouter.value.toFixed(3)}`);
-	if (status.currentRoute) lines.push(`Route: ${status.currentRoute.provider}/${status.currentRoute.model} · ${status.currentRoute.thinking}`);
+	const anthropic = status.currentRoute?.provider === "anthropic"
+		? latest(metrics, (row) => row.source === "anthropic" && row.metric === "used-fraction" && row.scope === "tokens" && typeof row.value === "number")
+			?? latest(metrics, (row) => row.source === "anthropic" && row.metric === "used-fraction" && row.scope === "requests" && typeof row.value === "number")
+		: undefined;
+	if (anthropic && typeof anthropic.value === "number") lines.push(`Anthropic ${anthropic.scope}: ${((1 - anthropic.value) * 100).toFixed(1)}% left`);
+	if (status.currentRoute) lines.push(`Route: ${routeText(status.currentRoute)}`);
 	if (status.lastDecision) lines.push(`Pressure: ${Number.isFinite(status.lastDecision.pressure) ? status.lastDecision.pressure.toFixed(3) : "∞"} · ${status.lastDecision.action}`);
 	lines.push(`Next: ${nextAction(status.lastDecision?.action)}`);
 	lines.push("Telemetry:");
-	for (const source of status.sources.filter((source) => source.provider === status.currentRoute?.provider)) {
+	const providerSources = status.sources.filter((source) => source.provider === status.currentRoute?.provider);
+	for (const source of providerSources.slice(0, HUMAN_STATUS_MAX_SOURCES)) {
 		const freshness = !source.ok ? "failed" : source.observedAt !== undefined && now - source.observedAt > 120_000 ? "stale" : "fresh";
-		lines.push(`  ${source.id}: ${freshness} · ${source.metrics} metrics`);
+		lines.push(`  ${sanitizedText(source.id)}: ${freshness} · ${source.metrics} metrics`);
 	}
-	if (status.override) lines.push(`Override: ${status.override.route.provider}/${status.override.route.model} · ${status.override.route.thinking}`);
+	if (providerSources.length > HUMAN_STATUS_MAX_SOURCES) lines.push(`  … ${providerSources.length - HUMAN_STATUS_MAX_SOURCES} more telemetry sources omitted`);
+	if (status.override) lines.push(`Override: ${routeText(status.override.route)}`);
 	if (status.paused) lines.push("Emergency halt is active");
 	return lines;
 }
@@ -160,7 +212,7 @@ async function snapshot(client: JittorPanelClient): Promise<{ status: RouterStat
 
 async function chooseOverride(ctx: ExtensionCommandContext, routes: Route[]): Promise<Route | undefined> {
 	if (routes.length === 0) { ctx.ui.notify("Pi reports no authenticated routes for the current provider.", "warning"); return undefined; }
-	const labels = routes.map((route) => `${route.provider}/${route.model} · ${route.thinking}`);
+	const labels = routes.map(routeText);
 	const selected = await ctx.ui.select("Override route", labels);
 	const index = selected ? labels.indexOf(selected) : -1;
 	return index >= 0 ? routes[index] : undefined;
@@ -211,7 +263,7 @@ export async function showJittorPanel(ctx: ExtensionCommandContext, client: Jitt
 			continue;
 		}
 		const route = await chooseOverride(ctx, current.status.availableRoutes);
-		if (route && await ctx.ui.confirm("Apply route override?", `${route.provider}/${route.model} · ${route.thinking} for one hour`)) {
+		if (route && await ctx.ui.confirm("Apply route override?", `${routeText(route)} for one hour`)) {
 			await client.call("router.override", { route, expiresAt: Date.now() + 60 * 60 * 1_000 });
 		}
 	}