@danypops/pi-jittor 0.2.1 → 0.3.1

package/README.md

@@ -1,10 +1,16 @@
 # @danypops/pi-jittor
 
-The Pi extension for Jittor: routing enforcement, the integrated footer, settings TUI, usage/cost graphs, and benchmark panels, all through an authenticated loopback client to the [`@danypops/jittor`](../jittor) daemon. See the [repo root README](../../README.md) for the two-package overview.
+The Pi extension for Jittor: token, cost, context, provider-budget, and model-run observation plus routing, recovery, and model-selection controls, all through an authenticated loopback client to the [`@danypops/jittor`](../jittor) daemon. See the [repo root README](../../README.md) for the two-package overview.
+
+## Architecture
+
+- `extension/src/observability/` collects and presents token, cost, context, provider-budget, and model-run observations.
+- `extension/src/optimization/` contains routing-adjacent recovery and model-selection controls.
+- `extension/src/index.ts` composes Pi lifecycle handlers; daemon transport, settings, and session identity remain thin boundary modules.
 
 ## Behavior
 
-The extension preflights input and every provider turn, applies model/thinking decisions, records response headers and finalized usage through the daemon, and blocks requests when required telemetry is unsafe. It follows Pi's current authenticated model/provider and synchronizes Pi's available models before every decision, so unavailable catalog routes are never selected. Mutable route state is scoped by Pi session, so concurrent sessions cannot replace each other's active provider or footer budget selection. Each session registers an opaque secret with the daemon at `session_start` (best-effort; a registration failure leaves that session unarmored rather than blocked) and presents it on every router-mutating call for the rest of its lifetime; an unregistered `session_id` continues to mutate exactly as before, so this is additive armor, not a breaking change for other callers of the same API. A configured required budget source still fails closed; a provider with no enforceable budget window continues explicitly monitor-only.
+The extension records context composition, response headers, finalized usage, cost, and model-run behavior through the daemon. It also preflights provider turns, applies model/thinking decisions, and blocks requests when required telemetry is unsafe. It follows Pi's current authenticated model/provider and synchronizes Pi's available models before every decision, so unavailable catalog routes are never selected. Mutable route state is scoped by Pi session, so concurrent sessions cannot replace each other's active provider or footer budget selection. Each session registers an opaque secret with the daemon at `session_start` (best-effort; a registration failure leaves that session unarmored rather than blocked) and presents it on every router-mutating call for the rest of its lifetime; an unregistered `session_id` continues to mutate exactly as before, so this is additive armor, not a breaking change for other callers of the same API. A configured required budget source still fails closed; a provider with no enforceable budget window continues explicitly monitor-only.
 
 Its responsive integrated footer groups repository and model identity with cumulative usage, a color-coded context-window bar, and current-provider budget telemetry. Codex shows the active model's bounded quota as a draining remaining-budget bar with reset and freshness information. OpenRouter uses the same drain semantics when its official key telemetry exposes a configured limit and remaining balance; keys without a limit remain honest text-only spend and never receive a fabricated denominator. Anthropic shows the same drain semantics from its most-restrictive-in-effect token bucket, falling back to the request bucket when no token telemetry has been observed yet. During Pi compaction, the context bar drains from its captured fill against a learned median duration estimated from the last few completed compactions (bounded to the most recent 20 samples, requiring at least 3 before trusting it). It never renders a timer. Until enough evidence exists, the bar does not drain; it blinks in place at its captured fill. Run `jittor compaction estimate [--json]` (via the core CLI) to inspect the current estimate and its confidence directly. Unknown and stale telemetry are marked explicitly. Run `/jittor` for the consolidated Settings TUI (its default action), or `/jittor status` for detailed burn pressure, freshness, route state, and confirmed emergency-halt/override controls.
 
@@ -37,7 +43,7 @@ The extension observes finalized Codex assistant errors through Pi's public mess
 
 The graph fetches metrics per distinct provider/model scope (`jittor metrics distinct-scopes`, bounded to 40 scopes, 250 rows each) rather than one flat "most recent rows" query. A flat query lets one heavy, long-running session monopolize the entire row budget with its own most recent activity, silently hiding every other provider from the chart no matter which time frame is selected, since the query would never reach back far enough in time to see anything else. Fetching per scope guarantees every active provider/model gets its own fair share of the query budget instead.
 
