@danypops/jittor 0.1.0

package/extension/src/footer.ts

@@ -0,0 +1,232 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import {
+	FOOTER_BAR_MAX_WIDTH,
+	FOOTER_BAR_MIN_WIDTH,
+	FOOTER_CONTEXT_ACCENT_FRACTION,
+	FOOTER_CONTEXT_ERROR_FRACTION,
+	FOOTER_CONTEXT_WARNING_FRACTION,
+	FOOTER_WIDE_TERMINAL_WIDTH,
+	TELEMETRY_STALE_AFTER_MS,
+} from "../../src/constants.ts";
+
+type FooterColor = "accent" | "dim" | "warning" | "error";
+
+interface FooterTheme {
+	fg(color: FooterColor, text: string): string;
+	bold(text: string): string;
+}
+
+interface FooterData {
+	getGitBranch(): string | null | undefined;
+	getAvailableProviderCount(): number;
+	getExtensionStatuses(): ReadonlyMap<string, string>;
+	onBranchChange?(callback: () => void): () => void;
+}
+
+interface ContextUsage {
+	tokens: number | null;
+	percent: number | null;
+	contextWindow: number;
+}
+
+interface FooterContext {
+	model?: { provider: string; id: string; reasoning?: boolean; contextWindow?: number };
+	modelRegistry: { isUsingOAuth(model: unknown): boolean };
+	getContextUsage(): ContextUsage | undefined;
+	sessionManager: {
+		getCwd(): string;
+		getSessionName(): string | undefined;
+		getEntries(): Array<{ type: string; message?: any }>;
+	};
+}
+
+/** A provider usage value suitable for the footer. Null fraction means no known denominator. */
+export interface ProviderBudget {
+	label: string;
+	fraction: number | null;
+	valueText: string;
+	observedAt?: number;
+}
+
+interface UsageTotals {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+	cacheHit?: number;
+}
+
+function formatTokens(count: number): string {
+	if (count < 1_000) return count.toString();
+	if (count < 10_000) return `${(count / 1_000).toFixed(1)}k`;
+	if (count < 1_000_000) return `${Math.round(count / 1_000)}k`;
+	if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+	return `${Math.round(count / 1_000_000)}M`;
+}
+
+function footerCwd(cwd: string, home: string | undefined): string {
+	if (!home) return cwd;
+	const resolvedCwd = resolve(cwd);
+	const resolvedHome = resolve(home);
+	const relativeToHome = relative(resolvedHome, resolvedCwd);
+	const inside = relativeToHome === "" || (relativeToHome !== ".." && !relativeToHome.startsWith(`..${sep}`) && !isAbsolute(relativeToHome));
+	if (!inside) return cwd;
+	return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
+}
+
+function sanitize(value: string): string {
+	return value.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+}
+
+function usageTotals(context: FooterContext): UsageTotals {
+	let input = 0, output = 0, cacheRead = 0, cacheWrite = 0, cost = 0, cacheHit: number | undefined;
+	for (const entry of context.sessionManager.getEntries()) {
+		if (entry.type !== "message" || entry.message?.role !== "assistant") continue;
+		const usage = entry.message.usage;
+		input += usage?.input ?? 0;
+		output += usage?.output ?? 0;
+		cacheRead += usage?.cacheRead ?? 0;
+		cacheWrite += usage?.cacheWrite ?? 0;
+		cost += usage?.cost?.total ?? 0;
+		const prompt = (usage?.input ?? 0) + (usage?.cacheRead ?? 0) + (usage?.cacheWrite ?? 0);
+		if (prompt > 0) cacheHit = (usage.cacheRead ?? 0) / prompt * 100;
+	}
+	return { input, output, cacheRead, cacheWrite, cost, ...(cacheHit === undefined ? {} : { cacheHit }) };
+}
+
+function barWidth(width: number): number {
+	return width >= FOOTER_WIDE_TERMINAL_WIDTH ? FOOTER_BAR_MAX_WIDTH : FOOTER_BAR_MIN_WIDTH;
+}
+
+function progressBar(fraction: number | null, width: number): string {
+	if (fraction === null || !Number.isFinite(fraction)) return "░".repeat(width);
+	const clamped = Math.min(1, Math.max(0, fraction));
+	const filled = Math.round(width * clamped);
+	return "█".repeat(filled) + "░".repeat(width - filled);
+}
+
+function fillColor(fraction: number | null): FooterColor {
+	if (fraction === null || !Number.isFinite(fraction)) return "dim";
+	if (fraction > FOOTER_CONTEXT_ERROR_FRACTION) return "error";
+	if (fraction > FOOTER_CONTEXT_WARNING_FRACTION) return "warning";
+	if (fraction > FOOTER_CONTEXT_ACCENT_FRACTION) return "accent";
+	return "dim";
+}
+
+function contextSegment(context: FooterContext, theme: FooterTheme, width: number, compact: boolean): string {
+	const usage = context.getContextUsage();
+	const window = usage?.contextWindow ?? context.model?.contextWindow ?? 0;
+	const fraction = usage?.percent === null || usage?.percent === undefined ? null : usage.percent / 100;
+	const bar = theme.fg(fillColor(fraction), progressBar(fraction, barWidth(width)));
+	if (usage?.tokens === null || usage?.tokens === undefined) return `ctx ${bar} ?/${formatTokens(window)}`;
+	const value = compact ? `${Math.round((fraction ?? 0) * 100)}%` : `${formatTokens(usage.tokens)}/${formatTokens(window)}`;
+	return `ctx ${bar} ${value}`;
+}
+
+function budgetSegment(budget: ProviderBudget | null, theme: FooterTheme, width: number, compact: boolean, now: number): string {
+	const w = barWidth(width);
+	if (!budget) return `budget ${theme.fg("dim", progressBar(null, w))} ?`;
+	if (budget.fraction === null) return `${budget.label} ${budget.valueText}`;
+	const bar = theme.fg(fillColor(budget.fraction), progressBar(budget.fraction, w));
+	const value = compact ? `${Math.round(budget.fraction * 100)}%` : budget.valueText;
+	const stale = budget.observedAt !== undefined && now - budget.observedAt > TELEMETRY_STALE_AFTER_MS;
+	return `${budget.label} ${bar} ${value}${stale ? ` ${theme.fg("warning", "stale")}` : ""}`;
+}
+
+function usageSegment(context: FooterContext): string {
+	const totals = usageTotals(context);
+	const parts: string[] = [];
+	if (totals.input) parts.push(`↑${formatTokens(totals.input)}`);
+	if (totals.output) parts.push(`↓${formatTokens(totals.output)}`);
+	if (totals.cacheRead) parts.push(`R${formatTokens(totals.cacheRead)}`);
+	if (totals.cacheWrite) parts.push(`W${formatTokens(totals.cacheWrite)}`);
+	if ((totals.cacheRead || totals.cacheWrite) && totals.cacheHit !== undefined) parts.push(`CH${totals.cacheHit.toFixed(1)}%`);
+	if (totals.cost || (context.model && context.modelRegistry.isUsingOAuth(context.model))) {
+		parts.push(`$${totals.cost.toFixed(3)}${context.model && context.modelRegistry.isUsingOAuth(context.model) ? " (sub)" : ""}`);
+	}
+	return parts.join(" ");
+}
+
+function identityLines(context: FooterContext, footerData: FooterData, theme: FooterTheme, thinkingLevel: string, width: number): string[] {
+	let cwd = footerCwd(context.sessionManager.getCwd(), process.env.HOME ?? process.env.USERPROFILE);
+	const branch = footerData.getGitBranch();
+	if (branch) cwd += ` (${branch})`;
+	const sessionName = context.sessionManager.getSessionName();
+	if (sessionName) cwd += ` · ${sessionName}`;
+	const repo = `${theme.bold("Repo")} ${theme.fg("dim", cwd)}`;
+
+	const model = context.model;
+	const provider = model && footerData.getAvailableProviderCount() > 1 ? `(${model.provider}) ` : "";
+	const thinking = model?.reasoning ? ` · ${thinkingLevel === "off" ? "thinking off" : thinkingLevel}` : "";
+	const ai = `${theme.bold("AI")} ${provider}${model?.id ?? "no-model"}${thinking}`;
+	const gap = width - visibleWidth(repo) - visibleWidth(ai);
+	if (gap >= 2) return [`${repo}${" ".repeat(gap)}${ai}`];
+	return [truncateToWidth(repo, width, "…"), truncateToWidth(ai, width, "…")];
+}
+
+function statusLines(context: FooterContext, budget: ProviderBudget | null, theme: FooterTheme, width: number, now: number): string[] {
+	const usage = usageSegment(context);
+	const fullContext = contextSegment(context, theme, width, false);
+	const fullBudget = budgetSegment(budget, theme, width, false, now);
+	const fullParts = [usage, fullContext, fullBudget].filter(Boolean);
+	const full = `${theme.bold("LLM")} ${fullParts.join(" · ")}`;
+	if (visibleWidth(full) <= width) return [full];
+
+	const compactContext = contextSegment(context, theme, width, true);
+	const compactBudget = budgetSegment(budget, theme, width, true, now);
+	const compact = `${theme.bold("LLM")} ${compactContext} · ${compactBudget}`;
+	if (visibleWidth(compact) <= width) return [compact];
+	return [
+		truncateToWidth(`${theme.bold("LLM")} ${compactContext}`, width, ""),
+		truncateToWidth(`${theme.bold("LLM")} ${compactBudget}`, width, ""),
+	];
+}
+
+export function renderFooterLines(
+	context: FooterContext,
+	footerData: FooterData,
+	theme: FooterTheme,
+	providerBudget: ProviderBudget | null,
+	thinkingLevel: string,
+	width: number,
+	now = Date.now(),
+): string[] {
+	const safeWidth = Math.max(1, width);
+	const lines = [
+		...identityLines(context, footerData, theme, thinkingLevel, safeWidth),
+		...statusLines(context, providerBudget, theme, safeWidth, now),
+	];
+	const statuses = [...footerData.getExtensionStatuses().entries()]
+		.filter(([key]) => key !== "jittor")
+		.sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
+		.map(([, text]) => sanitize(text));
+	if (statuses.length > 0) lines.push(truncateToWidth(statuses.join(" "), safeWidth, theme.fg("dim", "…")));
+	return lines.map((line) => truncateToWidth(line, safeWidth, ""));
+}
+
+export interface IntegratedFooterState {
+	providerBudget: ProviderBudget | null;
+	requestRender?: () => void;
+}
+
+export function installIntegratedFooter(ctx: ExtensionContext, state: IntegratedFooterState, getThinkingLevel: () => string): void {
+	ctx.ui.setStatus("jittor", undefined);
+	ctx.ui.setFooter((tui, theme, footerData) => {
+		state.requestRender = () => tui.requestRender();
+		const unsubscribe = (footerData as FooterData).onBranchChange?.(() => tui.requestRender());
+		return {
+			invalidate() {},
+			render(width: number): string[] {
+				return renderFooterLines(ctx as unknown as FooterContext, footerData, theme, state.providerBudget, getThinkingLevel(), width);
+			},
+			dispose() {
+				unsubscribe?.();
+				state.requestRender = undefined;
+				tui.requestRender();
+			},
+		};
+	});
+}

