@danypops/pi-jittor 0.7.0 → 0.9.0

package/extension/src/index.ts

@@ -26,7 +26,6 @@ import {
 	papyrusContextMetric,
 	type Route,
 	type RouterStatus,
-	type StoredMetricObservation,
 	TASK_DOMAINS,
 	TASK_TYPES,
 	type TextTokenCounter,
@@ -61,7 +60,7 @@ import {
 import { LocalRunTelemetry } from "./observability/model-run.ts";
 import { captureProviderContextSnapshot } from "./observability/provider-context-snapshot.ts";
 import { ProviderResponseTelemetry } from "./observability/provider-response.ts";
-import { buildFooterBudget, providerBudgetMetricQuery } from "./observability/status.ts";
+import { buildFooterBudget, fetchProviderBudgetMetrics } from "./observability/status.ts";
 import { showUsagePanel } from "./observability/usage.ts";
 import { candidateIdentityOf, decideAutoMode, newAutoModeSessionState, recordAutoModeDismissal } from "./optimization/auto-mode.ts";
 import { showAutoModeSuggestion } from "./optimization/auto-mode-dialog.ts";
@@ -158,27 +157,11 @@ async function recordMetrics(client: JittorExtensionClient, metrics: MetricObser
 
 async function refreshFooter(client: JittorExtensionClient, state: IntegratedFooterState, sessionId: string): Promise<void> {
 	const status = (await client.call("router.status", { session_id: sessionId })) as RouterStatus;
-	const query = providerBudgetMetricQuery(status);
-	const metrics = query ? ((await client.call("metrics.query", query)) as StoredMetricObservation[]) : [];
+	const metrics = await fetchProviderBudgetMetrics(client, status);
 	state.providerBudget = buildFooterBudget(status, metrics);
 	state.requestRender?.();
 }
 
-function delay(milliseconds: number, signal?: AbortSignal): Promise<void> {
-	if (milliseconds <= 0) return Promise.resolve();
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(resolve, milliseconds);
-		signal?.addEventListener(
-			"abort",
-			() => {
-				clearTimeout(timer);
-				reject(new Error("Jittor throttle cancelled"));
-			},
-			{ once: true },
-		);
-	});
-}
-
 function routeModelAvailable(ctx: ExtensionContext, route: Route): boolean {
 	return ctx.modelRegistry.getAvailable().some((model) => model.provider === route.provider && model.id === route.model);
 }
@@ -318,38 +301,6 @@ async function syncCurrentRoute(
 	});
 }
 
