@danypops/pi-jittor 0.1.0

package/extension/src/service-client.ts

@@ -0,0 +1,28 @@
+import { createRetryingClient, type RetryingClient } from "@danypops/daemon-kit/pi-client";
+import { connectJittorClient, type JittorClient, type OperationInputs, type OperationName, type OperationOutputs } from "@danypops/jittor";
+
+type JittorConnector = () => Promise<JittorClient>;
+
+function defaultConnector(): Promise<JittorClient> {
+	return Promise.resolve(connectJittorClient());
+}
+
+let connector: JittorConnector = defaultConnector;
+let retrying: RetryingClient<JittorClient> = createRetryingClient(() => connector(), { label: "Jittor" });
+
+export async function callJittor<Name extends OperationName>(
+	operation: Name,
+	input: OperationInputs[Name],
+): Promise<OperationOutputs[Name]> {
+	return retrying.call((client) => client.call(operation, input));
+}
+
+export function setJittorClientConnectorForTests(value: JittorConnector): void {
+	connector = value;
+	retrying = createRetryingClient(() => connector(), { label: "Jittor" });
+}
+
+export function resetJittorClientForTests(): void {
+	connector = defaultConnector;
+	retrying = createRetryingClient(() => connector(), { label: "Jittor" });
+}

package/extension/src/session-identity.ts

@@ -0,0 +1,20 @@
+/**
+ * Client-side cache for this extension's own session_secret, registered with the daemon at
+ * session_start and released at session_shutdown (see index.ts). Keyed by sessionId rather
+ * than a single "current" variable, matching every router call site's own explicit sessionId.
+ */
+const secretsBySessionId = new Map<string, string>();
+
+export function cacheSessionSecret(sessionId: string, secret: string): void {
+	secretsBySessionId.set(sessionId, secret);
+}
+
+export function forgetSessionSecret(sessionId: string): void {
+	secretsBySessionId.delete(sessionId);
+}
+
+/** Spread into any router-mutating request body alongside session_id -- empty object when no secret is cached for this sessionId (unregistered, or registration hasn't completed yet), matching the daemon's opt-in-armor default. */
+export function sessionSecretField(sessionId: string | undefined): { session_secret?: string } {
+	const secret = sessionId ? secretsBySessionId.get(sessionId) : undefined;
+	return secret ? { session_secret: secret } : {};
+}

package/extension/src/settings-tui.ts