package/extension/src/index.ts

@@ -0,0 +1,317 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { MAX_DYNAMIC_ROUTES } from "../../src/constants.ts";
+import type { MetricObservation, StoredMetricObservation } from "../../src/domain/metric.ts";
+import type { PolicyDecision, Route } from "../../src/policy.ts";
+import type { RouterStatus } from "../../src/ports/router-controller.ts";
+import { parseCodexRateLimitHeaders } from "../../src/providers/codex.ts";
+import { installIntegratedFooter, type IntegratedFooterState } from "./footer.ts";
+import { callJittor } from "./service-client.ts";
+import { persistentEnforcementControl, type EnforcementControl } from "./settings.ts";
+import { buildFooterBudget, formatFooterStatus, showJittorPanel } from "./tui.ts";
+import { showUsagePanel } from "./usage.ts";
+
+export { formatFooterStatus } from "./tui.ts";
+
+const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const RECOVERY_GUIDANCE = "Run /jittor off to disable blocking, or restart the daemon with: systemctl --user restart jittor.service";
+
+export interface JittorExtensionClient {
+	call(operation: string, input: unknown): Promise<any>;
+}
+
+const daemonClient: JittorExtensionClient = {
+	call: (operation, input) => callJittor(operation as Parameters<typeof callJittor>[0], input as never),
+};
+
+async function recordMetrics(client: JittorExtensionClient, metrics: MetricObservation[]): Promise<void> {
+	for (const metric of metrics) await client.call("metrics.record", metric);
+}
+
+async function refreshFooter(client: JittorExtensionClient, state: IntegratedFooterState): Promise<void> {
+	const status = await client.call("router.status", {}) as RouterStatus;
+	const provider = status.currentRoute?.provider;
+	const query = provider === "openai-codex"
+		? { source: "codex-subscription", metric: "used-fraction", limit: 100, order: "desc" }
+		: provider === "openrouter" ? { source: "openrouter", metric: "usage", limit: 10, order: "desc" } : null;
+	const metrics = query ? await client.call("metrics.query", query) as StoredMetricObservation[] : [];
+	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);
+}
+
+async function applyRoute(pi: ExtensionAPI, ctx: ExtensionContext, route: Route): Promise<boolean> {
+	if (!routeModelAvailable(ctx, route)) return false;
+	const model = ctx.modelRegistry.find(route.provider, route.model);
+	if (!model) return false;
+	if (!ctx.model || ctx.model.provider !== route.provider || ctx.model.id !== route.model) {
+		if (!await pi.setModel(model)) return false;
+	}
+	if (THINKING_LEVELS.has(route.thinking)) pi.setThinkingLevel(route.thinking as Parameters<ExtensionAPI["setThinkingLevel"]>[0]);
+	return true;
+}
+
+interface PiRouteModel {
+	provider: string;
+	id: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: Partial<Record<string, unknown>>;
+	cost?: { input?: number; output?: number };
+}
+
+const THINKING_DESCENDING = ["max", "xhigh", "high", "medium", "low", "minimal", "off"] as const;
+
+function supportsThinking(model: PiRouteModel, level: string): boolean {
+	if (!model.reasoning) return level === "off";
+	return model.thinkingLevelMap?.[level] !== null;
+}
+
+function modelCost(model: PiRouteModel): number {
+	return (model.cost?.input ?? 0) + (model.cost?.output ?? 0);
+}
+
+export function routesFromPi(models: PiRouteModel[], current: PiRouteModel, thinking: string): Route[] {
+	const sameProvider = models
+		.filter((model) => model.provider === current.provider)
+		.filter((model, index, rows) => rows.findIndex((candidate) => candidate.id === model.id) === index);
+	if (!sameProvider.some((model) => model.id === current.id)) sameProvider.push(current);
+	const routes: Route[] = [{ provider: current.provider, model: current.id, thinking }];
+	const currentLevel = THINKING_DESCENDING.indexOf(thinking as typeof THINKING_DESCENDING[number]);
+	const lowerLevels = THINKING_DESCENDING.slice(currentLevel >= 0 ? currentLevel + 1 : 0);
+	for (const level of lowerLevels) {
+		if (supportsThinking(current, level)) routes.push({ provider: current.provider, model: current.id, thinking: level });
+	}
+	const alternatives = sameProvider
+		.filter((model) => model.id !== current.id)
+		.sort((left, right) => modelCost(left) - modelCost(right) || left.id.localeCompare(right.id));
+	for (const model of alternatives) {
+		const level = [thinking, ...lowerLevels].find((candidate) => supportsThinking(model, candidate)) ?? "off";
+		routes.push({ provider: model.provider, model: model.id, thinking: level });
+		if (routes.length >= MAX_DYNAMIC_ROUTES) break;
+	}
+	return routes;
+}
+
+async function syncAvailableRoutes(pi: ExtensionAPI, client: JittorExtensionClient, ctx: ExtensionContext): Promise<void> {
+	if (!ctx.model) { await client.call("router.available_routes", { routes: [] }); return; }
+	const models = ctx.modelRegistry.getAvailable() as PiRouteModel[];
+	const routes = routesFromPi(models, ctx.model as PiRouteModel, pi.getThinkingLevel());
+	await client.call("router.available_routes", { routes });
+}
+
+async function syncCurrentRoute(
+	pi: ExtensionAPI,
+	client: JittorExtensionClient,
+	ctx: ExtensionContext,
+	model = ctx.model,
+	thinking = pi.getThinkingLevel(),
+): Promise<void> {
+	if (!model) return;
+	await client.call("router.current_route", { provider: model.provider, model: model.id, thinking });
+}
+
+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", {}) as PolicyDecision, false);
+	}
+	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[] {
+	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 [];
+	const usage = value["usage"] as Record<string, unknown>;
+	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 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];
+		if (typeof amount === "number" && Number.isFinite(amount)) metrics.push({ source: "pi", scope, metric, value: amount, unit: "tokens", observedAt, attributes });
+	}
+	const cost = typeof usage["cost"] === "object" && usage["cost"] !== null ? (usage["cost"] as Record<string, unknown>)["total"] : undefined;
+	if (typeof cost === "number" && Number.isFinite(cost)) metrics.push({ source: "pi", scope, metric: "cost", value: cost, unit: "usd", observedAt, attributes });
+	return metrics;
+}
+
+export function registerJittorExtension(
+	pi: ExtensionAPI,
+	client: JittorExtensionClient = daemonClient,
+	enforcement: EnforcementControl = persistentEnforcementControl(),
+): void {
+	const footerState: IntegratedFooterState = { providerBudget: null };
+	const showFooter = (ctx: ExtensionContext): void => {
+		if (enforcement.isFooterEnabled()) installIntegratedFooter(ctx, footerState, () => pi.getThinkingLevel());
+		else ctx.ui.setFooter(undefined);
+	};
+	const disable = (ctx: ExtensionContext): void => {
+		enforcement.setEnabled(false);
+		ctx.ui.setStatus("jittor", undefined);
+		showFooter(ctx);
+		ctx.ui.notify("Jittor enforcement is off (monitor-only); the informational footer remains independent and provider requests will not be blocked.", "warning");
+	};
+	const enable = async (ctx: ExtensionContext): Promise<void> => {
+		try {
+			await syncCurrentRoute(pi, client, ctx);
+			await syncAvailableRoutes(pi, client, ctx);
+			await client.call("telemetry.poll", {});
+			const readinessDecision = await client.call("router.decide", {}) as PolicyDecision;
+			if (readinessDecision.action === "halt") throw new Error(readinessDecision.reason);
+			enforcement.setEnabled(true);
+			showFooter(ctx);
+			await refreshFooter(client, footerState);
+			ctx.ui.notify("Jittor enforcement enabled.", "info");
+		} catch (error) {
+			enforcement.setEnabled(false);
+			showFooter(ctx);
+			const reason = error instanceof Error ? error.message : "readiness failed";
+			ctx.ui.notify(`Jittor remains monitor-only: ${reason}. ${RECOVERY_GUIDANCE}.`, "error");
+		}
+	};
+
+	pi.registerCommand("jittor", {
+		description: "Inspect, enable, or disable Jittor routing",
+		handler: async (args, ctx) => {
+			const action = args.trim().toLowerCase();
+			if (action === "off" || action === "disable") { disable(ctx); return; }
+			if (action === "on" || action === "enable") { await enable(ctx); return; }
+			if (action === "footer off" || action === "footer disable") {
+				enforcement.setFooterEnabled(false);
+				ctx.ui.setFooter(undefined);
+				ctx.ui.notify("Jittor footer disabled; routing enforcement is unchanged.", "info");
+				return;
+			}
+			if (action === "footer on" || action === "footer enable") {
+				enforcement.setFooterEnabled(true);
+				showFooter(ctx);
+				await refreshFooter(client, footerState).catch(() => undefined);
+				ctx.ui.notify("Jittor informational footer enabled; routing enforcement is unchanged.", "info");
+				return;
+			}
+			if (!enforcement.isEnabled()) {
+				ctx.ui.notify("Jittor is monitor-only. Run /jittor on to re-enable blocking.", "info");
+				return;
+			}
+			await showJittorPanel(ctx, client);
+		},
+	});
+	pi.registerCommand("jittor-off", {
+		description: "Emergency local bypass: disable Jittor blocking without daemon access",
+		handler: async (_args, ctx) => { disable(ctx); },
+	});
+	pi.registerCommand("jittor-on", {
+		description: "Enable Jittor only after telemetry and routes pass readiness",
+		handler: async (_args, ctx) => { await enable(ctx); },
+	});
+	pi.registerCommand("usage", {
+		description: "Show Jittor token usage over time",
+		handler: async (_args, ctx) => { await showUsagePanel(ctx, client); },
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		ctx.ui.setStatus("jittor", undefined);
+		showFooter(ctx);
+		try {
+			await syncCurrentRoute(pi, client, ctx);
+			await syncAvailableRoutes(pi, client, ctx);
+			await client.call("telemetry.poll", {});
+			await refreshFooter(client, footerState);
+		} catch {
+			footerState.providerBudget = null;
+			footerState.requestRender?.();
+		}
+	});
+
+	pi.on("input", async (event, ctx) => {
+		if (event.source === "extension" || !enforcement.isEnabled()) return { action: "continue" as const };
+		try {
+			const next = await client.call("router.decide", {}) 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 };
+		}
+	});
+
+	pi.on("model_select", async (event, ctx) => {
+		await syncCurrentRoute(pi, client, ctx, event.model).then(() => syncAvailableRoutes(pi, client, ctx)).catch(() => undefined);
+		if (enforcement.isFooterEnabled()) await refreshFooter(client, footerState).catch(() => undefined);
+	});
+
+	pi.on("thinking_level_select", async (event, ctx) => {
+		await syncCurrentRoute(pi, client, ctx, ctx.model, event.level).catch(() => undefined);
+	});
+
+	pi.on("turn_start", async (_event, ctx) => {
+		if (!enforcement.isEnabled()) return;
+		try {
+			await syncCurrentRoute(pi, client, ctx);
+			await syncAvailableRoutes(pi, client, ctx);
+			await applyDecision(pi, client, ctx, await client.call("router.decide", {}) as PolicyDecision);
+			await refreshFooter(client, footerState);
+		} catch {
+			halt(ctx, "Jittor could not verify or apply a safe route");
+		}
+	});
+
+	pi.on("after_provider_response", async (event, ctx) => {
+		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 (enforcement.isFooterEnabled()) await refreshFooter(client, footerState).catch(() => undefined);
+	});
+
+	pi.on("message_end", async (event, _ctx) => {
+		const metrics = assistantUsageMetrics(event.message, Date.now());
+		if (metrics.length > 0) await recordMetrics(client, metrics).catch(() => undefined);
+		if (enforcement.isFooterEnabled()) await refreshFooter(client, footerState).catch(() => undefined);
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		ctx.ui.setStatus("jittor", undefined);
+		ctx.ui.setFooter(undefined);
+	});
+}
+
+export default function jittorExtension(pi: ExtensionAPI): void {
+	registerJittorExtension(pi);
+}

