@diegopetrucci/pi-extensions 0.1.72 → 0.1.73

package/extensions/context-cap/index.ts

@@ -2,117 +2,285 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import type { Model, Api } from "@earendil-works/pi-ai";
 
 const DEFAULT_MAX_CONTEXT_WINDOW = 200_000;
+const DEFAULT_RESERVE_TOKENS = 16_384;
+const PROCESS_STATE_KEY = Symbol.for("pi-extensions.context-cap.model-holds.v1");
 type AnyModel = Model<Api> | Model<any>;
 
-const originalContextWindows = new WeakMap<AnyModel, number>();
-const touchedModels = new Set<AnyModel>();
+type ModelWindow = number | undefined;
+type HolderToken = object;
+type ModelHold = {
+	original: number;
+	cap: number;
+	holders: Set<HolderToken>;
+};
+
+type GlobalSymbolTable = typeof globalThis & { [key: symbol]: unknown };
+
+// Pi can load the same extension source once per session. Keep coordination in
+// a Symbol.for slot so separately loaded module copies share one WeakMap, while
+// the WeakMap itself does not retain model objects after every holder releases.
+function getProcessModelHolds(): WeakMap<AnyModel, ModelHold> {
+	const globalObject = globalThis as GlobalSymbolTable;
+	const existing = globalObject[PROCESS_STATE_KEY];
+	if (existing instanceof WeakMap) return existing as WeakMap<AnyModel, ModelHold>;
 
+	const created = new WeakMap<AnyModel, ModelHold>();
+	globalObject[PROCESS_STATE_KEY] = created;
+	return created;
+}
+
+const processModelHolds = getProcessModelHolds();
+
+type CapReason = "virtual" | "unknown" | "reserve" | "modelOverride" | "settingsUnavailable";
 type ApplyResult = {
 	changed: boolean;
 	key: string;
-	original: number;
-	effective: number;
+	original?: number;
+	effective?: number;
+	reserveTokens?: number;
+	holders?: number;
+	reason?: CapReason;
 };
+type CapGuard =
+	| { allowed: true }
+	| { allowed: false; reason: Exclude<CapReason, "virtual" | "unknown">; reserveTokens?: number };
 
 function modelKey(model: AnyModel): string {
 	return `${model.provider}/${model.id}`;
 }
 