@@ -0,0 +1,153 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { USAGE_PERIODS, type UsagePeriod } from "@danypops/jittor";
+import type { CodexRecoveryControl, EnforcementControl, UsageBudgetControl } from "./settings.ts";
+
+export interface SettingsSnapshot {
+	enforcementEnabled: boolean;
+	footerEnabled: boolean;
+	codexRecoveryEnabled: boolean;
+	usageTokenBudgets: Partial<Record<UsagePeriod, number>>;
+}
+
+interface SettingsTheme {
+	fg(color: "accent" | "success" | "warning" | "error" | "muted" | "dim" | "borderMuted", text: string): string;
+	bold(text: string): string;
+}
+
+type SettingsKey = "enforcement" | "footer" | "recovery" | `budget-${UsagePeriod}`;
+type SettingsAction = { kind: "activate"; key: SettingsKey } | { kind: "close" };
+
+export interface SettingsEffects {
+	setEnforcement(enabled: boolean): void | Promise<void>;
+	setFooter(enabled: boolean): void | Promise<void>;
+	setRecovery(enabled: boolean): void | Promise<void>;
+}
+
+const SETTINGS_KEYS: SettingsKey[] = [
+	"enforcement",
+	"footer",
+	"recovery",
+	...USAGE_PERIODS.map(({ id }) => `budget-${id}` as const),
+];
+
+function state(enabled: boolean, theme: SettingsTheme): string {
+	return enabled ? theme.fg("success", "ON") : theme.fg("muted", "OFF");
+}
+
+function budgetLabel(period: UsagePeriod, snapshot: SettingsSnapshot): string {
+	const value = snapshot.usageTokenBudgets[period];
+	return value === undefined ? "not configured" : `${value.toLocaleString()} tokens`;
+}
+
+function rowText(key: SettingsKey, snapshot: SettingsSnapshot, theme: SettingsTheme): string {
+	if (key === "enforcement") return `Routing enforcement  ${state(snapshot.enforcementEnabled, theme)}`;
+	if (key === "footer") return `Informational footer  ${state(snapshot.footerEnabled, theme)}`;
+	if (key === "recovery") return `Codex recovery  ${state(snapshot.codexRecoveryEnabled, theme)}`;
+	const period = key.slice("budget-".length) as UsagePeriod;
+	return `${USAGE_PERIODS.find((candidate) => candidate.id === period)!.label} token budget  ${budgetLabel(period, snapshot)}`;
+}
+
+export function settingsSnapshot(
+	enforcement: EnforcementControl,
+	recovery: CodexRecoveryControl,
+	budgets: UsageBudgetControl,
+): SettingsSnapshot {
+	return {
+		enforcementEnabled: enforcement.isEnabled(),
+		footerEnabled: enforcement.isFooterEnabled(),
+		codexRecoveryEnabled: recovery.isCodexRecoveryEnabled(),
+		usageTokenBudgets: Object.fromEntries(USAGE_PERIODS.map(({ id }) => [id, budgets.getUsageTokenBudget(id)])),
+	};
+}
+
+export function renderSettingsView(snapshot: SettingsSnapshot, selected: number, width: number, theme: SettingsTheme): string[] {
+	const safeWidth = Math.max(20, width);
+	const lines = [
+		theme.bold("Jittor Settings"),
+		theme.fg("dim", "Token budgets are user values; provider quotas remain separate."),
+		"",
+	];
+	for (let index = 0; index < SETTINGS_KEYS.length; index += 1) {
+		const selectedRow = index === selected;
+		const prefix = selectedRow ? theme.fg("accent", "› ") : "  ";
+		lines.push(`${prefix}${rowText(SETTINGS_KEYS[index]!, snapshot, theme)}`);
+	}
+	lines.push("", theme.fg("dim", "↑/↓ select · Enter edit · Esc close"));
+	return lines.map((line) => visibleWidth(line) <= safeWidth ? line : truncateToWidth(line, safeWidth, "…"));
+}
+
+function plainTheme(): SettingsTheme {
+	return { fg: (_color, text) => text, bold: (text) => text };
+}
+
+async function editBudget(ctx: ExtensionCommandContext, budgets: UsageBudgetControl, period: UsagePeriod): Promise<void> {
+	const label = USAGE_PERIODS.find((candidate) => candidate.id === period)!.label;
+	const current = budgets.getUsageTokenBudget(period);
+	const input = await ctx.ui.input(`${label} token budget`, current?.toLocaleString() ?? "positive token count or off");
+	if (input === undefined) return;
+	const normalized = input.trim().toLowerCase();
+	if (normalized === "off" || normalized === "clear") {
+		budgets.setUsageTokenBudget(period, undefined);
+		ctx.ui.notify(`${label} token budget cleared.`, "info");
+		return;
+	}
+	const tokens = Number(normalized.replaceAll(",", ""));
+	if (!Number.isFinite(tokens) || tokens <= 0) {
+		ctx.ui.notify("Enter a positive token count, or `off` to clear this threshold.", "warning");
+		return;
+	}
+	budgets.setUsageTokenBudget(period, tokens);
+	ctx.ui.notify(`${label} token budget set to ${tokens.toLocaleString()} tokens.`, "info");
+}
+
+export async function showSettingsPanel(
+	ctx: ExtensionCommandContext,
+	enforcement: EnforcementControl,
+	recovery: CodexRecoveryControl,
+	budgets: UsageBudgetControl,
+	effects: SettingsEffects = {
+		setEnforcement: (enabled) => enforcement.setEnabled(enabled),
+		setFooter: (enabled) => enforcement.setFooterEnabled(enabled),
+		setRecovery: (enabled) => recovery.setCodexRecoveryEnabled(enabled),
+	},
+): Promise<void> {
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify(renderSettingsView(settingsSnapshot(enforcement, recovery, budgets), -1, 100, plainTheme()).slice(0, -2).join("\n"), "info");
+		return;
+	}
+	for (;;) {
+		const snapshot = settingsSnapshot(enforcement, recovery, budgets);
+		const action = await ctx.ui.custom<SettingsAction>((tui, theme, _keybindings, done) => {
+			let selected = 0;
+			return {
+				invalidate() {},
+				render(width: number): string[] { return renderSettingsView(snapshot, selected, width, theme); },
+				handleInput(data: string): void {
+					if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || data === "q") done({ kind: "close" });
+					else if (matchesKey(data, "up")) { selected = (selected - 1 + SETTINGS_KEYS.length) % SETTINGS_KEYS.length; tui.requestRender(); }
+					else if (matchesKey(data, "down")) { selected = (selected + 1) % SETTINGS_KEYS.length; tui.requestRender(); }
+					else if (matchesKey(data, "return") || matchesKey(data, "enter") || matchesKey(data, "space")) done({ kind: "activate", key: SETTINGS_KEYS[selected]! });
+				},
+			};
+		});
+		if (!action || action.kind === "close") return;
+		if (action.key === "enforcement") {
+			if (enforcement.isEnabled()) {
+				if (await ctx.ui.confirm("Disable routing enforcement?", "Jittor will remain monitor-only and will no longer block unsafe provider requests.")) await effects.setEnforcement(false);
+			} else await effects.setEnforcement(true);
+			continue;
+		}
+		if (action.key === "footer") {
+			await effects.setFooter(!enforcement.isFooterEnabled());
+			continue;
+		}
+		if (action.key === "recovery") {
+			if (!recovery.isCodexRecoveryEnabled()) {
+				if (await ctx.ui.confirm("Enable Codex recovery?", "Jittor may start bounded hidden retries only after transient Codex failures fully settle.")) await effects.setRecovery(true);
+			} else await effects.setRecovery(false);
+			continue;
+		}
+		await editBudget(ctx, budgets, action.key.slice("budget-".length) as UsagePeriod);
+	}
+}