package/extension/src/service-client.ts

@@ -0,0 +1,26 @@
+import { connectJittorClient } from "../../src/client.ts";
+import type { OperationInputs, OperationName, OperationOutputs } from "../../src/service.ts";
+
+let cached = connectJittorClient;
+let client: ReturnType<typeof connectJittorClient> | undefined;
+
+export async function callJittor<Name extends OperationName>(
+	operation: Name,
+	input: OperationInputs[Name],
+): Promise<OperationOutputs[Name]> {
+	for (let attempt = 0; attempt < 2; attempt++) {
+		try {
+			client ??= cached();
+			return await client.call(operation, input);
+		} catch (error) {
+			client = undefined;
+			if (attempt === 1) throw error;
+		}
+	}
+	throw new Error("Jittor client retry exhausted");
+}
+
+export function resetJittorClientForTests(): void {
+	client = undefined;
+	cached = connectJittorClient;
+}

package/extension/src/settings.ts

@@ -0,0 +1,59 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { JITTOR_EXTENSION_SETTINGS_FILENAME, JITTOR_STATE_DIRECTORY } from "../../src/constants.ts";
+
+export interface EnforcementControl {
+	isEnabled(): boolean;
+	setEnabled(enabled: boolean): void;
+	isFooterEnabled(): boolean;
+	setFooterEnabled(enabled: boolean): void;
+}
+
+interface ExtensionSettings {
+	enforcementEnabled: boolean;
+	footerEnabled: boolean;
+}
+
+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 { enforcementEnabled: true, footerEnabled: true };
+		const record = value as Record<string, unknown>;
+		return {
+			enforcementEnabled: record["enforcementEnabled"] !== false,
+			footerEnabled: record["footerEnabled"] !== false,
+		};
+	} catch {
+		return { enforcementEnabled: true, footerEnabled: true };
+	}
+}
+
+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): EnforcementControl {
+	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);
+		},
+	};
+}