-function halt(ctx: ExtensionContext, reason: string): false {
-	ctx.ui.notify(`${reason}. ${RECOVERY_GUIDANCE}.`, "warning");
-	ctx.abort();
-	return false;
-}
-
-async function applyDecision(
-	pi: ExtensionAPI,
-	client: JittorExtensionClient,
-	ctx: ExtensionContext,
-	decision: PolicyDecision,
-	allowResync = true,
-): Promise<boolean> {
-	if (decision.action === "halt") return halt(ctx, `Jittor blocked this provider request: ${decision.reason}`);
-	if (decision.action === "throttle") await delay(decision.delayMs ?? 0, ctx.signal);
-	if (!decision.route || (await applyRoute(pi, ctx, decision.route))) return true;
-	if (allowResync) {
-		await syncAvailableRoutes(pi, client, ctx);
-		return applyDecision(
-			pi,
-			client,
-			ctx,
-			(await client.call("router.decide", { session_id: ctx.sessionManager.getSessionId() })) as PolicyDecision,
-			false,
-		);
-	}
-	return halt(
-		ctx,
-		`Jittor could not apply any authenticated Pi route after ${decision.route.provider}/${decision.route.model} became unavailable`,
-	);
-}
-
 let assistantUsageRunSequence = 0;
 
 /**
@@ -503,54 +454,61 @@ export function registerJittorExtension(
 	const contextFingerprinter = new HmacContextFingerprinter(contextFingerprintKey);
 	let contextCaptureSequence = 0;
 	pi.on("before_provider_request", (event, ctx) => {
-		try {
-			const sessionId = ctx.sessionManager.getSessionId();
-			let history:
-				| {
-						roots: SessionTreeNodeLike[];
-						activeEntryIds: Set<string>;
-						branchEntryIds: Set<string>;
-				  }
-				| undefined;
+		// Pi awaits this hook immediately before opening the provider request. Snapshotting a large
+		// payload here used to add its full CPU cost to TTFT even though persistence was detached.
+		// Defer the entire observational path to a later macrotask; the provider payload is immutable
+		// after serialization in Pi's request path, and a missed snapshot is preferable to delaying it.
+		const timer = setTimeout(() => {
 			try {
-				history = {
-					roots: ctx.sessionManager.getTree() as SessionTreeNodeLike[],
-					activeEntryIds: new Set((ctx.sessionManager.buildContextEntries() as SessionEntryLike[]).map((entry) => entry.id)),
-					branchEntryIds: new Set((ctx.sessionManager.getBranch() as SessionEntryLike[]).map((entry) => entry.id)),
+				const sessionId = ctx.sessionManager.getSessionId();
+				let history:
+					| {
+							roots: SessionTreeNodeLike[];
+							activeEntryIds: Set<string>;
+							branchEntryIds: Set<string>;
+					  }
+					| undefined;
+				try {
+					history = {
+						roots: ctx.sessionManager.getTree() as SessionTreeNodeLike[],
+						activeEntryIds: new Set((ctx.sessionManager.buildContextEntries() as SessionEntryLike[]).map((entry) => entry.id)),
+						branchEntryIds: new Set((ctx.sessionManager.getBranch() as SessionEntryLike[]).map((entry) => entry.id)),
+					};
+				} catch {
+					// Older/custom SessionManager implementations may not expose tree projections.
+				}
+				const captureInput = {
+					payload: event.payload,
+					captureId: `${++contextCaptureSequence}`,
+					sessionId,
+					provider: ctx.model?.provider ?? "unknown",
+					model: ctx.model?.id ?? "unknown",
+					capturedAt: Date.now(),
+					fingerprinter: contextFingerprinter,
 				};
+				let snapshot: ContextSnapshot;
+				try {
+					snapshot = captureProviderContextSnapshot({ ...captureInput, ...(history ? { history } : {}) });
+				} catch {
+					// A custom SessionManager tree shape must not suppress the real request-payload snapshot.
+					snapshot = captureProviderContextSnapshot(captureInput);
+				}
+				// Observation must never alter or abort the provider request. Both local writes are detached;
+				// they receive only bounded token sizes and keyed fingerprints.
+				const requestTokens = snapshot.segments
+					.filter((segment) => segment.requestPosition !== null)
+					.reduce((sum, segment) => sum + segment.tokens, 0);
+				const compactionMetrics = compactionTelemetry.observeContextSnapshot(requestTokens, "structural-estimate", snapshot.capturedAt, {
+					provider: snapshot.provider,
+					model: snapshot.model,
+				});
+				void client.call("context.snapshot", snapshot).catch(() => undefined);
+				if (compactionMetrics.length > 0) void recordMetrics(client, compactionMetrics).catch(() => undefined);
 			} catch {
-				// Older/custom SessionManager implementations may not expose tree projections.
-			}
-			const captureInput = {
-				payload: event.payload,
-				captureId: `${++contextCaptureSequence}`,
-				sessionId,
-				provider: ctx.model?.provider ?? "unknown",
-				model: ctx.model?.id ?? "unknown",
-				capturedAt: Date.now(),
-				fingerprinter: contextFingerprinter,
-			};
-			let snapshot: ContextSnapshot;
-			try {
-				snapshot = captureProviderContextSnapshot({ ...captureInput, ...(history ? { history } : {}) });
-			} catch {
-				// A custom SessionManager tree shape must not suppress the real request-payload snapshot.
-				snapshot = captureProviderContextSnapshot(captureInput);
+				// Snapshot collection is strictly failure-isolated from provider delivery.
 			}
-			// Observation must never alter or abort the provider request. Both local writes are detached;
-			// they receive only bounded token sizes and keyed fingerprints.
-			const requestTokens = snapshot.segments
-				.filter((segment) => segment.requestPosition !== null)
-				.reduce((sum, segment) => sum + segment.tokens, 0);
-			const compactionMetrics = compactionTelemetry.observeContextSnapshot(requestTokens, "structural-estimate", snapshot.capturedAt, {
-				provider: snapshot.provider,
-				model: snapshot.model,
-			});
-			void client.call("context.snapshot", snapshot).catch(() => undefined);
-			if (compactionMetrics.length > 0) void recordMetrics(client, compactionMetrics).catch(() => undefined);
-		} catch {
-			// Snapshot collection is strictly failure-isolated from provider delivery.
-		}
+		}, 0);
+		timer.unref?.();
 	});
 	const stopContextHub = pi.events?.on?.(CONTEXT_HUB_CONTRIBUTION_CHANNEL, (payload) => contextHub.observe(payload));
 	// Cached from the most recent before_agent_start observation: Pi's own base system prompt is
@@ -1002,25 +960,58 @@ export function registerJittorExtension(
 		]).catch(() => undefined);
 	});
 
-	pi.on("agent_settled", async (_event, ctx) => {
+	let ambientRouting: Promise<void> | null = null;
+	const scheduleAmbientRouting = (ctx: ExtensionContext): void => {
+		if (ambientRouting || !ctx.isIdle()) return;
+		ambientRouting = (async () => {
+			try {
+				await syncCurrentRoute(pi, client, ctx);
+				await syncAvailableRoutes(pi, client, ctx);
+				if (!ctx.isIdle()) return;
+				let budgetActed = false;
+				if (enforcement.isEnabled()) {
+					const decision = (await client.call("router.decide", {
+						session_id: ctx.sessionManager.getSessionId(),
+					})) as PolicyDecision;
+					if (!ctx.isIdle()) return;
+					budgetActed = decision.action !== "continue";
+					if (decision.action === "halt") {
+						ctx.ui.notify(`Jittor recommends pausing future requests: ${decision.reason}.`, "warning");
+					} else if (decision.route && !(await applyRoute(pi, ctx, decision.route)) && ctx.isIdle()) {
+						// Catalogs can change while an ambient decision is in flight. Refresh and try one
+						// newly-computed route; failure simply leaves the current model in place.
+						await syncAvailableRoutes(pi, client, ctx);
+						const refreshed = (await client.call("router.decide", {
+							session_id: ctx.sessionManager.getSessionId(),
+						})) as PolicyDecision;
+						if (ctx.isIdle() && refreshed.route) await applyRoute(pi, ctx, refreshed.route);
+					}
+				}
+				if (!budgetActed && ctx.isIdle()) await runAutoModeTurn(ctx);
+			} catch {
+				// Routing is opportunistic: daemon latency or failure must never enter Pi's request path.
+			} finally {
+				ambientRouting = null;
+			}
+		})();
+	};
+
+	pi.on("agent_settled", (_event, ctx) => {
 		if (footerState.compaction) {
 			finishCompactionUi();
 			if (compactionTelemetry.hasOpenCompaction())
-				await recordMetrics(client, [compactionTelemetry.abort(Date.now(), "agent-settled-without-completion")]).catch(() => undefined);
+				void recordMetrics(client, [compactionTelemetry.abort(Date.now(), "agent-settled-without-completion")]).catch(() => undefined);
 		}
 		scheduleCodexRecovery(ctx);
+		scheduleAmbientRouting(ctx);
 		if (!enforcement.isFooterEnabled()) return;
-		try {
-			await syncCurrentRoute(pi, client, ctx);
-			await syncAvailableRoutes(pi, client, ctx);
-			await refreshFooter(client, footerState, ctx.sessionManager.getSessionId());
-		} catch {
+		void refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => {
 			footerState.providerBudget = null;
 			footerState.requestRender?.();
-		}
+		});
 	});
 
-	pi.on("input", async (event, ctx) => {
+	pi.on("input", (event) => {
 		if (event.source !== "extension") {
 			cancelRecovery(true);
 			// Auto mode's own effort classifier reads this at the next turn_start -- captured
@@ -1028,57 +1019,34 @@ export function registerJittorExtension(
 			// separate, independently-toggled feature from budget enforcement.
 			pendingUserText = event.text;
 		}
-		if (event.source === "extension" || !enforcement.isEnabled()) return { action: "continue" as const };
-		try {
-			const next = (await client.call("router.decide", { session_id: ctx.sessionManager.getSessionId() })) as PolicyDecision;
-			if (next.action === "halt") {
-				ctx.ui.notify(`Jittor blocked input: ${next.reason}. ${RECOVERY_GUIDANCE}.`, "warning");
-				return { action: "handled" as const };
-			}
-			return { action: "continue" as const };
-		} catch {
-			ctx.ui.notify(`Jittor could not verify budget telemetry, so fail-closed enforcement blocked input. ${RECOVERY_GUIDANCE}.`, "error");
-			return { action: "handled" as const };
-		}
+		// Routing is advisory and ambient. The submitted message always enters Pi immediately;
+		// daemon decisions computed while idle can optimize a later turn.
+		return { action: "continue" as const };
 	});
 
-	pi.on("model_select", async (event, ctx) => {
-		await syncCurrentRoute(pi, client, ctx, event.model)
+	pi.on("model_select", (event, ctx) => {
+		void syncCurrentRoute(pi, client, ctx, event.model)
 			.then(() => syncAvailableRoutes(pi, client, ctx))
+			.then(() =>
+				enforcement.isFooterEnabled()
+					? refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined)
+					: undefined,
+			)
 			.catch(() => undefined);
-		if (enforcement.isFooterEnabled()) await refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined);
 	});
 
-	pi.on("thinking_level_select", async (event, ctx) => {
-		await syncCurrentRoute(pi, client, ctx, ctx.model, event.level).catch(() => undefined);
+	pi.on("thinking_level_select", (event, ctx) => {
+		void syncCurrentRoute(pi, client, ctx, ctx.model, event.level).catch(() => undefined);
 	});
 
-	pi.on("turn_start", async (event, ctx) => {
+	pi.on("turn_start", (event, ctx) => {
 		currentSessionId = ctx.sessionManager.getSessionId();
 		compactionTelemetry.observeTurn();
 		codexRecoveryCapability.resetTurn();
 		providerResponseTelemetry.resetTurn();
 		localRunTelemetry.beginTurn(event.timestamp);
-		// Budget/enforcement routing is safety-critical and always wins on conflict: Auto mode is
-		// only evaluated when budget pressure required no action this turn (action === "continue"),
-		// so the two decision sources never fight over the model mid-turn.
-		let budgetActedThisTurn = false;
-		if (enforcement.isEnabled()) {
-			try {
-				await syncCurrentRoute(pi, client, ctx);
-				await syncAvailableRoutes(pi, client, ctx);
-				const budgetDecision = (await client.call("router.decide", {
-					session_id: ctx.sessionManager.getSessionId(),
-				})) as PolicyDecision;
-				budgetActedThisTurn = budgetDecision.action !== "continue";
-				await applyDecision(pi, client, ctx, budgetDecision);
-				await refreshFooter(client, footerState, ctx.sessionManager.getSessionId());
-			} catch {
-				halt(ctx, "Jittor could not verify or apply a safe route");
-				return;
-			}
-		}
-		if (!budgetActedThisTurn) await runAutoModeTurn(ctx).catch(() => undefined);
+		// Deliberately no daemon or routing work here: Pi awaits turn_start before provider delivery.
+		// The previous agent_settled event computes and applies recommendations for later turns.
 	});
 
 	pi.on("message_update", async (event) => {
@@ -1095,35 +1063,35 @@ export function registerJittorExtension(
 		if (currentTurnToolNames.length < EFFORT_CLASSIFICATION_MAX_TOOL_NAMES) currentTurnToolNames.push(event.toolName);
 	});
 
-	pi.on("after_provider_response", async (event, ctx) => {
+	pi.on("after_provider_response", (event, ctx) => {
 		localRunTelemetry.onProviderResponse();
 		if (ctx.model?.provider === "openai-codex") codexRecoveryCapability.notifyResponse(event.status, event.headers);
 		const notifySchemaDrift = (message: string) => {
 			if (enforcement.isEnabled()) ctx.ui.notify(`Jittor detected ${message}. ${RECOVERY_GUIDANCE}.`, "error");
 		};
-		await providerResponseTelemetry.handleProviderResponse(client, ctx.model?.provider, event.status, event.headers, notifySchemaDrift);
-		if (enforcement.isFooterEnabled()) await refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined);
+		// Pi fires this before consuming the provider stream. Never put telemetry or footer RPCs
+		// between the HTTP response and the first streamed token.
+		void providerResponseTelemetry
+			.handleProviderResponse(client, ctx.model?.provider, event.status, event.headers, notifySchemaDrift)
+			.catch(() => undefined);
 	});
 
-	pi.on("turn_end", async (event, ctx) => {
+	pi.on("turn_end", (event, ctx) => {
 		const tokens = ctx.getContextUsage()?.tokens;
 		if (typeof tokens === "number" && Number.isFinite(tokens)) contextGrowth.observe(++contextGrowthTurn, tokens);
 		const metrics = localRunTelemetry.completeTurn(event.message, pi.getThinkingLevel());
-		await recordMetrics(client, metrics).catch(() => undefined);
+		void recordMetrics(client, metrics).catch(() => undefined);
 		priorTurnToolNames = currentTurnToolNames;
 		currentTurnToolNames = [];
 	});
 
-	pi.on("message_end", async (event, ctx) => {
+	pi.on("message_end", (event, ctx) => {
 		if (event.message.role === "assistant") {
 			if (event.message.provider === "openai-codex")
 				codexRecoveryCapability.notifyMessageEnd(event.message.stopReason, event.message.errorMessage);
-			await providerResponseTelemetry.handleMessageEnd(
-				client,
-				event.message.provider,
-				event.message.stopReason,
-				event.message.errorMessage,
-			);
+			void providerResponseTelemetry
+				.handleMessageEnd(client, event.message.provider, event.message.stopReason, event.message.errorMessage)
+				.catch(() => undefined);
 		}
 		const metrics = assistantUsageMetrics(
 			event.message,
@@ -1143,9 +1111,10 @@ export function registerJittorExtension(
 				cacheRead: amount("cache-read-tokens"),
 				cacheWrite: amount("cache-write-tokens"),
 			});
-			await recordMetrics(client, metrics).catch(() => undefined);
+			void recordMetrics(client, metrics).catch(() => undefined);
 		}
-		if (enforcement.isFooterEnabled()) await refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined);
+		// Footer refresh is consolidated in agent_settled; finalized-message accounting must not
+		// hold back streamed lifecycle delivery or the next queued prompt.
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {

package/extension/src/observability/footer.ts

@@ -48,7 +48,7 @@ interface FooterContext {
 }
 
 /** A bounded quota is explicitly remaining; unbounded values never receive a fabricated bar. */
