@danypops/jittor 0.11.0 → 0.12.0

package/extension/src/capabilities/codex-recovery.ts

@@ -1,127 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-	CODEX_RECOVERY_ATTEMPT_WINDOW_MS,
-	CODEX_RECOVERY_BASE_DELAY_MS,
-	CODEX_RECOVERY_JITTER_RATIO,
-	CODEX_RECOVERY_MAX_ATTEMPTS,
-	CODEX_RECOVERY_MAX_DELAY_MS,
-	MILLISECONDS_PER_MINUTE,
-	MILLISECONDS_PER_SECOND,
-} from "../../../src/constants.ts";
-import { CodexRecoveryPolicy, classifyCodexFailure, type CodexFailureKind, type CodexFailureMetadata } from "../../../src/domain/codex-recovery.ts";
-import type { CodexRecoveryControl } from "../settings.ts";
-import { headerValue } from "./http-headers.ts";
-
-export interface CodexRecoveryRuntime {
-	now(): number;
-	random(): number;
-	setTimeout(callback: () => void | Promise<void>, delayMs: number): unknown;
-	clearTimeout(handle: unknown): void;
-}
-
-export const SYSTEM_RECOVERY_RUNTIME: CodexRecoveryRuntime = {
-	now: Date.now,
-	random: Math.random,
-	setTimeout(callback, delayMs) { return setTimeout(() => { void callback(); }, delayMs); },
-	clearTimeout(handle) { clearTimeout(handle as ReturnType<typeof setTimeout>); },
-};
-
-/**
- * Codex's settled-turn hidden-retry recovery, as its own capability: tracks the most recent
- * Codex response (status/retry-after) across the current turn, classifies a finalized failure,
- * and schedules at most one bounded, jittered follow-up once Pi's own turn has genuinely
- * settled. Fully self-contained -- the only external dependencies are Pi's own message-send API,
- * the persisted on/off control, and a runtime the tests can fake (timers, randomness, clock).
- */
-export class CodexRecoveryCapability {
-	private readonly policy: CodexRecoveryPolicy;
-	private lastResponse: CodexFailureMetadata = {};
-	private timer: unknown;
-	private cooldown: { until: number; attempt: number; failureKind: CodexFailureKind } | undefined;
-
-	constructor(
-		private readonly pi: ExtensionAPI,
-		private readonly control: CodexRecoveryControl,
-		private readonly runtime: CodexRecoveryRuntime,
-	) {
-		this.policy = new CodexRecoveryPolicy({
-			baseDelayMs: CODEX_RECOVERY_BASE_DELAY_MS,
-			maxDelayMs: CODEX_RECOVERY_MAX_DELAY_MS,
-			maxAttempts: CODEX_RECOVERY_MAX_ATTEMPTS,
-			attemptWindowMs: CODEX_RECOVERY_ATTEMPT_WINDOW_MS,
-			jitterRatio: CODEX_RECOVERY_JITTER_RATIO,
-		}, runtime.random);
-	}
-
-	/** Clears the tracked response at the start of every new turn, before any Codex response for it has arrived. */
-	resetTurn(): void {
-		this.lastResponse = {};
-	}
-
-	notifyResponse(status: number, headers: Record<string, string>): void {
-		this.lastResponse = { status, ...(headerValue(headers, "retry-after") ? { retryAfter: headerValue(headers, "retry-after") } : {}) };
-	}
-
-	notifyMessageEnd(stopReason: string, errorMessage: string | undefined): void {
-		if (stopReason === "error") {
-			const failure = classifyCodexFailure(errorMessage, this.lastResponse);
-			if (this.control.isCodexRecoveryEnabled() && failure.transient) this.policy.observeFailure(failure, this.runtime.now());
-			else this.cancel(true);
-		} else if (stopReason !== "aborted") {
-			this.cancel(true);
-		}
-		this.lastResponse = {};
-	}
-
-	cancel(resetPolicy: boolean): void {
-		if (this.timer !== undefined) this.runtime.clearTimeout(this.timer);
-		this.timer = undefined;
-		this.cooldown = undefined;
-		if (resetPolicy) this.policy.cancel();
-	}
-
-	statusText(): string {
-		const now = this.runtime.now();
-		const state = this.policy.state(now);
-		const enabled = this.control.isCodexRecoveryEnabled();
-		const attempt = this.cooldown?.attempt ?? (state.pending ? state.attempts + 1 : state.attempts);
-		const phase = this.cooldown
-			? `cooldown ${Math.ceil(Math.max(0, this.cooldown.until - now) / MILLISECONDS_PER_SECOND)}s`
-			: state.pending ? "pending"
-				: state.attempts >= CODEX_RECOVERY_MAX_ATTEMPTS ? "exhausted"
-					: state.attempts > 0 ? "waiting" : "idle";
-		const failureKind = this.cooldown?.failureKind ?? state.lastFailureKind;
-		return [
-			`Codex recovery: ${enabled ? "on" : "off"}`,
-			phase,
-			`attempt ${attempt}/${CODEX_RECOVERY_MAX_ATTEMPTS}`,
-			`window ${CODEX_RECOVERY_ATTEMPT_WINDOW_MS / MILLISECONDS_PER_MINUTE}m`,
-			...(failureKind ? [failureKind] : []),
-		].join(" · ");
-	}
-
-	scheduleIfIdle(ctx: ExtensionContext): void {
-		if (!this.control.isCodexRecoveryEnabled() || this.timer !== undefined || !ctx.isIdle() || ctx.hasPendingMessages()) return;
-		const plan = this.policy.plan(this.runtime.now());
-		if (plan.action === "exhausted") {
-			this.policy.abandonFailure();
-			if (ctx.hasUI) ctx.ui.notify(`Jittor Codex recovery stopped: ${plan.reason}.`, "warning");
-			return;
-		}
-		if (plan.action !== "schedule") return;
-		this.cooldown = { until: this.runtime.now() + plan.delayMs, attempt: plan.attempt, failureKind: plan.failureKind };
-		this.timer = this.runtime.setTimeout(async () => {
-			this.timer = undefined;
-			this.cooldown = undefined;
-			if (!ctx.isIdle() || ctx.hasPendingMessages()) return;
-			const attempt = this.policy.recordAttempt(this.runtime.now());
-			if (!attempt) return;
-			this.pi.sendMessage({
-				customType: "jittor-codex-recovery",
-				content: `Retry the previous Codex request after a transient ${attempt.failureKind} failure. Automatic recovery attempt ${attempt.attempt} of ${CODEX_RECOVERY_MAX_ATTEMPTS}.`,
-				display: false,
-				details: { attempt: attempt.attempt, failureKind: attempt.failureKind },
-			}, { triggerTurn: true, deliverAs: "followUp" });
-		}, plan.delayMs);
-	}
-}