-function getOriginalContextWindow(model: AnyModel): number {
-	const existing = originalContextWindows.get(model);
-	if (typeof existing === "number") return existing;
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
-	originalContextWindows.set(model, model.contextWindow);
-	touchedModels.add(model);
-	return model.contextWindow;
+function isKnownContextWindow(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
 }
 
-function getEffectiveContextWindow(model: AnyModel): number {
-	return Math.min(getOriginalContextWindow(model), DEFAULT_MAX_CONTEXT_WINDOW);
+function isNonNegativeSafeInteger(value: unknown): value is number {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
 
-function applyContextCap(model: AnyModel | undefined): ApplyResult | undefined {
-	if (!model) return undefined;
+function isVirtualModel(model: AnyModel): boolean {
+	return (model as AnyModel & { api?: string }).api === "pi-virtual";
+}
 
-	const key = modelKey(model);
-	const original = getOriginalContextWindow(model);
-	const effective = Math.min(original, DEFAULT_MAX_CONTEXT_WINDOW);
-	const changed = model.contextWindow !== effective;
-	model.contextWindow = effective;
+function readCapGuard(pi: ExtensionAPI, model: AnyModel): CapGuard {
+	const getSettings = (pi as ExtensionAPI & { getSettings?: () => unknown }).getSettings;
+	// Pi before getSettings existed has no way to expose the effective
+	// compaction settings. Preserve the older-host cap behavior there.
+	if (typeof getSettings !== "function") return { allowed: true };
+
+	try {
+		const settings = getSettings.call(pi);
+		if (!isRecord(settings)) return { allowed: false, reason: "settingsUnavailable" };
+		const compactionValue = settings.compaction;
+		if (compactionValue === undefined) return { allowed: true };
+		if (!isRecord(compactionValue)) return { allowed: false, reason: "settingsUnavailable" };
+
+		const overridesValue = compactionValue.modelOverrides;
+		if (overridesValue !== undefined && !isRecord(overridesValue)) {
+			return { allowed: false, reason: "settingsUnavailable" };
+		}
+		if (overridesValue && Object.prototype.hasOwnProperty.call(overridesValue, modelKey(model))) {
+			return { allowed: false, reason: "modelOverride" };
+		}
 
-	return { changed, key, original, effective };
+		const ordinaryReserve = compactionValue.reserveTokens;
+		if (ordinaryReserve !== undefined && !isNonNegativeSafeInteger(ordinaryReserve)) {
+			return { allowed: false, reason: "settingsUnavailable" };
+		}
+		const reserveTokens = ordinaryReserve ?? DEFAULT_RESERVE_TOKENS;
+		return reserveTokens >= DEFAULT_MAX_CONTEXT_WINDOW
+			? { allowed: false, reason: "reserve", reserveTokens }
+			: { allowed: true };
+	} catch {
+		// A host settings implementation that cannot return a coherent snapshot
+		// must not be guessed at: leave the model unmodified and report why.
+		return { allowed: false, reason: "settingsUnavailable" };
+	}
+}
+
+function originalContextWindow(model: AnyModel): ModelWindow {
+	const hold = processModelHolds.get(model);
+	return hold?.original ?? (isKnownContextWindow(model.contextWindow) ? model.contextWindow : undefined);
 }
 
-function restoreContextWindow(model: AnyModel | undefined): boolean {
-	if (!model) return false;
+function releaseContextCap(model: AnyModel | undefined, holderToken: HolderToken, heldModels: Set<AnyModel>): boolean {
+	if (!model || !heldModels.delete(model)) return false;
 
-	const original = originalContextWindows.get(model);
-	if (typeof original !== "number" || model.contextWindow === original) return false;
+	const hold = processModelHolds.get(model);
+	if (!hold) return false;
+	hold.holders.delete(holderToken);
+	if (hold.holders.size > 0) return false;
 
-	model.contextWindow = original;
+	processModelHolds.delete(model);
+	// Do not overwrite a value changed by the host or another extension while
+	// this holder was active. Equality is the only safe signal available here.
+	if (model.contextWindow !== hold.cap) return false;
+	model.contextWindow = hold.original;
 	return true;
 }
 
-function forEachRegistryModel(ctx: ExtensionContext, callback: (model: AnyModel) => void): void {
-	try {
-		for (const model of ctx.modelRegistry.getAll()) {
-			callback(model);
-		}
-	} catch {
-		// Best effort only. The active ctx.model is handled separately by callers.
+function applyContextCap(
+	pi: ExtensionAPI,
+	model: AnyModel | undefined,
+	holderToken: HolderToken,
+	heldModels: Set<AnyModel>,
+): ApplyResult | undefined {
+	if (!model) return undefined;
+
+	const key = modelKey(model);
+	if (isVirtualModel(model)) {
+		return { changed: false, key, reason: "virtual" };
 	}
-}
 
-function applyContextCapToSession(ctx: ExtensionContext): number {
-	let changed = 0;
+	const hold = processModelHolds.get(model);
+	if (!isKnownContextWindow(model.contextWindow) && !hold) {
+		return { changed: false, key, reason: "unknown" };
+	}
 
-	forEachRegistryModel(ctx, (model) => {
-		if (applyContextCap(model)?.changed) changed++;
-	});
+	const original = hold?.original ?? model.contextWindow;
+	if (!isKnownContextWindow(original)) {
+		return { changed: false, key, reason: "unknown" };
+	}
+	const effective = hold?.cap ?? Math.min(original, DEFAULT_MAX_CONTEXT_WINDOW);
+	if (!hold && original <= DEFAULT_MAX_CONTEXT_WINDOW) {
+		return { changed: false, key, original, effective };
+	}
 
-	if (applyContextCap(ctx.model)?.changed) changed++;
-	return changed;
-}
+	const guard = readCapGuard(pi, model);
+	if (!guard.allowed) {
+		if (heldModels.has(model)) releaseContextCap(model, holderToken, heldModels);
+		return {
+			changed: false,
+			key,
+			original,
+			effective,
+			reserveTokens: guard.reserveTokens,
+			reason: guard.reason,
+			holders: hold?.holders.size,
+		};
+	}
 
-function restoreContextCapForSession(ctx: ExtensionContext): number {
-	let changed = 0;
+	const activeHold = hold ?? { original, cap: effective, holders: new Set<HolderToken>() };
+	if (!hold) processModelHolds.set(model, activeHold);
+	const alreadyHeld = heldModels.has(model);
+	if (!alreadyHeld) {
+		activeHold.holders.add(holderToken);
+		heldModels.add(model);
+	}
 
-	forEachRegistryModel(ctx, (model) => {
-		if (restoreContextWindow(model)) changed++;
-	});
+	// Only the first holder writes the cap. If the host changed a shared model
+	// after that, later holders join the reference count without clobbering it.
+	const changed = !hold && model.contextWindow !== activeHold.cap;
+	if (changed) model.contextWindow = activeHold.cap;
+
+	return {
+		changed,
+		key,
+		original: activeHold.original,
+		effective: activeHold.cap,
+		holders: activeHold.holders.size,
+	};
+}
 
-	if (restoreContextWindow(ctx.model)) changed++;
+function restoreTouchedModels(holderToken: HolderToken, heldModels: Set<AnyModel>): number {
+	let changed = 0;
+	for (const model of [...heldModels]) {
+		if (releaseContextCap(model, holderToken, heldModels)) changed++;
+	}
 	return changed;
 }
 
+function applyContextCapToSession(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	holderToken: HolderToken,
+	heldModels: Set<AnyModel>,
+): number {
+	return applyContextCap(pi, ctx.model, holderToken, heldModels)?.changed ? 1 : 0;
+}
+
 function formatTokens(tokens: number): string {
 	return tokens >= 1000 ? `${Math.round(tokens / 1000)}k` : String(tokens);
 }
 
+function formatWindow(window: ModelWindow): string {
+	return isKnownContextWindow(window) ? formatTokens(window) : "unknown";
+}
+
+function unavailableReason(result: ApplyResult | undefined): string | undefined {
+	if (result?.reason === "virtual") {
+		return "virtual selection; routed physical limit is unavailable to this extension";
+	}
+	if (result?.reason === "unknown") {
+		return "physical model has no compatible context-window limit";
+	}
+	if (result?.reason === "reserve") {
+		return `compaction reserveTokens (${formatTokens(result.reserveTokens ?? DEFAULT_MAX_CONTEXT_WINDOW)}) is at least 200k; the auto-compaction threshold would be zero or negative`;
+	}
+	if (result?.reason === "modelOverride") {
+		return `compaction.modelOverrides[\"${result.key}\"] is configured; leaving the model window unchanged`;
+	}
+	if (result?.reason === "settingsUnavailable") {
+		return "compaction settings could not be resolved safely";
+	}
+	return undefined;
+}
+
+function holdStatus(model: AnyModel, heldModels: Set<AnyModel>): string {
+	const hold = processModelHolds.get(model);
+	if (!hold) return " No process-wide context-cap hold is active.";
+
+	const otherHolders = Math.max(hold.holders.size - (heldModels.has(model) ? 1 : 0), 0);
+	const holderWord = otherHolders === 1 ? "holder" : "holders";
+	const holderVerb = otherHolders === 1 ? "holds" : "hold";
+	return ` Process-wide cap holders: ${hold.holders.size}; ${otherHolders} other ${holderWord} still ${holderVerb} the cap.`;
+}
+
 export default function contextCapExtension(pi: ExtensionAPI) {
 	let enabled = true;
+	const holderToken: HolderToken = {};
+	const heldModels = new Set<AnyModel>();
 
 	pi.on("session_start", async (_event, ctx) => {
-		if (enabled) applyContextCapToSession(ctx);
+		// A reload/session replacement can reuse model objects. Release only this
+		// extension instance's holds before capturing the new active model.
+		restoreTouchedModels(holderToken, heldModels);
+		if (enabled) applyContextCapToSession(pi, ctx, holderToken, heldModels);
 	});
 
 	pi.on("model_select", async (event, ctx) => {
+		// Selection changes are the narrowest reliable boundary available to an
+		// extension. Release this instance's previous handle before applying the
+		// new physical model, and never infer a virtual route from its metadata.
+		releaseContextCap(event.previousModel, holderToken, heldModels);
 		if (!enabled) return;
 
-		const result = applyContextCap(event.model);
+		const result = applyContextCap(pi, event.model, holderToken, heldModels);
 		if (!result || !ctx.hasUI) return;
 
+		const unavailable = unavailableReason(result);
 		ctx.ui.setStatus(
 			"context-cap",
-			result.original > DEFAULT_MAX_CONTEXT_WINDOW
-				? `ctx cap ${formatTokens(result.effective)}/${formatTokens(result.original)}`
-				: undefined,
+			unavailable
+				? "ctx cap unavailable"
+				: result.original !== undefined && result.original > DEFAULT_MAX_CONTEXT_WINDOW
+					? `ctx cap ${formatTokens(result.effective ?? result.original)}/${formatTokens(result.original)}`
+					: undefined,
 		);
 	});
 
-	pi.on("session_shutdown", async (_event, ctx) => {
-		restoreContextCapForSession(ctx);
-		for (const model of touchedModels) restoreContextWindow(model);
+	pi.on("session_tree", async (_event, ctx) => {
+		// Branch changes do not expose a different routed model. Reapply only to
+		// the active physical handle after releasing this instance's old hold.
+		restoreTouchedModels(holderToken, heldModels);
+		if (enabled) applyContextCapToSession(pi, ctx, holderToken, heldModels);
+	});
+
+	pi.on("session_shutdown", async (_event, _ctx) => {
+		restoreTouchedModels(holderToken, heldModels);
 	});
 
 	pi.registerCommand("context-cap", {
@@ -127,31 +295,45 @@ export default function contextCapExtension(pi: ExtensionAPI) {
 
 			if (action === "on" || action === "enable") {
 				enabled = true;
-				const changed = applyContextCapToSession(ctx);
-				ctx.ui.setStatus("context-cap", `ctx cap ${formatTokens(DEFAULT_MAX_CONTEXT_WINDOW)}`);
-				ctx.ui.notify(`Context cap enabled (${changed} model window(s) capped/restored).`, "info");
+				const result = applyContextCap(pi, ctx.model, holderToken, heldModels);
+				const changed = result?.changed ? 1 : 0;
+				const unavailable = unavailableReason(result);
+				ctx.ui.setStatus("context-cap", unavailable ? "ctx cap unavailable" : `ctx cap ${formatTokens(DEFAULT_MAX_CONTEXT_WINDOW)}`);
+				ctx.ui.notify(
+					unavailable
+						? `Context cap enabled, but unavailable: ${unavailable}.`
+						: `Context cap enabled (${changed} active model window(s) capped/restored).`,
+					"info",
+				);
 				return;
 			}
 
 			if (action === "off" || action === "disable") {
 				enabled = false;
-				const changed = restoreContextCapForSession(ctx);
+				const changed = restoreTouchedModels(holderToken, heldModels);
 				ctx.ui.setStatus("context-cap", undefined);
-				ctx.ui.notify(`Context cap disabled for this extension session (${changed} model window(s) restored).`, "info");
+				ctx.ui.notify(`Context cap disabled for this extension session (${changed} active model window(s) restored).`, "info");
 				return;
 			}
 
 			if (action === "toggle") {
 				if (enabled) {
 					enabled = false;
-					const changed = restoreContextCapForSession(ctx);
+					const changed = restoreTouchedModels(holderToken, heldModels);
 					ctx.ui.setStatus("context-cap", undefined);
-					ctx.ui.notify(`Context cap disabled for this extension session (${changed} model window(s) restored).`, "info");
+					ctx.ui.notify(`Context cap disabled for this extension session (${changed} active model window(s) restored).`, "info");
 				} else {
 					enabled = true;
-					const changed = applyContextCapToSession(ctx);
-					ctx.ui.setStatus("context-cap", `ctx cap ${formatTokens(DEFAULT_MAX_CONTEXT_WINDOW)}`);
-					ctx.ui.notify(`Context cap enabled (${changed} model window(s) capped/restored).`, "info");
+					const result = applyContextCap(pi, ctx.model, holderToken, heldModels);
+					const changed = result?.changed ? 1 : 0;
+					const unavailable = unavailableReason(result);
+					ctx.ui.setStatus("context-cap", unavailable ? "ctx cap unavailable" : `ctx cap ${formatTokens(DEFAULT_MAX_CONTEXT_WINDOW)}`);
+					ctx.ui.notify(
+						unavailable
+							? `Context cap enabled, but unavailable: ${unavailable}.`
+							: `Context cap enabled (${changed} active model window(s) capped/restored).`,
+						"info",
+					);
 				}
 				return;
 			}
@@ -164,10 +346,31 @@ export default function contextCapExtension(pi: ExtensionAPI) {
 					return;
 				}
 
-				const original = getOriginalContextWindow(model);
-				const effective = enabled ? getEffectiveContextWindow(model) : model.contextWindow;
+				if (isVirtualModel(model)) {
+					ctx.ui.notify(
+						`Context cap is ${status}. Current model: ${modelKey(model)} is a virtual selection; the routed physical limit is unavailable to this extension.`,
+						"info",
+					);
+					return;
+				}
+
+				const hold = processModelHolds.get(model);
+				const original = originalContextWindow(model);
+				const shouldCheckGuard = enabled && (hold !== undefined || (isKnownContextWindow(model.contextWindow) && model.contextWindow > DEFAULT_MAX_CONTEXT_WINDOW));
+				const guard = shouldCheckGuard ? readCapGuard(pi, model) : { allowed: true as const };
+				const unavailable = !guard.allowed
+					? unavailableReason({
+							changed: false,
+							key: modelKey(model),
+							reason: guard.reason,
+							reserveTokens: guard.reserveTokens,
+						})
+					: undefined;
+				const prefix = unavailable
+					? `Context cap is ${status}, but unavailable: ${unavailable}.`
+					: `Context cap is ${status}.`;
 				ctx.ui.notify(
-					`Context cap is ${status}. Current model: ${modelKey(model)} (${formatTokens(effective)}/${formatTokens(original)} effective/original).`,
+					`${prefix} Current model: ${modelKey(model)} (${formatWindow(model.contextWindow)}/${formatWindow(original)} effective/original).${holdStatus(model, heldModels)}`,
 					"info",
 				);
 				return;

package/extensions/context-cap/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-context-cap",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "A pi extension that caps effective model context windows at 200k tokens for earlier auto-compaction.",
   "keywords": [
     "pi-package",

package/extensions/context-inspector/README.md

@@ -40,6 +40,8 @@ Options:
 - The current-context chart reconciles to pi's footer-compatible context total when pi knows it.
 - Immediately after compaction, pi may not know exact current context usage until the next model response.
 - The full branch tab includes old pre-compaction history for inspection; that history is not necessarily sent verbatim to the model.
+- When the selected model is virtual, the report labels it as a selection and shows the latest routed physical identity from an assistant response when available. It never treats virtual metadata as the provider's context limit; the context window is shown only from Pi's aggregate usage when known.
+- Bounded `nestedCalls` metadata is noted on its parent tool result but is not expanded or counted as transcript output, because Pi does not record child results in the model context.
 - `--keep` writes reports under `<pi-config-dir>/context-reports/`; avoid committing those reports because they can contain sensitive session data unless redacted.
 
 ## Install

package/extensions/context-inspector/index.ts

@@ -122,11 +122,14 @@ type MinimalMessage = {
 	timestamp?: number;
 	provider?: string;
 	model?: string;
+	api?: string;
 	stopReason?: string;
 	usage?: unknown;
 	toolCallId?: string;
 	toolName?: string;
 	details?: unknown;
+	/** Pi keeps nested tool calls here as bounded metadata; they are not transcript content. */
+	nestedCalls?: unknown;
 	customType?: string;
 	display?: boolean;
 	summary?: string;
@@ -240,6 +243,11 @@ type Dataset = {
 	stats: DatasetStats;
 };
 
+type RoutedModel = {
+	provider: string;
+	id: string;
+};
+
 type ReportData = {
 	generatedAt: string;
 	cwd: string;
@@ -253,6 +261,8 @@ type ReportData = {
 		id?: string;
 		contextWindow?: number;
 		thinkingLevel?: string;
+		virtual?: boolean;
+		routed?: RoutedModel;
 	};
 	contextUsage: {
 		tokens: number | null;
@@ -371,6 +381,18 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null;
 }
 
+function isKnownPositiveNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function isKnownNonNegativeNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+function isVirtualModel(model: unknown): boolean {
+	return isRecord(model) && model.api === "pi-virtual";
+}
+
 function getContentBlocks(content: unknown): MinimalContentBlock[] {
 	if (typeof content === "string") return [{ type: "text", text: content }];
 	if (!Array.isArray(content)) return [];
@@ -577,11 +599,22 @@ function analyzeAssistantContent(state: AnalyzerState, message: MinimalMessage,
 	}
 }
 
+function nestedCallsNote(message: MinimalMessage): string | undefined {
+	const nested = message.nestedCalls;
+	if (!isRecord(nested) || !Array.isArray(nested.calls)) return undefined;
+	const count = nested.calls.length;
+	if (nested.complete === false) {
+		return `Pi recorded ${count} bounded nested tool call${count === 1 ? "" : "s"} incompletely; nested results are not transcript context and are excluded from attribution.`;
+	}
+	return `Pi recorded ${count} bounded nested tool call${count === 1 ? "" : "s"}; nested results are not transcript context and are excluded from attribution.`;
+}
+
 function analyzeToolResult(state: AnalyzerState, message: MinimalMessage, entry?: MinimalEntry): void {
 	const timestamp = isoTimestamp(message, entry);
 	const entryId = entry?.id;
 	const toolName = message.toolName ?? "tool";
 	const blocks = getContentBlocks(message.content);
+	const nestedNote = nestedCallsNote(message);
 	for (const block of blocks) {
 		if (block.type === "text" && typeof block.text === "string") {
 			const noteParts: string[] = [];
@@ -589,6 +622,7 @@ function analyzeToolResult(state: AnalyzerState, message: MinimalMessage, entry?
 				if (isRecord(message.details.truncation) && message.details.truncation.truncated) noteParts.push("Result was truncated before entering context.");
 				if (typeof message.details.fullOutputPath === "string") noteParts.push(`Full output: ${message.details.fullOutputPath}`);
 			}
+			if (nestedNote) noteParts.push(nestedNote);
 			addTextSegment(state, "toolResults", `Tool result: ${toolName}`, block.text, {
 				source: "tool-result",
 				role: "toolResult",
@@ -801,10 +835,14 @@ function resolveSessionProjection(ctx: ExtensionCommandContext): MinimalSessionP
 			messages: candidate.messages,
 		});
 	}
+	// `entries` is the provenance-bearing canonical projection. Keep validating
+	// the optional flattened field for compatibility, but derive the list used by
+	// the report from entries so a stale/invented flattened list cannot reintroduce
+	// omitted history or nested metadata as transcript messages.
 	if ("messages" in projection && (!Array.isArray(projection.messages) || !projection.messages.every(isProjectionMessage))) return undefined;
 	return {
 		entries,
-		messages: Array.isArray(projection.messages) ? projection.messages : entries.flatMap((entry) => entry.messages),
+		messages: entries.flatMap((entry) => entry.messages),
 	};
 }
 
@@ -1005,15 +1043,41 @@ function getSessionName(ctx: ExtensionCommandContext): string | undefined {
 	return safeCall(() => ctx.sessionManager.getSessionName()) ?? safeCall(() => (ctx as unknown as { getSessionName?: () => string | undefined }).getSessionName?.());
 }
 
+function latestRoutedModel(messages: MinimalMessage[]): RoutedModel | undefined {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message?.role !== "assistant") continue;
+		if (message.stopReason === "error" || message.stopReason === "aborted") continue;
+		if (message.api === "pi-virtual") continue;
+		if (typeof message.provider !== "string" || !message.provider || typeof message.model !== "string" || !message.model) continue;
+		return { provider: message.provider, id: message.model };
+	}
+	return undefined;
+}
+
 function buildReportData(pi: ExtensionAPI, ctx: ExtensionCommandContext, options: CommandOptions): ReportData {
 	const branchEntries = ctx.sessionManager.getBranch() as MinimalEntry[];
+	const projection = resolveSessionProjection(ctx);
 	const overhead = buildOverheadSegments(pi, ctx, options.redact);
-	const currentAnalysis = resolveCurrentContextAnalysis(ctx, branchEntries, options.redact);
+	const currentAnalysis = projection
+		? analyzeProjection(projection, options.redact)
+		: analyzeEntries(resolveCurrentContextEntries(ctx, branchEntries), options.redact);
 	const fullAnalysis = analyzeEntries(branchEntries, options.redact);
 	const usage = ctx.getContextUsage();
-	const contextTokens = usage?.tokens ?? null;
-	const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? null;
-	const contextPercent = usage?.percent ?? (contextTokens != null && contextWindow ? (contextTokens / contextWindow) * 100 : null);
+	const contextTokens = isKnownNonNegativeNumber(usage?.tokens) ? usage.tokens : null;
+	const reportedContextWindow = isKnownPositiveNumber(usage?.contextWindow) ? usage.contextWindow : undefined;
+	const selectedContextWindow = isKnownPositiveNumber(ctx.model?.contextWindow) ? ctx.model.contextWindow : undefined;
+	const virtualSelection = isVirtualModel(ctx.model);
+	const contextWindow = reportedContextWindow ?? (virtualSelection ? null : selectedContextWindow ?? null);
+	const reportedPercent = isKnownNonNegativeNumber(usage?.percent) ? usage.percent : undefined;
+	const contextPercent = reportedPercent ?? (contextTokens != null && contextWindow ? (contextTokens / contextWindow) * 100 : null);
+	const projectedMessages = projection
+		? projection.entries.flatMap((entry) => entry.messages)
+		: branchEntries.flatMap((entry) => {
+			const message = contextEntryToMessage(entry);
+			return message ? [message] : [];
+		});
+	const routed = virtualSelection ? latestRoutedModel(projectedMessages) : undefined;
 
 	const currentSegments = [...overhead, ...currentAnalysis.segments];
 	const fullSegments = [...overhead, ...fullAnalysis.segments];
@@ -1041,9 +1105,19 @@ function buildReportData(pi: ExtensionAPI, ctx: ExtensionCommandContext, options
 	if (options.redact) {
 		notes.push("Redaction is enabled: message contents, paths, commands, session identifiers, and timestamps are hidden in this report.");
 	}
-	if (usage?.tokens == null) {
+	if (contextTokens == null) {
 		notes.push("Current context usage is unknown, usually because compaction just ran and no model response has arrived yet.");
 	}
+	if (virtualSelection) {
+		const selected = [ctx.model?.provider, ctx.model?.id].filter(Boolean).join("/") || "virtual selection";
+		if (routed) {
+			notes.push(`Model selection ${selected} is virtual. Latest routed physical response: ${routed.provider}/${routed.id}. The context window shown below is provider-reported usage when available; it is not inferred from the virtual selection.`);
+		} else {
+			notes.push(`Model selection ${selected} is virtual. Pi has not exposed a routed physical response here, so no provider context window is inferred.`);
+		}
+	} else if (contextWindow == null) {
+		notes.push("The selected model's context window is unknown because pi did not provide a finite positive limit.");
+	}
 	if (currentDataset.stats.estimatorOverageTokens > 0) {
 		notes.push(`Local component estimates exceed pi's footer total by ${formatTokens(currentDataset.stats.estimatorOverageTokens)} tokens, so chart slices are scaled down proportionally.`);
 	}
@@ -1062,8 +1136,10 @@ function buildReportData(pi: ExtensionAPI, ctx: ExtensionCommandContext, options
 		model: {
 			provider: ctx.model?.provider,
 			id: ctx.model?.id,
-			contextWindow: ctx.model?.contextWindow,
+			contextWindow: selectedContextWindow,
 			thinkingLevel: safeCall(() => pi.getThinkingLevel()),
+			virtual: virtualSelection,
+			routed,
 		},
 		contextUsage: {
 			tokens: contextTokens,
@@ -1384,12 +1460,17 @@ pre { margin: 0; white-space: pre-wrap; word-break: break-word; color: #cbd5e1;
 	function renderCards(ds) {
 		const cards = $('cards'); cards.replaceChildren();
 		const usage = data.contextUsage;
-		const model = [data.model.provider, data.model.id].filter(Boolean).join('/') || 'no model';
+		const selectedModel = [data.model.provider, data.model.id].filter(Boolean).join('/') || 'no model';
+		const routedModel = data.model.virtual && data.model.routed ? [data.model.routed.provider, data.model.routed.id].join('/') : '';
+		const model = routedModel && routedModel !== selectedModel ? selectedModel + ' → ' + routedModel : selectedModel;
+		const modelHint = data.model.virtual
+			? (routedModel ? 'virtual selection → latest routed physical response' : 'virtual selection; routed physical model unavailable')
+			: (data.model.thinkingLevel ? 'thinking: ' + data.model.thinkingLevel : '');
 		const cardData = [
 			['Context used', usage.tokens == null ? fmt(ds.stats.tokens) : fmt(usage.tokens), usage.percent == null ? 'Footer percent is currently unknown.' : pct(usage.percent) + ' of ' + fmt(usage.contextWindow) + ' tokens'],
 			['Dataset total', fmt(ds.stats.tokens), ds.id === 'current' ? 'Reconciled to pi footer when available.' : 'Full branch is shown as raw local estimates.'],
 			['Biggest bucket', ds.stats.categories[0]?.label || '—', ds.stats.categories[0] ? fmt(ds.stats.categories[0].displayTokens) + ' tokens' : 'No context-bearing entries found.'],
-			['Model', model, data.model.thinkingLevel ? 'thinking: ' + data.model.thinkingLevel : ''],
+			['Model', model, modelHint],
 		];
 		for (const [label, value, hint] of cardData) {
 			cards.append(el('div', { class: 'card' }, [

package/extensions/context-inspector/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-context-inspector",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "A pi extension that opens a local HTML dashboard explaining where the current session context is going.",
   "keywords": [
     "pi-package",