package/extension/src/settings.ts

@@ -0,0 +1,102 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { JITTOR_EXTENSION_SETTINGS_FILENAME, JITTOR_STATE_DIRECTORY, USAGE_PERIODS, type UsagePeriod } from "@danypops/jittor";
+
+export interface EnforcementControl {
+	isEnabled(): boolean;
+	setEnabled(enabled: boolean): void;
+	isFooterEnabled(): boolean;
+	setFooterEnabled(enabled: boolean): void;
+}
+
+export interface CodexRecoveryControl {
+	isCodexRecoveryEnabled(): boolean;
+	setCodexRecoveryEnabled(enabled: boolean): void;
+}
+
+export interface UsageBudgetControl {
+	getUsageTokenBudget(period: UsagePeriod): number | undefined;
+	setUsageTokenBudget(period: UsagePeriod, tokens: number | undefined): void;
+}
+
+export interface PersistentExtensionControl extends EnforcementControl, CodexRecoveryControl, UsageBudgetControl {}
+
+interface ExtensionSettings {
+	enforcementEnabled: boolean;
+	footerEnabled: boolean;
+	codexRecoveryEnabled: boolean;
+	usageTokenBudgets: Partial<Record<UsagePeriod, number>>;
+}
+
+function defaultSettings(): ExtensionSettings {
+	return { enforcementEnabled: true, footerEnabled: true, codexRecoveryEnabled: false, usageTokenBudgets: {} };
+}
+
+function parseUsageTokenBudgets(value: unknown): Partial<Record<UsagePeriod, number>> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	const record = value as Record<string, unknown>;
+	return Object.fromEntries(USAGE_PERIODS.flatMap(({ id }) => {
+		const tokens = record[id];
+		return typeof tokens === "number" && Number.isFinite(tokens) && tokens > 0 ? [[id, tokens]] : [];
+	})) as Partial<Record<UsagePeriod, number>>;
+}
+
+function settingsPath(env: Record<string, string | undefined> = process.env): string {
+	const config = env["XDG_CONFIG_HOME"] ?? join(env["HOME"] ?? ".", ".config");
+	return join(config, JITTOR_STATE_DIRECTORY, JITTOR_EXTENSION_SETTINGS_FILENAME);
+}
+
+function loadSettings(path: string): ExtensionSettings {
+	try {
+		const value = JSON.parse(readFileSync(path, "utf8")) as unknown;
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return defaultSettings();
+		const record = value as Record<string, unknown>;
+		return {
+			enforcementEnabled: record["enforcementEnabled"] !== false,
+			footerEnabled: record["footerEnabled"] !== false,
+			codexRecoveryEnabled: record["codexRecoveryEnabled"] === true,
+			usageTokenBudgets: parseUsageTokenBudgets(record["usageTokenBudgets"]),
+		};
+	} catch {
+		return defaultSettings();
+	}
+}
+
+function persistSettings(path: string, settings: ExtensionSettings): void {
+	mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+	const temporary = `${path}.${process.pid}.tmp`;
+	writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
+	chmodSync(temporary, 0o600);
+	renameSync(temporary, path);
+}
+
+export function persistentEnforcementControl(env: Record<string, string | undefined> = process.env): PersistentExtensionControl {
+	const path = settingsPath(env);
+	const settings = loadSettings(path);
+	return {
+		isEnabled: () => settings.enforcementEnabled,
+		setEnabled(value: boolean): void {
+			settings.enforcementEnabled = value;
+			persistSettings(path, settings);
+		},
+		isFooterEnabled: () => settings.footerEnabled,
+		setFooterEnabled(value: boolean): void {
+			settings.footerEnabled = value;
+			persistSettings(path, settings);
+		},
+		isCodexRecoveryEnabled: () => settings.codexRecoveryEnabled,
+		setCodexRecoveryEnabled(value: boolean): void {
+			settings.codexRecoveryEnabled = value;
+			persistSettings(path, settings);
+		},
+		getUsageTokenBudget(period): number | undefined {
+			return settings.usageTokenBudgets[period];
+		},
+		setUsageTokenBudget(period, tokens): void {
+			if (tokens !== undefined && (!Number.isFinite(tokens) || tokens <= 0)) throw new Error("usage token budget must be a positive finite number");
+			if (tokens === undefined) delete settings.usageTokenBudgets[period];
+			else settings.usageTokenBudgets[period] = tokens;
+			persistSettings(path, settings);
+		},
+	};
+}