package/extension/src/capabilities/http-headers.ts

@@ -1,5 +0,0 @@
-/** Case-insensitive header lookup -- Pi's provider-response event headers are a plain Record, not a Headers instance. */
-export function headerValue(headers: Record<string, string>, name: string): string | undefined {
-	const expected = name.toLowerCase();
-	return Object.entries(headers).find(([key]) => key.toLowerCase() === expected)?.[1];
-}

package/extension/src/capabilities/local-run-telemetry.ts

@@ -1,104 +0,0 @@
-import { classifyTaskFromTools, modelRunMetrics, type ModelRunObservation } from "../../../src/domain/model-observation.ts";
-import type { MetricObservation } from "../../../src/domain/metric.ts";
-
-export interface ActiveLocalModelRun {
-	runId: string;
-	startedAt: number;
-	firstTokenAt: number | null;
-	providerResponses: number;
-	toolNames: string[];
-	toolCalls: number;
-	toolFailures: number;
-}
-
-/**
- * Content-free local model observations derived only from Pi's public lifecycle: TTFT, wall
- * latency, tool-loop counts and failures, and a bounded tool-name list used only to derive
- * domain/type classification -- never prompts, responses, tool arguments/results, or project
- * paths. Owns the one in-flight run plus the most recently completed one (for `/jittor outcome`).
- */
-export class LocalRunTelemetry {
-	private active: ActiveLocalModelRun | undefined;
-	private lastCompleted: ModelRunObservation | undefined;
-	private sequence = 0;
-
-	beginTurn(timestamp: number): void {
-		this.active = {
-			runId: `local-${timestamp}-${++this.sequence}`,
-			startedAt: timestamp,
-			firstTokenAt: null,
-			providerResponses: 0,
-			toolNames: [],
-			toolCalls: 0,
-			toolFailures: 0,
-		};
-	}
-
-	discardTurn(): void {
-		this.active = undefined;
-	}
-
-	onMessageUpdate(assistantMessageEventType: string): void {
-		if (!this.active || this.active.firstTokenAt !== null) return;
-		if (["text_delta", "thinking_delta", "toolcall_delta"].includes(assistantMessageEventType)) this.active.firstTokenAt = Date.now();
-	}
-
-	onToolExecutionEnd(toolName: string, isError: boolean): void {
-		if (!this.active) return;
-		this.active.toolCalls += 1;
-		if (isError) this.active.toolFailures += 1;
-		if (this.active.toolNames.length < 100) this.active.toolNames.push(toolName);
-	}
-
-	onProviderResponse(): void {
-		if (this.active) this.active.providerResponses += 1;
-	}
-
-	/** Finalizes the active run against a completed assistant turn_end message, returning metrics to record (empty if the message shape doesn't match a completed assistant turn). */
-	completeTurn(message: unknown, thinkingLevel: string): MetricObservation[] {
-		const active = this.active;
-		this.active = undefined;
-		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);
-		this.lastCompleted = {
-			runId: active.runId,
-			provider: value["provider"],
-			model: value["model"],
-			thinking: thinkingLevel,
-			...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",
-		};
-		return modelRunMetrics(this.lastCompleted);
-	}
-
-	/** Builds the single outcome-accepted/outcome-accepted=0 metric for the most recently completed run, or null if none exists yet. */
-	explicitOutcomeMetric(explicitOutcome: "accepted" | "rejected"): MetricObservation | null {
-		if (!this.lastCompleted) return null;
-		return modelRunMetrics({ ...this.lastCompleted, explicitOutcome }).find((metric) => metric.metric === "outcome-accepted") ?? null;
-	}
-
-	reset(): void {
-		this.active = undefined;
-		this.lastCompleted = undefined;
-	}
-}