-Series are colored with a categorical palette chosen to avoid this UI's own status colors ("success"/"warning"/"error" already mean something specific elsewhere in this panel, so reusing them for arbitrary model identity would make a model's bar segment look like a warning or a failure) and instead reuses the theme's syntax-highlighting roles. Once more series are active than there are hues, a series reuses a hue in bold rather than repeating an indistinguishable color. Multiple models active within the same cumulative time frame are rendered as one bar stacked by color, not separate bars.
+Series are colored with a categorical palette chosen to avoid this UI's own status colors ("success"/"warning"/"error" already mean something specific elsewhere in this panel, so reusing them for arbitrary model identity would make a model's bar segment look like a warning or a failure) and instead reuses the theme's syntax-highlighting roles. A stable provider/model identity hash keeps each model's color fixed across token and cost graphics, period switches, refreshes, ranking changes, and extension restarts. The hash also selects an optional bold variant as a second visual channel, reducing collisions when more model identities exist than terminal hues. Multiple models active within the same cumulative time frame are rendered as one bar stacked by color, not separate bars.
 
 Token-budget thresholds are optional and must be configured by the user; Jittor never infers a token allowance from Codex or another provider's subscription percentage. Configure or clear one period with `/usage budget <hourly|daily|weekly|monthly|quarterly> <positive-tokens|off>`, and inspect all of them with `/usage budget`. A configured budget appears as a horizontal threshold on the cumulative graph with explicit remaining or **OVER BUDGET** state; the cost view does not yet support a budget threshold. These private settings persist in `$XDG_CONFIG_HOME/jittor/extension.json` (or `~/.config/jittor/extension.json`).
 
@@ -51,6 +57,16 @@ The extension observes Papyrus's task-focus lifecycle in real time over a shared
 
 Run `/jittor benchmarks [coding|general] [research|planning|general]` (either order, either or both omitted) for the responsive recommendation panel over the core daemon's benchmark ranking operation (see `@danypops/jittor`'s README for ingestion sources). Because the released Pi extension API does not expose the exact `/scoped-models` set, the current adapter labels candidates `available-models`; the panel says **ADVISORY** and offers no selection action. Automatic route ordering is allowed only for `exact-session` authority and then narrows/reorders routes already present in the supplied candidate set. `/jittor outcome accepted` or `/jittor outcome rejected` attaches explicit outcome evidence to the latest completed local run; runtime completion alone is not treated as quality success.
 
+### Context Hub inspection
+
+Run `/context` for a tree-aware breakdown of the current context window. The TUI supports `/` live search, `f` scope cycling (**all**, **active**, **historical/compacted**), `m` minimum-size thresholds, `g`/`G` top/bottom navigation, and arrow-key scrolling. Search and filters preserve ancestor rows so a matching message block never loses its segment, turn, or branch context.
+
+Conversation entries drill into text, thinking, tool-call arguments, shell commands, and outputs. For conservatively mapped OpenAI-family models, `/context` lazily loads the corresponding `gpt-tokenizer` BPE and marks those individual values `tokenizer-exact-text`, naming the encoding. Unsupported/unknown models and character-only structural inputs remain visibly marked `≈ char/4`; failure to load a tokenizer falls back rather than blocking a request or guessing exactness. Base-prompt aggregates still drill into tool snippets, skills, project context files, guidelines, and custom/appended prompt inputs with structural provenance.
+
+Assistant turns also expose the authoritative **provider-reported aggregate request context** (`input + cacheRead + cacheWrite`). The aggregate stays separate from individual item costs, with an explicit unattributed residual rather than proportional allocation. Images, message envelopes, chat templates, tool schemas, cache-control serialization, and provider rewrites remain provider/model-specific, so exact local text counts are never described as exact requests or billing. Measurements retain only bounded provenance/identity metadata; tokenizer input and prompt/response content are never persisted. See [`../jittor/docs/TOKEN_MEASUREMENT.md`](../jittor/docs/TOKEN_MEASUREMENT.md).
+
+At Pi's `before_provider_request` boundary, Jittor also records a bounded content-free snapshot of final request structure plus compaction-aware/inactive session history. `/context` shows the latest stable-prefix size, first changed segment, lifecycle counts, per-source growth, and truncation state. These keyed-HMAC correlations are structural evidence, never proof of provider cache behavior. See [`../jittor/docs/CONTEXT_SNAPSHOTS.md`](../jittor/docs/CONTEXT_SNAPSHOTS.md).
+
 ### Context pressure
 
 Run `/jittor context` for the in-session summary of Papyrus prompt-injection and Pi compaction telemetry; see `@danypops/jittor`'s README for what is recorded and the equivalent CLI command.