-export type ProviderBudget =
+export type ProviderBudget = { availableResets?: { count: number; observedAt: number } } & (
 	| {
 			kind: "bounded";
 			label: string;
@@ -67,7 +67,21 @@ export type ProviderBudget =
 			kind: "unavailable";
 			label: string;
 			valueText: string;
-	  };
+	  }
+);
+
+export function resetAvailabilityText(budget: ProviderBudget | null | undefined, now: number): string | undefined {
+	const resets = budget?.availableResets;
+	if (
+		!resets ||
+		!Number.isSafeInteger(resets.count) ||
+		resets.count < 1 ||
+		resets.count > 10000 ||
+		now - resets.observedAt > TELEMETRY_STALE_AFTER_MS
+	)
+		return undefined;
+	return `${resets.count} reset${resets.count === 1 ? "" : "s"} available`;
+}
 
 /** Compact, always-visible state of Jittor's effort-based Auto mode -- the newer, effort-driven router, distinct from the existing budget-pressure route already reflected by the model/budget segments. */
 export interface RouterFooterInfo {
@@ -227,6 +241,18 @@ function budgetSegment(
 	width: number,
 	compact: boolean,
 	now: number,
+): string | undefined {
+	const quota = quotaSegment(budget, theme, width, compact, now);
+	const resets = resetAvailabilityText(budget, now);
+	return resets ? `${quota ?? "Codex"} · ${resets}` : quota;
+}
+
+function quotaSegment(
+	budget: ProviderBudget | null | undefined,
+	theme: FooterTheme,
+	width: number,
+	compact: boolean,
+	now: number,
 ): string | undefined {
 	if (budget === undefined) return undefined;
 	const w = barWidth(width);

package/extension/src/observability/status.ts

@@ -13,7 +13,7 @@ import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tu
 import { BorderedSelectPanel, type TextMeasure } from "malevich-tui-components";
 import { sessionSecretField } from "../session-identity.ts";
 import { showConfirmDialog, showRouteOverrideMenu } from "../tui-prompts.ts";
-import type { ProviderBudget } from "./footer.ts";
+import { type ProviderBudget, resetAvailabilityText } from "./footer.ts";
 
 export interface JittorPanelClient {
 	call(operation: string, input: unknown): Promise<any>;
@@ -136,6 +136,28 @@ export function buildFooterBudget(
 	metrics: StoredMetricObservation[],
 	now = Date.now(),
 ): ProviderBudget | null | undefined {
+	const budget = buildQuotaBudget(status, metrics, now);
+	if (status.currentRoute?.provider !== "openai-codex" || codexTelemetryState(status, now) !== "available") return budget;
+	const resets = latest(
+		metrics,
+		(row) => row.source === "codex-subscription" && row.scope === "codex:resets" && row.metric === "available-resets",
+	);
+	if (
+		!resets ||
+		typeof resets.value !== "number" ||
+		!Number.isSafeInteger(resets.value) ||
+		resets.value <= 0 ||
+		resets.value > 10000 ||
+		now - resets.observedAt > TELEMETRY_STALE_AFTER_MS
+	)
+		return budget;
+	return {
+		...(budget ?? { kind: "unavailable", label: "Codex", valueText: "usage unavailable" }),
+		availableResets: { count: resets.value, observedAt: resets.observedAt },
+	};
+}
+
+function buildQuotaBudget(status: RouterStatus, metrics: StoredMetricObservation[], now = Date.now()): ProviderBudget | null | undefined {
 	if (!status.currentRoute) return null;
 	if (status.currentRoute.provider === "openai-codex") {
 		const codex = codexWindowForModel(metrics, status.currentRoute.model);
@@ -238,8 +260,12 @@ export function formatFooterStatus(status: RouterStatus, metrics: StoredMetricOb
 	const budget = buildFooterBudget(status, metrics, now);
 	if (!budget) return "";
 	if (budget.kind === "unbounded") return budget.valueText;
-	if (budget.kind === "unavailable") return `${budget.label} ${budget.valueText}`;
-	return `${budget.label} ${(budget.remainingFraction * 100).toFixed(1)}% left`;
+	const resets = resetAvailabilityText(budget, now);
+	const quota =
+		budget.kind === "unavailable"
+			? `${budget.label} ${budget.valueText}`
+			: `${budget.label} ${(budget.remainingFraction * 100).toFixed(1)}% left`;
+	return resets ? `${quota} · ${resets}` : quota;
 }
 
 function nextAction(action: PolicyAction | undefined): string {
@@ -287,6 +313,8 @@ export function buildStatusView(status: RouterStatus, metrics: StoredMetricObser
 	const lines = [status.ready ? "Ready" : "Not ready"];
 	const codex = status.currentRoute?.provider === "openai-codex" ? codexWindowForModel(metrics, status.currentRoute.model) : undefined;
 	const budget = buildFooterBudget(status, metrics, now);
+	const resets = resetAvailabilityText(budget, now);
+	if (resets) lines.push(`Codex: ${resets}`);
 	if (codex && typeof codex.value === "number" && budget?.kind === "bounded") {
 		const seconds = Number(codex.attributes.windowSeconds ?? 0);
 		lines.push(`Codex ${windowName(seconds)}: ${((1 - codex.value) * 100).toFixed(1)}% left`);
@@ -343,9 +371,24 @@ export interface StatusPanelSnapshot {
 /** Shared by the standalone status panel below and the unified /jittor shell, so both fetch identically. */
 export async function fetchStatusSnapshot(client: JittorPanelClient, sessionId: string): Promise<StatusPanelSnapshot> {
 	const status = (await client.call("router.status", { session_id: sessionId })) as RouterStatus;
+	const metrics = await fetchProviderBudgetMetrics(client, status);
+	return { status, metrics };
+}
+
+export async function fetchProviderBudgetMetrics(client: JittorPanelClient, status: RouterStatus): Promise<StoredMetricObservation[]> {
 	const query = providerBudgetMetricQuery(status);
 	const metrics = query ? ((await client.call("metrics.query", query)) as StoredMetricObservation[]) : [];
-	return { status, metrics };
+	if (status.currentRoute?.provider === "openai-codex") {
+		const resets = (await client.call("metrics.query", {
+			source: "codex-subscription",
+			scope: "codex:resets",
+			metric: "available-resets",
+			order: "desc",
+			limit: 1,
+		})) as StoredMetricObservation[];
+		return [...metrics, ...resets];
+	}
+	return metrics;
 }
 
 async function chooseOverride(ctx: ExtensionCommandContext, routes: Route[]): Promise<Route | undefined> {

package/extension/src/service-client.ts

@@ -15,6 +15,8 @@ let retrying: RetryingClient<JittorClient> = createRetryingClient(() => connecto
  * is classified: only reads may be transparently invoked twice after a connection-shaped error.
  */
 const OPERATION_RETRY_MODE = {
+	"subscription.resets.list": "retry",
+	"subscription.resets.redeem": "once",
 	"metrics.record": "once",
 	"metrics.record_batch": "once",
 	"metrics.query": "retry",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-jittor",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Pi extension for Jittor token and context observability with optimization controls backed by the @danypops/jittor daemon",
   "license": "MIT",
   "type": "module",
@@ -16,7 +16,7 @@
     "@danypops/vehicle-client": "^0.10.1",
     "@danypops/vehicle-core": "^0.17.1",
     "@danypops/vehicle-server": "^0.25.1",
-    "@danypops/jittor": "^0.20.0",
+    "@danypops/jittor": "^0.22.0",
     "malevich-tui-components": "^0.28.0"
   },
   "peerDependencies": {
@@ -26,7 +26,7 @@
   },
   "devDependencies": {
     "@danypops/pi-extension-harness": "^0.6.2",
-    "@danypops/pi-process-harness": "^0.1.2",
+    "@danypops/pi-process-harness": "^0.3.2",
     "@danypops/pi-tui-harness": "^0.0.2",
     "@earendil-works/pi-ai": "*",
     "bun-types": "latest"