package/extension/src/capabilities/provider-response-telemetry.ts

@@ -1,96 +0,0 @@
-import type { MetricObservation } from "../../../src/domain/metric.ts";
-import { hasAnthropicRateLimitHeaders, parseAnthropicRateLimitHeaders } from "../../../src/providers/anthropic-contracts.ts";
-import { parseCodexRateLimitHeaders } from "../../../src/providers/codex.ts";
-import { classifyGoogleVertexFailure, googleVertexFailureMetrics, type GoogleVertexFailureMetadata } from "../../../src/providers/google-vertex-contracts.ts";
-import { headerValue } from "./http-headers.ts";
-
-export interface ProviderTelemetryClient {
-	call(operation: string, input: unknown): Promise<any>;
-}
-
-async function recordMetrics(client: ProviderTelemetryClient, metrics: MetricObservation[]): Promise<void> {
-	if (metrics.length === 0) return;
-	await client.call("metrics.record_batch", { observations: metrics });
-}
-
-/**
- * Bounded telemetry derived directly from provider HTTP responses and finalized messages, for
- * every provider except Codex (whose response tracking is settled-turn-recovery's own concern --
- * see codex-recovery.ts). Anthropic and anthropic-vertex official rate-limit headers become
- * budget metrics; Google Vertex and anthropic-vertex failures become bounded, content-free
- * failure-count metrics classified from GCP's own `google.rpc.Status` shape. anthropic-vertex is
- * tracked distinctly from both google-vertex (different code path, different quota pool) and
- * direct anthropic (different transport), never conflated with either.
- */
-export class ProviderResponseTelemetry {
-	private lastGoogleVertexResponse: GoogleVertexFailureMetadata = {};
-	private lastAnthropicVertexResponse: GoogleVertexFailureMetadata = {};
-
-	resetTurn(): void {
-		this.lastGoogleVertexResponse = {};
-		this.lastAnthropicVertexResponse = {};
-	}
-
-	async handleProviderResponse(
-		client: ProviderTelemetryClient,
-		provider: string | undefined,
-		status: number,
-		headers: Record<string, string>,
-		notifySchemaDrift: (message: string) => void,
-	): Promise<void> {
-		if (provider === "anthropic") {
-			const parsedHeaders = new Headers(headers);
-			if (hasAnthropicRateLimitHeaders(parsedHeaders)) {
-				try {
-					await recordMetrics(client, parseAnthropicRateLimitHeaders(parsedHeaders, Date.now()).metrics);
-				} catch {
-					notifySchemaDrift("Anthropic telemetry schema drift");
-				}
-			}
-		}
-		if (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 module.
-			const parsedHeaders = new Headers(headers);
-			if (hasAnthropicRateLimitHeaders(parsedHeaders)) {
-				try {
-					await recordMetrics(client, parseAnthropicRateLimitHeaders(parsedHeaders, Date.now(), "anthropic-vertex").metrics);
-				} catch {
-					notifySchemaDrift("Anthropic-on-Vertex telemetry schema drift");
-				}
-			}
-			// Well-evidenced regardless of headers: GCP's own quota system fronts this transport, so the
-			// same failure classification as google-vertex applies below.
-			this.lastAnthropicVertexResponse = { status, ...(headerValue(headers, "retry-after") ? { retryAfter: headerValue(headers, "retry-after") } : {}) };
-		}
-		if (provider === "google-vertex") {
-			this.lastGoogleVertexResponse = { status, ...(headerValue(headers, "retry-after") ? { retryAfter: headerValue(headers, "retry-after") } : {}) };
-		}
-		if (Object.keys(headers).some((name) => name.toLowerCase().startsWith("x-codex-"))) {
-			try {
-				const updates = parseCodexRateLimitHeaders(new Headers(headers), Date.now());
-				await recordMetrics(client, updates.flatMap((update) => update.metrics));
-			} catch {
-				notifySchemaDrift("Codex telemetry schema drift");
-			}
-		}
-	}
-
-	async handleMessageEnd(client: ProviderTelemetryClient, provider: string | undefined, stopReason: string | undefined, errorMessage: string | undefined): Promise<void> {
-		if (provider === "google-vertex") {
-			if (stopReason === "error") {
-				const failure = classifyGoogleVertexFailure(errorMessage, this.lastGoogleVertexResponse);
-				await recordMetrics(client, googleVertexFailureMetrics(failure, Date.now())).catch(() => undefined);
-			}
-			this.lastGoogleVertexResponse = {};
-		}
-		if (provider === "anthropic-vertex") {
-			if (stopReason === "error") {
-				const failure = classifyGoogleVertexFailure(errorMessage, this.lastAnthropicVertexResponse);
-				await recordMetrics(client, googleVertexFailureMetrics(failure, Date.now(), "anthropic-vertex")).catch(() => undefined);
-			}
-			this.lastAnthropicVertexResponse = {};
-		}
-	}
-}