package/docs/USAGE_PRIOR_ART.md

@@ -55,7 +55,7 @@ OpenRouter's authenticated web dashboard is not distributed as reusable terminal
 
 Jittor combines the best applicable patterns:
 
-1. Pure domain projection in `src/domain/usage.ts`.
+1. Pure observation projection in `src/observability/usage.ts`.
 2. Explicit `24h`, `7d`, `30d`, and `90d` windows.
 3. Provider/model-preserving series and input/output/cache totals.
 4. Vertically scaled, colored, stacked Unicode bars with fractional top blocks.

package/extension/src/index.ts

@@ -1,4 +1,4 @@
-import type { ContextSegmentItem } from "@danypops/jittor";
+import type { ContextSegmentItem, ContextSnapshot } from "@danypops/jittor";
 import {
 	applyTaskFocusEvent,
 	CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN,
@@ -6,7 +6,10 @@ import {
 	CONTEXT_HUB_CONTRIBUTION_CHANNEL,
 	CompactionTelemetry,
 	type ContextAssessment,
+	classifyTaskFromTools,
 	FOOTER_COMPACTION_RENDER_INTERVAL_MS,
+	HmacContextFingerprinter,
+	loadOpenAiTextTokenCounter,
 	MAX_DYNAMIC_ROUTES,
 	type MetricObservation,
 	type ModelCandidate,
@@ -21,6 +24,8 @@ import {
 	type StoredMetricObservation,
 	TASK_DOMAINS,
 	TASK_TYPES,
+	type TextTokenCounter,
+	type TokenMeasurementScope,
 	toolLedgerSegment,
 	USAGE_PERIODS,
 	type UsagePeriod,
@@ -28,11 +33,6 @@ import {
 	validateTaskFocusEvent,
 } from "@danypops/jittor";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { showBenchmarkPanel } from "./benchmark-tui.ts";
-import { CodexRecoveryCapability, type CodexRecoveryRuntime, SYSTEM_RECOVERY_RUNTIME } from "./capabilities/codex-recovery.ts";
-import { ContextHubCapability } from "./capabilities/context-hub.ts";
-import { LocalRunTelemetry } from "./capabilities/local-run-telemetry.ts";
-import { ProviderResponseTelemetry } from "./capabilities/provider-response-telemetry.ts";
 import {
 	basePromptSegment,
 	buildBasePromptItems,
@@ -41,20 +41,41 @@ import {
 	messageHistorySegment,
 	type SessionEntryLike,
 	type SessionTreeNodeLike,
-} from "./context-breakdown.ts";
-import { showContextView } from "./context-view.ts";
-import { type CompactionProgress, type IntegratedFooterState, installIntegratedFooter } from "./footer.ts";
+} from "./observability/context-breakdown.ts";
+import { ContextGrowthCapability } from "./observability/context-growth.ts";
+import { ContextHubCapability } from "./observability/context-hub.ts";
+import { showContextView } from "./observability/context-view.ts";
+import { type CompactionProgress, type IntegratedFooterState, installIntegratedFooter } from "./observability/footer.ts";
+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, showJittorPanel } from "./observability/status.ts";
+import { showUsagePanel } from "./observability/usage.ts";
+import { showBenchmarkPanel } from "./optimization/model-selection-panel.ts";
+import { CodexRecoveryCapability, type CodexRecoveryRuntime, SYSTEM_RECOVERY_RUNTIME } from "./optimization/recovery/codex.ts";
 import { callJittor } from "./service-client.ts";
 import { cacheSessionSecret, forgetSessionSecret, sessionSecretField } from "./session-identity.ts";
 import { type CodexRecoveryControl, type EnforcementControl, persistentEnforcementControl, type UsageBudgetControl } from "./settings.ts";
 import { showSettingsPanel } from "./settings-tui.ts";
-import { buildFooterBudget, providerBudgetMetricQuery, showJittorPanel } from "./tui.ts";
-import { showUsagePanel } from "./usage.ts";
 
-export type { CodexRecoveryRuntime } from "./capabilities/codex-recovery.ts";
-export { formatFooterStatus } from "./tui.ts";
+export { formatFooterStatus } from "./observability/status.ts";
+export type { CodexRecoveryRuntime } from "./optimization/recovery/codex.ts";
 
 const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const textTokenCounterPromises = new Map<string, Promise<readonly TextTokenCounter[]>>();
+
+function textTokenCounters(provider: string | undefined, model: string | undefined): Promise<readonly TextTokenCounter[]> {
+	if (!provider || !model) return Promise.resolve([]);
+	const key = `${provider}\u0000${model}`;
+	let counters = textTokenCounterPromises.get(key);
+	if (!counters) {
+		counters = loadOpenAiTextTokenCounter(provider, model)
+			.then((counter) => (counter ? [counter] : []))
+			.catch(() => []);
+		textTokenCounterPromises.set(key, counters);
+	}
+	return counters;
+}
 const RECOVERY_GUIDANCE = "Run /jittor off to disable blocking, or restart the daemon with: systemctl --user restart jittor.service";
 
 export interface JittorExtensionClient {
@@ -286,6 +307,9 @@ function assistantUsageMetrics(
 	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 messageTimestamp = value.timestamp;
+	const metricObservedAt =
+		typeof messageTimestamp === "number" && Number.isSafeInteger(messageTimestamp) && messageTimestamp >= 0 ? messageTimestamp : observedAt;
 	const provider = typeof value.provider === "string" ? value.provider : "unknown";
 	const model = typeof value.model === "string" ? value.model : "unknown";
 	const scope = `${provider}:${model}`;
@@ -296,19 +320,37 @@ function assistantUsageMetrics(
 		...(thinking === null || thinking.length === 0 ? {} : { thinking }),
 	};
 	const metrics: MetricObservation[] = [];
-	for (const [field, metric] of [
-		["input", "input-tokens"],
-		["output", "output-tokens"],
-		["cacheRead", "cache-read-tokens"],
-		["cacheWrite", "cache-write-tokens"],
-	] as const) {
+	for (const [field, metric, tokenScope] of [
+		["input", "input-tokens", "request-input"],
+		["output", "output-tokens", "response-output"],
+		["cacheRead", "cache-read-tokens", "cache-read"],
+		["cacheWrite", "cache-write-tokens", "cache-write"],
+	] as const satisfies ReadonlyArray<readonly [string, string, TokenMeasurementScope]>) {
 		const amount = usage[field];
-		if (typeof amount === "number" && Number.isFinite(amount))
-			metrics.push({ source: "pi", scope, metric, value: amount, unit: "tokens", observedAt, attributes });
+		if (typeof amount === "number" && Number.isSafeInteger(amount) && amount >= 0)
+			metrics.push({
+				source: "pi",
+				scope,
+				metric,
+				value: amount,
+				unit: "tokens",
+				observedAt: metricObservedAt,
+				attributes: {
+					...attributes,
+					tokenMeasurement: {
+						tokens: amount,
+						scope: tokenScope,
+						provenance: "provider-reported",
+						method: "pi-assistant-usage",
+						provider,
+						model,
+					},
+				},
+			});
 	}
 	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 });
+		metrics.push({ source: "pi", scope, metric: "cost", value: cost, unit: "usd", observedAt: metricObservedAt, attributes });
 	return metrics;
 }
 
@@ -318,14 +360,70 @@ export function registerJittorExtension(
 	enforcement: EnforcementControl = persistentEnforcementControl(),
 	codexRecovery: CodexRecoveryControl = recoveryControl(enforcement),
 	recoveryRuntime: CodexRecoveryRuntime = SYSTEM_RECOVERY_RUNTIME,
+	contextGrowth: ContextGrowthCapability = new ContextGrowthCapability(),
 ): void {
 	const footerState: IntegratedFooterState = { providerBudget: null };
 	const usageBudgets = usageBudgetControl(enforcement);
 	let compactionTelemetry = new CompactionTelemetry();
+	let contextGrowthTurn = 0;
 	const localRunTelemetry = new LocalRunTelemetry();
 	const providerResponseTelemetry = new ProviderResponseTelemetry();
 	const codexRecoveryCapability = new CodexRecoveryCapability(pi, codexRecovery, recoveryRuntime);
 	const contextHub = new ContextHubCapability();
+	const contextFingerprintKey = new Uint8Array(32);
+	crypto.getRandomValues(contextFingerprintKey);
+	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;
+			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 {
+			// Snapshot collection is strictly failure-isolated from provider delivery.
+		}
+	});
 	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
 	// only ever visible transiently inside that hook's event, so /context reuses this rather than
@@ -402,8 +500,8 @@ export function registerJittorExtension(
 		if (enforcement.isFooterEnabled()) installIntegratedFooter(ctx, footerState, () => pi.getThinkingLevel());
 		else ctx.ui.setFooter(undefined);
 	};
-	const disable = (ctx: ExtensionContext): void => {
-		enforcement.setEnabled(false);
+	const disable = async (ctx: ExtensionContext): Promise<void> => {
+		await enforcement.setEnabled(false);
 		ctx.ui.setStatus("jittor", undefined);
 		showFooter(ctx);
 		ctx.ui.notify(
@@ -418,12 +516,12 @@ export function registerJittorExtension(
 			await client.call("telemetry.poll", {});
 			const readinessDecision = (await client.call("router.decide", { session_id: ctx.sessionManager.getSessionId() })) as PolicyDecision;
 			if (readinessDecision.action === "halt") throw new Error(readinessDecision.reason);
-			enforcement.setEnabled(true);
+			await enforcement.setEnabled(true);
 			showFooter(ctx);
 			await refreshFooter(client, footerState, ctx.sessionManager.getSessionId());
 			ctx.ui.notify("Jittor enforcement enabled.", "info");
 		} catch (error) {
-			enforcement.setEnabled(false);
+			await 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");
@@ -438,13 +536,13 @@ export function registerJittorExtension(
 				await showSettingsPanel(ctx, enforcement, codexRecovery, usageBudgets, {
 					setEnforcement: async (enabled) => (enabled ? enable(ctx) : disable(ctx)),
 					setFooter: async (enabled) => {
-						enforcement.setFooterEnabled(enabled);
+						await enforcement.setFooterEnabled(enabled);
 						showFooter(ctx);
 						if (enabled) await refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined);
 					},
-					setRecovery: (enabled) => {
+					setRecovery: async (enabled) => {
 						if (!enabled) cancelRecovery(true);
-						codexRecovery.setCodexRecoveryEnabled(enabled);
+						await codexRecovery.setCodexRecoveryEnabled(enabled);
 					},
 				});
 				return;
@@ -499,13 +597,13 @@ export function registerJittorExtension(
 				return;
 			}
 			if (action === "recovery on" || action === "recovery enable") {
-				codexRecovery.setCodexRecoveryEnabled(true);
+				await codexRecovery.setCodexRecoveryEnabled(true);
 				ctx.ui.notify("Jittor Codex recovery enabled; bounded retries begin only after transient failures fully settle.", "info");
 				return;
 			}
 			if (action === "recovery off" || action === "recovery disable") {
 				cancelRecovery(true);
-				codexRecovery.setCodexRecoveryEnabled(false);
+				await codexRecovery.setCodexRecoveryEnabled(false);
 				ctx.ui.notify("Jittor Codex recovery disabled and pending recovery cleared.", "info");
 				return;
 			}
@@ -518,7 +616,7 @@ export function registerJittorExtension(
 				return;
 			}
 			if (action === "off" || action === "disable") {
-				disable(ctx);
+				await disable(ctx);
 				return;
 			}
 			if (action === "on" || action === "enable") {
@@ -526,13 +624,13 @@ export function registerJittorExtension(
 				return;
 			}
 			if (action === "footer off" || action === "footer disable") {
-				enforcement.setFooterEnabled(false);
+				await 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);
+				await enforcement.setFooterEnabled(true);
 				showFooter(ctx);
 				await refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined);
 				ctx.ui.notify("Jittor informational footer enabled; routing enforcement is unchanged.", "info");
@@ -548,6 +646,7 @@ export function registerJittorExtension(
 						`Papyrus injection: ${summary.injection.runs} runs · avg ${average} chars · p95 ${p95} chars · unchanged ${summary.injection.unchangedRate === null ? "unknown" : `${(summary.injection.unchangedRate * 100).toFixed(1)}%`}`,
 						`Mix: rules ${summary.injection.ruleCharacters.toLocaleString()} chars · tasks ${summary.injection.taskCharacters.toLocaleString()} chars · estimated ${summary.injection.estimatedTokens.toLocaleString()} tokens`,
 						`Compactions: ${summary.compaction.completed} completed · ${summary.compaction.aborted} aborted · ${summary.compaction.perRun === null ? "unknown" : summary.compaction.perRun.toFixed(3)} per agent run · ${summary.compaction.perTurn === null ? "unknown" : summary.compaction.perTurn.toFixed(3)} per turn`,
+						`Effectiveness: ${summary.compaction.effectivenessSamples} samples · avg reduction ${summary.compaction.averageReductionRatio === null ? "unknown" : `${(summary.compaction.averageReductionRatio * 100).toFixed(1)}%`} · mechanisms Pi/provider/extension ${summary.compaction.mechanisms["pi-native"]}/${summary.compaction.mechanisms["provider-side"]}/${summary.compaction.mechanisms.extension}`,
 						`Completeness: ${summary.completeness}`,
 					].join("\n"),
 					"info",
@@ -577,7 +676,10 @@ export function registerJittorExtension(
 			// path including everything a real compaction has already summarized away.
 			const activeEntryIds = new Set((ctx.sessionManager.buildContextEntries() as SessionEntryLike[]).map((entry) => entry.id));
 			const branchEntryIds = new Set((ctx.sessionManager.getBranch() as SessionEntryLike[]).map((entry) => entry.id));
-			const messageHistory = buildMessageHistoryTree(tree, activeEntryIds, branchEntryIds);
+			const messageHistory = buildMessageHistoryTree(tree, activeEntryIds, branchEntryIds, {
+				...(ctx.model ? { provider: ctx.model.provider, model: ctx.model.id } : {}),
+				counters: await textTokenCounters(ctx.model?.provider, ctx.model?.id),
+			});
 			const usage = ctx.getContextUsage();
 			const ownSegments = [
 				basePromptSegment(lastObservedBasePromptTokens, lastObservedBasePromptItems),
@@ -589,7 +691,9 @@ export function registerJittorExtension(
 				contextWindow: ctx.model?.contextWindow ?? null,
 				segments: [...ownSegments, ...contextHub.contributedSegments()],
 			});
-			await showContextView(ctx, breakdown);
+			const opaqueSessionId = contextFingerprinter.fingerprint(`session:${ctx.sessionManager.getSessionId()}`);
+			const delta = await client.call("context.delta", { session_id: opaqueSessionId }).catch(() => null);
+			await showContextView(ctx, breakdown, delta);
 		},
 	});
 
@@ -615,7 +719,7 @@ export function registerJittorExtension(
 					return;
 				}
 				if (valueText === "off" || valueText === "clear") {
-					usageBudgets.setUsageTokenBudget(period, undefined);
+					await usageBudgets.setUsageTokenBudget(period, undefined);
 					ctx.ui.notify(`${USAGE_PERIODS.find((candidate) => candidate.id === period)!.label} token budget cleared.`, "info");
 					return;
 				}
@@ -624,7 +728,7 @@ export function registerJittorExtension(
 					ctx.ui.notify("Usage: /usage budget <hourly|daily|weekly|monthly|quarterly> <positive-tokens|off>", "warning");
 					return;
 				}
-				usageBudgets.setUsageTokenBudget(period, tokens);
+				await usageBudgets.setUsageTokenBudget(period, tokens);
 				ctx.ui.notify(
 					`${USAGE_PERIODS.find((candidate) => candidate.id === period)!.label} token budget set to ${tokens.toLocaleString()} tokens.`,
 					"info",
@@ -644,6 +748,8 @@ export function registerJittorExtension(
 		focusedTaskId = null;
 		finishCompactionUi();
 		compactionTelemetry = new CompactionTelemetry();
+		contextGrowthTurn = 0;
+		contextGrowth.reset();
 		localRunTelemetry.reset();
 		contextHub.reset();
 		cancelRecovery(true);
@@ -682,20 +788,40 @@ export function registerJittorExtension(
 	pi.on("session_before_compact", async (event, ctx) => {
 		beginCompactionUi(ctx, event.signal);
 		const usage = ctx.getContextUsage();
+		const preparationTokens = event.preparation?.tokensBefore;
 		const metric = compactionTelemetry.begin({
 			reason: event.reason,
 			willRetry: event.willRetry,
+			mechanism: "pi-native",
+			provider: ctx.model?.provider ?? "unknown",
+			model: ctx.model?.id ?? "unknown",
 			...(usage?.percent === null || usage?.percent === undefined ? {} : { contextPercent: usage.percent }),
-			...(usage?.tokens === null || usage?.tokens === undefined ? {} : { contextTokens: usage.tokens }),
+			...(typeof preparationTokens === "number" && Number.isSafeInteger(preparationTokens) && preparationTokens > 0
+				? { contextTokens: preparationTokens, contextProvenance: "structural-estimate" as const }
+				: usage?.tokens === null || usage?.tokens === undefined
+					? {}
+					: { contextTokens: usage.tokens, contextProvenance: "provider-reported" as const }),
 		});
 		await recordMetrics(client, [metric]).catch(() => undefined);
 	});
 
 	pi.on("session_compact", async (event) => {
 		finishCompactionUi();
-		await recordMetrics(client, [compactionTelemetry.complete({ reason: event.reason, willRetry: event.willRetry })]).catch(
-			() => undefined,
-		);
+		contextGrowth.reset();
+		const summary = event.compactionEntry?.summary;
+		await recordMetrics(client, [
+			compactionTelemetry.complete({
+				reason: event.reason,
+				willRetry: event.willRetry,
+				mechanism: event.fromExtension ? "extension" : "pi-native",
+				...(typeof summary === "string"
+					? {
+							summaryTokens: Math.ceil(summary.length / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN),
+							summaryProvenance: "structural-estimate" as const,
+						}
+					: {}),
+			}),
+		]).catch(() => undefined);
 	});
 
 	pi.on("agent_settled", async (_event, ctx) => {
@@ -771,6 +897,8 @@ export function registerJittorExtension(
 
 	pi.on("tool_execution_end", async (event) => {
 		localRunTelemetry.onToolExecutionEnd(event.toolName, event.isError);
+		const classification = classifyTaskFromTools([event.toolName]);
+		compactionTelemetry.observeToolClass(`${classification.domain}-${classification.type}`, event.isError);
 	});
 
 	pi.on("after_provider_response", async (event, ctx) => {
@@ -783,7 +911,9 @@ export function registerJittorExtension(
 		if (enforcement.isFooterEnabled()) await refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined);
 	});
 
-	pi.on("turn_end", async (event) => {
+	pi.on("turn_end", async (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);
 	});