package/extension/src/tui.ts

@@ -0,0 +1,284 @@
+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,
+	type MetricQuery,
+	type PolicyAction,
+	type Route,
+	type RouterStatus,
+	type StoredMetricObservation,
+} from "@danypops/jittor";
+import type { ProviderBudget } from "./footer.ts";
+import { sessionSecretField } from "./session-identity.ts";
+
+export interface JittorPanelClient {
+	call(operation: string, input: unknown): Promise<any>;
+}
+
+export function providerBudgetMetricQuery(status: RouterStatus): MetricQuery | null {
+	switch (status.currentRoute?.provider) {
+		case "openai-codex": return { source: "codex-subscription", metric: "used-fraction", order: "desc", limit: 100 };
+		case "openrouter": return { source: "openrouter", order: "desc", limit: 20 };
+		case "anthropic": return { source: "anthropic", metric: "used-fraction", order: "desc", limit: 20 };
+		case "anthropic-vertex": return { source: "anthropic-vertex", metric: "used-fraction", order: "desc", limit: 20 };
+		default: return null;
+	}
+}
+
+type PanelAction = "pause" | "resume" | "refresh" | "override" | "clear-override" | "close";
+
+function latest(rows: StoredMetricObservation[], predicate: (row: StoredMetricObservation) => boolean): StoredMetricObservation | undefined {
+	return rows.filter(predicate).sort((left, right) => right.observedAt - left.observedAt || right.id - left.id)[0];
+}
+
+function sanitizedText(value: string): string {
+	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 {
+	return typeof value === "string" ? value.toLowerCase().replace(/[^a-z0-9]+/g, "") : "";
+}
+
+function longestWindow(rows: StoredMetricObservation[]): StoredMetricObservation | undefined {
+	return [...rows].sort((left, right) =>
+		Number(right.attributes["windowSeconds"] ?? 0) - Number(left.attributes["windowSeconds"] ?? 0)
+		|| right.observedAt - left.observedAt
+		|| right.id - left.id,
+	)[0];
+}
+
+function codexWindowForModel(rows: StoredMetricObservation[], model: string): StoredMetricObservation | undefined {
+	const codexRows = rows.filter((row) => row.source === "codex-subscription" && row.metric === "used-fraction" && typeof row.value === "number");
+	const modelIdentity = normalizedIdentity(model);
+	const matchingAdditional = codexRows.filter((row) => {
+		const limitId = normalizedIdentity(row.attributes["limitId"]);
+		const limitName = normalizedIdentity(row.attributes["limitName"]);
+		return limitId !== "codex" && limitName.length > 0 && limitName === modelIdentity;
+	});
+	if (matchingAdditional.length > 0) return longestWindow(matchingAdditional);
+	return longestWindow(codexRows.filter((row) => {
+		const limitId = normalizedIdentity(row.attributes["limitId"]);
+		return limitId === "codex" || (limitId.length === 0 && row.scope.startsWith("codex:"));
+	}));
+}
+
+function compactWindowName(seconds: number): string {
+	if (seconds >= 6 * 24 * 60 * 60) return "W";
+	if (seconds >= 60 * 60) return `${Math.round(seconds / 3_600)}h`;
+	return `${Math.round(seconds / 60)}m`;
+}
+
+function windowName(seconds: number): string {
+	if (seconds >= 6 * 24 * 60 * 60) return "weekly";
+	if (seconds >= 60 * 60) return `${Math.round(seconds / 3_600)}h`;
+	return `${Math.round(seconds / 60)}m`;
+}
+
+/**
+ * `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);
+		if (!codex || typeof codex.value !== "number") return null;
+		const resetsAtSeconds = Number(codex.attributes["resetsAt"]);
+		return {
+			kind: "bounded",
+			label: compactWindowName(Number(codex.attributes["windowSeconds"] ?? 0)),
+			remainingFraction: 1 - codex.value,
+			observedAt: codex.observedAt,
+			...(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");
+		if (remaining && typeof remaining.value === "number" && (!openRouter || remaining.observedAt >= openRouter.observedAt)) {
+			const reset = typeof remaining.attributes["reset"] === "string" ? sanitizedText(remaining.attributes["reset"]) : undefined;
+			return {
+				kind: "bounded",
+				label: "OR",
+				remainingFraction: remaining.value,
+				observedAt: remaining.observedAt,
+				...(reset ? { resetText: `${reset} reset` } : {}),
+			};
+		}
+		if (!openRouter || typeof openRouter.value !== "number") return null;
+		return { kind: "unbounded", label: "spend", valueText: `$${openRouter.value.toFixed(3)}`, observedAt: openRouter.observedAt };
+	}
+	return undefined;
+}
+
+export function formatFooterStatus(status: RouterStatus, metrics: StoredMetricObservation[]): string {
+	const budget = buildFooterBudget(status, metrics);
+	if (!budget) return "";
+	return budget.kind === "unbounded" ? budget.valueText : `${budget.label} ${(budget.remainingFraction * 100).toFixed(1)}% left`;
+}
+
+function nextAction(action: PolicyAction | undefined): string {
+	switch (action) {
+		case "continue": return "throttle";
+		case "throttle": return "lower thinking";
+		case "lower-thinking": return "switch model";
+		case "switch-model": return "switch provider";
+		case "switch-provider": return "halt";
+		case "halt": return "halted";
+		default: return "waiting for decision";
+	}
+}
+
+function burnLine(rows: StoredMetricObservation[], current: StoredMetricObservation, now: number): string {
+	const previous = rows
+		.filter((row) => row.source === current.source && row.scope === current.scope && row.metric === current.metric && row.id !== current.id && row.observedAt < current.observedAt)
+		.sort((left, right) => right.observedAt - left.observedAt)[0];
+	const resetsAt = Number(current.attributes["resetsAt"] ?? 0) * 1_000;
+	const remainingSeconds = (resetsAt - now) / 1_000;
+	const sustainable = typeof current.value === "number" && remainingSeconds > 0 ? (1 - current.value) / remainingSeconds : null;
+	const observed = previous && typeof previous.value === "number" && typeof current.value === "number" && current.observedAt > previous.observedAt
+		? (current.value - previous.value) / ((current.observedAt - previous.observedAt) / 1_000)
+		: null;
+	const perHour = (rate: number | null) => rate === null ? "n/a" : `${(rate * 3_600 * 100).toFixed(2)}%/h`;
+	return `Burn: observed ${perHour(observed)} · sustainable ${perHour(sustainable)}`;
+}
+
+export function buildStatusView(status: RouterStatus, metrics: StoredMetricObservation[], now = Date.now()): string[] {
+	const lines = [status.ready ? "Ready" : "Not ready"];
+	const codex = status.currentRoute?.provider === "openai-codex" ? codexWindowForModel(metrics, status.currentRoute.model) : undefined;
+	if (codex && typeof codex.value === "number") {
+		const seconds = Number(codex.attributes["windowSeconds"] ?? 0);
+		lines.push(`Codex ${windowName(seconds)}: ${((1 - codex.value) * 100).toFixed(1)}% left`);
+		lines.push(burnLine(metrics, codex, now));
+	}
+	const openRouter = status.currentRoute?.provider === "openrouter"
+		? 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)}`);
+	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:");
+	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(`  ${sanitizedText(source.id)}: ${freshness} · ${source.metrics} metrics`);
+	}
+	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;
+}
+
+async function snapshot(client: JittorPanelClient, sessionId: string): Promise<{ status: RouterStatus; metrics: StoredMetricObservation[] }> {
+	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[] : [];
+	return { status, metrics };
+}
+
+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(routeText);
+	const selected = await ctx.ui.select("Override route", labels);
+	const index = selected ? labels.indexOf(selected) : -1;
+	return index >= 0 ? routes[index] : undefined;
+}
+
+export async function showJittorPanel(ctx: ExtensionCommandContext, client: JittorPanelClient): Promise<void> {
+	const session_id = ctx.sessionManager.getSessionId();
+	for (;;) {
+		const current = await snapshot(client, session_id);
+		if (ctx.mode !== "tui") {
+			ctx.ui.notify(buildStatusView(current.status, current.metrics).join("\n"), "info");
+			return;
+		}
+		const action = await ctx.ui.custom<PanelAction>((_tui, theme, _keybindings, done) => ({
+			invalidate() {},
+			render(width: number): string[] {
+				const border = theme.fg("borderMuted", "─".repeat(Math.max(1, width)));
+				const controls = current.status.paused
+					? "r refresh · p release emergency halt · o override · c clear override · Esc close"
+					: "r refresh · p emergency halt · o override · c clear override · Esc close";
+				return [
+					border,
+					truncateToWidth(theme.bold("Jittor"), width, ""),
+					border,
+					...buildStatusView(current.status, current.metrics).map((line) => truncateToWidth(` ${line}`, width, "…")),
+					border,
+					truncateToWidth(theme.fg("dim", controls), width, "…"),
+					border,
+				];
+			},
+			handleInput(data: string): void {
+				if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) done("close");
+				else if (data === "r") done("refresh");
+				else if (data === "p") done(current.status.paused ? "resume" : "pause");
+				else if (data === "o") done("override");
+				else if (data === "c") done("clear-override");
+			},
+		}));
+		if (!action || action === "close") return;
+		if (action === "refresh") { await client.call("telemetry.poll", {}); continue; }
+		if (action === "pause" || action === "resume") {
+			if (await ctx.ui.confirm(action === "pause" ? "Emergency-halt provider requests?" : "Release emergency halt?", "This changes provider-request enforcement. Use /jittor off to disable blocking entirely.")) {
+				await client.call(action === "pause" ? "router.pause" : "router.resume", { session_id, ...sessionSecretField(session_id) });
+			}
+			continue;
+		}
+		if (action === "clear-override") {
+			if (await ctx.ui.confirm("Clear route override?", "Policy-controlled routing will resume.")) await client.call("router.clear_override", { session_id, ...sessionSecretField(session_id) });
+			continue;
+		}
+		const route = await chooseOverride(ctx, current.status.availableRoutes);
+		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, session_id, ...sessionSecretField(session_id) });
+		}
+	}
+}