package/extension/src/footer.ts

@@ -1,323 +0,0 @@
-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_COMPACTION_BLINK_HALF_PERIOD_MS,
-	FOOTER_CONTEXT_WARNING_FRACTION,
-	FOOTER_WIDE_TERMINAL_WIDTH,
-	MILLISECONDS_PER_DAY,
-	MILLISECONDS_PER_HOUR,
-	MILLISECONDS_PER_MINUTE,
-	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 bounded quota is explicitly remaining; unbounded values never receive a fabricated bar. */
-export type ProviderBudget = {
-	kind: "bounded";
-	label: string;
-	remainingFraction: number;
-	observedAt?: number;
-	resetsAt?: number;
-	resetText?: string;
-} | {
-	kind: "unbounded";
-	label: string;
-	valueText: string;
-	observedAt?: number;
-};
-
-export interface CompactionProgress {
-	startedAt: number;
-	initialFraction: number;
-	/** Learned median duration from jittor-cli's `compaction.estimate`; absent/null means cold-start. */
-	estimatedMs?: number | null;
-	confidence?: "cold-start" | "learned";
-}
-
-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;
-	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 = input + cacheRead + cacheWrite;
-	return { input, output, cacheRead, cacheWrite, cost, ...(prompt > 0 ? { cacheHit: cacheRead / prompt * 100 } : {}) };
-}
-
-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 compactionFraction(progress: CompactionProgress, now: number): number {
-	const initial = Math.min(1, Math.max(0, progress.initialFraction));
-	if (progress.confidence !== "learned" || typeof progress.estimatedMs !== "number" || progress.estimatedMs <= 0) return initial;
-	const elapsedFraction = Math.max(0, Math.min(1, (now - progress.startedAt) / progress.estimatedMs));
-	return initial * (1 - elapsedFraction);
-}
-
-export function compactionBlinkOn(startedAt: number, now: number, halfPeriodMs = FOOTER_COMPACTION_BLINK_HALF_PERIOD_MS): boolean {
-	const elapsed = Math.max(0, now - startedAt);
-	return Math.floor(elapsed / halfPeriodMs) % 2 === 0;
-}
-
-function compactionBarGlyph(progress: CompactionProgress, theme: FooterTheme, width: number, now: number): string {
-	if (!compactionBlinkOn(progress.startedAt, now)) return theme.fg("dim", "░".repeat(width));
-	return theme.fg("accent", progressBar(compactionFraction(progress, now), width));
-}
-
-function contextSegment(
-	context: FooterContext,
-	theme: FooterTheme,
-	width: number,
-	compact: boolean,
-	now: number,
-	compaction?: CompactionProgress,
-): string {
-	const w = barWidth(width);
-	if (compaction) return `ctx ${compactionBarGlyph(compaction, theme, w, now)}`;
-	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, w));
-	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 minimalContextSegment(
-	context: FooterContext,
-	theme: FooterTheme,
-	width: number,
-	now: number,
-	compaction?: CompactionProgress,
-): string {
-	const w = barWidth(width);
-	if (compaction) {
-		return `ctx ${compactionBarGlyph(compaction, theme, w, now)}`;
-	}
-	const percent = context.getContextUsage()?.percent;
-	const fraction = percent === null || percent === undefined ? null : percent / 100;
-	return `ctx ${theme.fg(fillColor(fraction), progressBar(fraction, w))}`;
-}
-
-function resetLabel(resetsAt: number | undefined, now: number): string | undefined {
-	if (resetsAt === undefined) return undefined;
-	const remaining = resetsAt - now;
-	if (remaining <= 0) return "reset due";
-	if (remaining >= MILLISECONDS_PER_DAY) return `resets in ${Math.floor(remaining / MILLISECONDS_PER_DAY)}d`;
-	if (remaining >= MILLISECONDS_PER_HOUR) return `resets in ${Math.floor(remaining / MILLISECONDS_PER_HOUR)}h`;
-	return `resets in ${Math.max(1, Math.ceil(remaining / MILLISECONDS_PER_MINUTE))}m`;
-}
-
-/**
- * `undefined` means no budget signal is possible for this provider at all (see buildFooterBudget);
- * the segment is omitted entirely rather than showing a placeholder that could never resolve.
- * `null` means not known yet but might resolve, which still earns the `?` placeholder.
- */
-function budgetSegment(budget: ProviderBudget | null | undefined, theme: FooterTheme, width: number, compact: boolean, now: number): string | undefined {
-	if (budget === undefined) return undefined;
-	const w = barWidth(width);
-	if (!budget) return `budget ${theme.fg("dim", progressBar(null, w))} ?`;
-	const stale = budget.observedAt !== undefined && now - budget.observedAt > TELEMETRY_STALE_AFTER_MS;
-	const staleText = stale ? ` ${theme.fg("warning", "stale")}` : "";
-	if (budget.kind === "unbounded") return `${budget.label} ${budget.valueText}${staleText}`;
-	const remaining = Math.min(1, Math.max(0, budget.remainingFraction));
-	const bar = theme.fg(fillColor(1 - remaining), progressBar(remaining, w));
-	const value = `${(compact ? Math.round(remaining * 100) : (remaining * 100).toFixed(1))}% left`;
-	const reset = compact ? undefined : resetLabel(budget.resetsAt, now) ?? budget.resetText;
-	return `${budget.label} ${bar} ${value}${reset ? ` · ${reset}` : ""}${staleText}`;
-}
-
-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 repositorySegment(context: FooterContext, footerData: FooterData, theme: FooterTheme): 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}`;
-	return theme.fg("dim", cwd);
-}
-
-function modelSegments(context: FooterContext, footerData: FooterData, theme: FooterTheme, thinkingLevel: string): { full: string; compact: string } {
-	const model = context.model;
-	const modelName = theme.bold(model?.id ?? "no-model");
-	const provider = model && footerData.getAvailableProviderCount() > 1 ? `(${model.provider}) ` : "";
-	const thinking = model?.reasoning ? ` · ${thinkingLevel === "off" ? "thinking off" : thinkingLevel}` : "";
-	return { full: `${provider}${modelName}${thinking}`, compact: modelName };
-}
-
-function compactUsageSegment(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)}`);
-	return parts.join(" ");
-}
-
-function joinSegments(segments: Array<string | undefined>): string {
-	return segments.filter((segment): segment is string => Boolean(segment)).join(" · ");
-}
-
-export function renderFooterLines(
-	context: FooterContext,
-	footerData: FooterData,
-	theme: FooterTheme,
-	providerBudget: ProviderBudget | null | undefined,
-	thinkingLevel: string,
-	width: number,
-	now = Date.now(),
-	compaction?: CompactionProgress,
-): string[] {
-	const safeWidth = Math.max(1, width);
-	const repository = repositorySegment(context, footerData, theme);
-	const model = modelSegments(context, footerData, theme, thinkingLevel);
-	const usage = usageSegment(context);
-	const compactUsage = compactUsageSegment(context);
-	const fullContext = contextSegment(context, theme, safeWidth, false, now, compaction);
-	const compactContext = contextSegment(context, theme, safeWidth, true, now, compaction);
-	const minimalContext = minimalContextSegment(context, theme, safeWidth, now, compaction);
-	const fullBudget = budgetSegment(providerBudget, theme, safeWidth, false, now);
-	const compactBudget = budgetSegment(providerBudget, theme, safeWidth, true, now);
-	const statuses = [...footerData.getExtensionStatuses().entries()]
-		.filter(([key]) => key !== "jittor")
-		.sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
-		.map(([, text]) => sanitize(text))
-		.join(" ");
-
-	const candidates = [
-		joinSegments([repository, model.full, usage, fullContext, fullBudget, statuses]),
-		joinSegments([repository, model.full, usage, fullContext, fullBudget]),
-		joinSegments([model.full, usage, compactContext, compactBudget, statuses]),
-		joinSegments([model.full, usage, compactContext, compactBudget]),
-		joinSegments([model.full, compactUsage, compactContext, compactBudget]),
-		joinSegments([model.compact, compactUsage, compactContext, compactBudget]),
-		joinSegments([model.compact, compactContext, compactBudget]),
-		joinSegments([model.compact, minimalContext, compactBudget]),
-	];
-	const line = candidates.find((candidate) => visibleWidth(candidate) <= safeWidth) ?? candidates.at(-1) ?? "";
-	return [truncateToWidth(line, safeWidth, "")];
-}
-
-export interface IntegratedFooterState {
-	providerBudget: ProviderBudget | null | undefined;
-	compaction?: CompactionProgress;
-	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, Date.now(), state.compaction);
-			},
-			dispose() {
-				unsubscribe?.();
-				state.requestRender = undefined;
-				tui.requestRender();
-			},
-		};
-	});
-}