@oh-my-pi/pi-coding-agent 15.11.3 → 15.11.4

package/src/session/agent-session.ts

@@ -107,7 +107,7 @@ import {
 	relativePathWithinRoot,
 	Snowflake,
 } from "@oh-my-pi/pi-utils";
-import { snapcompactCompact } from "@oh-my-pi/snapcompact";
+import * as snapcompact from "@oh-my-pi/snapcompact";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
 import { classifyDifficulty } from "../auto-thinking/classifier";
 import { reset as resetCapabilities } from "../capability";
@@ -855,8 +855,13 @@ function extractPermissionLocations(
  *  `tag` is set only by `enqueueCustomMessageDisplay` (used for skill-prompt
  *  custom messages queued during streaming) and is matched by the custom-role
  *  `message_start` dequeue branch; user-message pushes leave it undefined and
- *  rely on the existing text-equality match. */
-type QueuedDisplayEntry = { text: string; tag?: string };
+ *  rely on the existing text-equality match. `images` carries the original
+ *  (pre-normalization) image blocks so queue restoration (Esc / Alt+Up) can
+ *  hand them back to the editor instead of dropping them. */
+type QueuedDisplayEntry = { text: string; tag?: string; images?: ImageContent[] };
+
+/** Entry returned by {@link AgentSession.clearQueue} / {@link AgentSession.popLastQueuedMessage}. */
+export type RestoredQueuedMessage = { text: string; images?: ImageContent[] };
 
 export class AgentSession {
 	readonly agent: Agent;
@@ -5028,7 +5033,7 @@ export class AgentSession {
 	async #queueSteer(text: string, images?: ImageContent[]): Promise<void> {
 		const normalizedImages = await normalizeModelContextImages(images);
 		const displayText = text || (images && images.length > 0 ? "[Image]" : "");
-		this.#steeringMessages.push({ text: displayText });
+		this.#steeringMessages.push({ text: displayText, images });
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
 		if (normalizedImages && normalizedImages.length > 0) {
 			content.push(...normalizedImages);
@@ -5040,6 +5045,16 @@ export class AgentSession {
 			attribution: "user",
 			timestamp: Date.now(),
 		});
+		// A steer can land on an idle session: the caller checked isStreaming
+		// before the (potentially slow) image normalization above, so the turn
+		// may have ended in between. Without a drain the message would strand in
+		// the queue until the next manual prompt — schedule an immediate continue,
+		// mirroring #queueFollowUp's idle-path delivery.
+		if (this.#canAutoContinueForFollowUp()) {
+			this.#scheduleAgentContinue({
+				shouldContinue: () => this.#canAutoContinueForFollowUp() && this.agent.hasQueuedMessages(),
+			});
+		}
 	}
 
 	/**
@@ -5048,7 +5063,7 @@ export class AgentSession {
 	async #queueFollowUp(text: string, images?: ImageContent[]): Promise<void> {
 		const normalizedImages = await normalizeModelContextImages(images);
 		const displayText = text || (images && images.length > 0 ? "[Image]" : "");
-		this.#followUpMessages.push({ text: displayText });
+		this.#followUpMessages.push({ text: displayText, images });
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
 		if (normalizedImages && normalizedImages.length > 0) {
 			content.push(...normalizedImages);
@@ -5297,12 +5312,14 @@ export class AgentSession {
 	}
 
 	/**
-	 * Clear queued messages and return them.
-	 * Useful for restoring to editor when user aborts.
+	 * Clear queued messages and return them (text plus any attached images).
+	 * Useful for restoring to editor when user aborts. The internal entry
+	 * arrays are handed out as-is — a `tag` (if any) is inert once the record
+	 * leaves the queue.
 	 */
-	clearQueue(): { steering: string[]; followUp: string[] } {
-		const steering = this.#steeringMessages.map(e => e.text);
-		const followUp = this.#followUpMessages.map(e => e.text);
+	clearQueue(): { steering: RestoredQueuedMessage[]; followUp: RestoredQueuedMessage[] } {
+		const steering = this.#steeringMessages;
+		const followUp = this.#followUpMessages;
 		this.#steeringMessages = [];
 		this.#followUpMessages = [];
 		this.agent.clearAllQueues();
@@ -5328,21 +5345,21 @@ export class AgentSession {
 	/**
 	 * Pop the last queued message (steering first, then follow-up).
 	 * Used by dequeue keybinding to restore messages to editor one at a time.
-	 * Returns the popped entry's `.text`; the tag (if any) dies with the
-	 * record — no orphan state can outlive the queue entry.
+	 * Returns the popped entry's text and images; the tag (if any) dies with
+	 * the record — no orphan state can outlive the queue entry.
 	 */
-	popLastQueuedMessage(): string | undefined {
+	popLastQueuedMessage(): RestoredQueuedMessage | undefined {
 		// Pop from steering first (LIFO)
 		if (this.#steeringMessages.length > 0) {
 			const entry = this.#steeringMessages.pop();
 			this.agent.popLastSteer();
-			return entry?.text;
+			return entry;
 		}
 		// Then from follow-up
 		if (this.#followUpMessages.length > 0) {
 			const entry = this.#followUpMessages.pop();
 			this.agent.popLastFollowUp();
-			return entry?.text;
+			return entry;
 		}
 		return undefined;
 	}
@@ -6368,7 +6385,10 @@ export class AgentSession {
 				details = compactionPrep.details;
 				preserveData = compactionPrep.preserveData;
 			} else if (snapcompactReady) {
-				const snapcompactResult = await snapcompactCompact(preparation, { convertToLlm, model: this.model });
+				const snapcompactResult = await snapcompact.compact(preparation, {
+					convertToLlm,
+					model: this.model,
+				});
 				summary = snapcompactResult.summary;
 				shortSummary = snapcompactResult.shortSummary;
 				firstKeptEntryId = snapcompactResult.firstKeptEntryId;
@@ -6582,7 +6602,7 @@ export class AgentSession {
 			const rawHandoffText = await generateHandoff(
 				this.agent.state.messages,
 				model,
-				apiKey,
+				this.#modelRegistry.resolver(model, this.sessionId),
 				{
 					systemPrompt: this.#obfuscateForProvider(this.#baseSystemPrompt),
 					tools: obfuscateProviderTools(this.#obfuscator, this.agent.state.tools),
@@ -7252,6 +7272,22 @@ export class AgentSession {
 		this.#closeProviderSessionsForModelSwitch(currentModel, currentModel);
 	}
 
+	#resetCurrentResponsesProviderSession(reason: string): void {
+		const currentModel = this.model;
+		if (currentModel?.api !== "openai-responses" && currentModel?.api !== "openai-codex-responses") {
+			return;
+		}
+
+		this.#closeProviderSessionsForModelSwitch(currentModel, currentModel);
+		this.agent.appendOnlyContext?.invalidateForModelChange();
+		logger.debug("Reset Responses provider session after stale replay error", {
+			provider: currentModel.provider,
+			model: currentModel.id,
+			api: currentModel.api,
+			reason,
+		});
+	}
+
 	/**
 	 * Re-evaluate append-only context mode, creating or destroying the
 	 * manager as needed. Called on model switch AND setting change.
@@ -7577,7 +7613,7 @@ export class AgentSession {
 				return await compact(
 					this.#obfuscatePreparationForProvider(preparation),
 					candidate,
-					apiKey,
+					this.#modelRegistry.resolver(candidate, this.sessionId),
 					this.#obfuscateTextForProvider(customInstructions),
 					signal,
 					{
@@ -7882,7 +7918,10 @@ export class AgentSession {
 			} else if (action === "snapcompact") {
 				// Local, deterministic: render discarded history onto PNG frames.
 				// No model candidates, no API key, no retry loop.
-				const snapcompactResult = await snapcompactCompact(preparation, { convertToLlm, model: this.model });
+				const snapcompactResult = await snapcompact.compact(preparation, {
+					convertToLlm,
+					model: this.model,
+				});
 				summary = snapcompactResult.summary;
 				shortSummary = snapcompactResult.shortSummary;
 				firstKeptEntryId = snapcompactResult.firstKeptEntryId;
@@ -7906,7 +7945,7 @@ export class AgentSession {
 							compactResult = await compact(
 								this.#obfuscatePreparationForProvider(preparation),
 								candidate,
-								apiKey,
+								this.#modelRegistry.resolver(candidate, this.sessionId),
 								undefined,
 								autoCompactionSignal,
 								{
@@ -8293,11 +8332,32 @@ export class AgentSession {
 		if (isContextOverflow(message, contextWindow)) return false;
 
 		if (this.#isClassifierRefusal(message)) return true;
+		if (this.#isStaleOpenAIResponsesReplayError(message)) return true;
 
 		const err = message.errorMessage;
 		return this.#isTransientErrorMessage(err) || isUsageLimitError(err);
 	}
 
+	#isStaleOpenAIResponsesReplayError(message: AssistantMessage): boolean {
+		const currentApi = this.model?.api;
+		if (
+			message.api !== "openai-responses" &&
+			message.api !== "openai-codex-responses" &&
+			currentApi !== "openai-responses" &&
+			currentApi !== "openai-codex-responses"
+		) {
+			return false;
+		}
+
+		const errorMessage = message.errorMessage;
+		if (!errorMessage) return false;
+
+		return (
+			/\bItem with id ['"][^'"]+['"] not found\.?/i.test(errorMessage) ||
+			(/previous[ _]?response/i.test(errorMessage) && /not[ _]?found|invalid|expired|stale/i.test(errorMessage))
+		);
+	}
+
 	#isClassifierRefusal(message: AssistantMessage): boolean {
 		if (message.stopReason !== "error") return false;
 		const stopType = message.stopDetails?.type;
@@ -8631,15 +8691,22 @@ export class AgentSession {
 		}
 
 		const errorMessage = message.errorMessage || "Unknown error";
+		const staleOpenAIResponsesReplayError = this.#isStaleOpenAIResponsesReplayError(message);
 		const parsedRetryAfterMs = this.#parseRetryAfterMsFromError(errorMessage);
-		let delayMs = calculateRetryBackoffDelayMs(retrySettings.baseDelayMs, this.#retryAttempt);
+		let delayMs = staleOpenAIResponsesReplayError
+			? 0
+			: calculateRetryBackoffDelayMs(retrySettings.baseDelayMs, this.#retryAttempt);
 		let switchedCredential = false;
 		let switchedModel = false;
 		// Set when a usage-limit error pinned the wait to credential
 		// availability — suppresses the generic retry-after bump below.
 		let usageLimitWaitMs: number | undefined;
 
-		if (this.model && isUsageLimitError(errorMessage)) {
+		if (staleOpenAIResponsesReplayError) {
+			this.#resetCurrentResponsesProviderSession("stale replay error");
+		}
+
+		if (this.model && !staleOpenAIResponsesReplayError && isUsageLimitError(errorMessage)) {
 			const retryAfterMs = parsedRetryAfterMs ?? calculateRateLimitBackoffMs(parseRateLimitReason(errorMessage));
 			const outcome = await this.#modelRegistry.authStorage.markUsageLimitReached(
 				this.model.provider,
@@ -8676,7 +8743,7 @@ export class AgentSession {
 		}
 
 		const currentSelector = this.model ? formatRetryFallbackSelector(this.model, this.thinkingLevel) : undefined;
-		if (!switchedCredential && currentSelector) {
+		if (!staleOpenAIResponsesReplayError && !switchedCredential && currentSelector) {
 			if (retrySettings.modelFallback) {
 				if (!classifierRefusal) {
 					this.#noteRetryFallbackCooldown(currentSelector, parsedRetryAfterMs, errorMessage);
@@ -9813,7 +9880,7 @@ export class AgentSession {
 			const branchSummarySettings = this.settings.getGroup("branchSummary");
 			const result = await generateBranchSummary(entriesToSummarize, {
 				model,
-				apiKey,
+				apiKey: this.#modelRegistry.resolver(model, this.sessionId),
 				signal: this.#branchSummaryAbortController.signal,
 				customInstructions: this.#obfuscateTextForProvider(options.customInstructions),
 				reserveTokens: branchSummarySettings.reserveTokens,

package/src/session/auth-storage.ts

@@ -12,6 +12,7 @@ export type {
 	AuthStorageOptions,
 	CredentialOrigin,
 	CredentialOriginKind,
+	OAuthAccountIdentity,
 	OAuthCredential,
 	SerializedAuthStorage,
 	SnapshotResponse,

package/src/session/session-dump-format.ts

@@ -4,6 +4,7 @@
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import { isZodSchema, zodToWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
 import {
 	type BashExecutionMessage,
 	type BranchSummaryMessage,
@@ -47,6 +48,12 @@ function stripTypeBoxFields(obj: unknown): unknown {
 	return obj;
 }
 
+/** Resolve tool parameters to a plain JSON Schema object for dump output. */
+function toolParametersToJsonSchema(parameters: unknown): unknown {
+	if (isZodSchema(parameters)) return zodToWireSchema(parameters);
+	return stripTypeBoxFields(parameters);
+}
+
 /** Serialize an object as XML parameter elements, one per key. */
 function formatArgsAsXml(args: Record<string, unknown>, indent = "\t"): string {
 	const parts: string[] = [];
@@ -89,7 +96,7 @@ export function formatSessionDumpText(options: FormatSessionDumpTextOptions): st
 		for (const tool of tools) {
 			lines.push(`<tool name="${tool.name}">`);
 			lines.push(tool.description);
-			const parametersClean = stripTypeBoxFields(tool.parameters);
+			const parametersClean = toolParametersToJsonSchema(tool.parameters);
 			lines.push(`\nParameters:\n${formatArgsAsXml(parametersClean as Record<string, unknown>)}`);
 			lines.push("<" + "/tool>\n");
 		}

package/src/session/session-manager.ts

@@ -27,7 +27,7 @@ import {
 	Snowflake,
 	toError,
 } from "@oh-my-pi/pi-utils";
-import { getPreservedSnapcompactArchive, snapcompactImages } from "@oh-my-pi/snapcompact";
+import * as snapcompact from "@oh-my-pi/snapcompact";
 import { ArtifactManager } from "./artifacts";
 import {
 	type BlobPutOptions,
@@ -712,7 +712,7 @@ export function buildSessionContext(
 		// the component can report them.
 		for (const entry of path) {
 			if (entry.type === "compaction") {
-				const snapcompactArchive = getPreservedSnapcompactArchive(entry.preserveData);
+				const snapcompactArchive = snapcompact.getPreservedArchive(entry.preserveData);
 				messages.push(
 					createCompactionSummaryMessage(
 						entry.summary,
@@ -720,7 +720,7 @@ export function buildSessionContext(
 						entry.timestamp,
 						entry.shortSummary,
 						undefined,
-						snapcompactArchive ? snapcompactImages(snapcompactArchive) : undefined,
+						snapcompactArchive ? snapcompact.images(snapcompactArchive) : undefined,
 					),
 				);
 			} else {
@@ -744,7 +744,7 @@ export function buildSessionContext(
 
 		// Emit summary first; re-attach any archived snapcompact frames so the
 		// model can keep reading the archived history after every context rebuild.
-		const snapcompactArchive = getPreservedSnapcompactArchive(compaction.preserveData);
+		const snapcompactArchive = snapcompact.getPreservedArchive(compaction.preserveData);
 		messages.push(
 			createCompactionSummaryMessage(
 				compaction.summary,
@@ -752,7 +752,7 @@ export function buildSessionContext(
 				compaction.timestamp,
 				compaction.shortSummary,
 				providerPayload,
-				snapcompactArchive ? snapcompactImages(snapcompactArchive) : undefined,
+				snapcompactArchive ? snapcompact.images(snapcompactArchive) : undefined,
 			),
 		);
 

package/src/session/snapcompact-inline.ts

@@ -0,0 +1,187 @@
+/**
+ * Snapcompact inline imaging: per-request transform that swaps the system
+ * prompt and/or large historical tool results for dense PNG frames on
+ * vision-capable models.
+ *
+ * Runs inside the agent loop's `transformProviderContext` hook — after the
+ * persisted history is converted to the outgoing `Context`, before the
+ * provider stream call. It only ever builds NEW message objects/arrays; the
+ * input context shares `content` array references with the persisted
+ * `SessionMessageEntry` messages, so mutation would leak rendered images
+ * into session.jsonl.
+ */
+import type { Context, ImageContent, Model, TextContent, ToolResultMessage, UserMessage } from "@oh-my-pi/pi-ai";
+import { countTokens } from "@oh-my-pi/pi-natives";
+import * as snapcompact from "@oh-my-pi/snapcompact";
+import systemFramesNote from "../prompts/system/snapcompact-system-frames-note.md" with { type: "text" };
+import systemStub from "../prompts/system/snapcompact-system-stub.md" with { type: "text" };
+import toolResultNote from "../prompts/system/snapcompact-toolresult-note.md" with { type: "text" };
+
+export interface SnapcompactInlineOptions {
+	renderSystemPrompt: boolean;
+	renderToolResults: boolean;
+}
+
+/**
+ * Image-count budget per provider. Snapcompact frames are 1568px (<2000px) so
+ * dimension/size limits never bind; only COUNT does. Strictest mainstream is
+ * Groq (~5), so unknown providers get the safe floor.
+ */
+const INLINE_IMAGE_BUDGET_BY_PROVIDER: Record<string, number> = {
+	anthropic: 90,
+	"amazon-bedrock": 90,
+	openai: 200,
+	google: 200,
+	"google-vertex": 200,
+	"google-gemini-cli": 200,
+};
+const DEFAULT_INLINE_IMAGE_BUDGET = 5;
+const MAX_SYSTEM_PROMPT_FRAMES = 6;
+/** Tool results under this many tokens are never rasterized — the swap can't
+ *  save enough to justify trading crisp text for an image. */
+const MIN_TOOL_RESULT_TOKENS = 3000;
+/** Render only if imageTokens <= textTokens * SAVINGS_MARGIN. */
+const SAVINGS_MARGIN = 0.9;
+
+/** Count image blocks already present across all message contents. */
+function countContextImages(context: Context): number {
+	let count = 0;
+	for (const message of context.messages) {
+		const content = message.content;
+		if (typeof content === "string") continue;
+		for (const block of content) {
+			if (block.type === "image") count++;
+		}
+	}
+	return count;
+}
+
+function isTextContent(block: TextContent | ImageContent): block is TextContent {
+	return block.type === "text";
+}
+
+/** Image tokens must undercut text tokens by the margin to be worth rendering. */
+function passesSavingsGate(frames: number, shape: snapcompact.Shape, textTokens: number): boolean {
+	return frames * shape.frameTokenEstimate <= textTokens * SAVINGS_MARGIN;
+}
+
+interface FrameCacheEntry {
+	hash: number | bigint;
+	frames: ImageContent[];
+}
+
+/**
+ * Stateless with respect to the model (passed per call, so mid-session model
+ * switches re-resolve shape and budget); stateful only for the render caches,
+ * which live as long as the session's Agent.
+ */
+export class SnapcompactInlineTransformer {
+	/** Rendered tool-result frames keyed by toolCallId. */
+	#toolCache = new Map<string, FrameCacheEntry>();
+	#systemCache?: FrameCacheEntry;
+
+	constructor(private readonly options: SnapcompactInlineOptions) {}
+
+	transform(context: Context, model: Model): Context {
+		// Vision gate: providers silently DROP images on text-only models —
+		// rendering would lose the content entirely.
+		if (!model.input.includes("image")) return context;
+
+		const shape = snapcompact.resolveShape(model.api);
+		let budget =
+			(INLINE_IMAGE_BUDGET_BY_PROVIDER[model.provider] ?? DEFAULT_INLINE_IMAGE_BUDGET) - countContextImages(context);
+		if (budget <= 0) return context;
+
+		const messages = [...context.messages];
+		let changed = false;
+
+		if (this.options.renderToolResults) {
+			const toolResultIndices: number[] = [];
+			const liveToolCallIds = new Set<string>();
+			for (let i = 0; i < messages.length; i++) {
+				const message = messages[i];
+				if (message.role !== "toolResult") continue;
+				toolResultIndices.push(i);
+				liveToolCallIds.add(message.toolCallId);
+			}
+			// Oldest-first for cache-stable bytes; skip the LAST tool result so
+			// the freshest output stays crisp text.
+			for (let k = 0; k < toolResultIndices.length - 1 && budget > 0; k++) {
+				const index = toolResultIndices[k];
+				const message = messages[index] as ToolResultMessage;
+				// Don't re-image results that already carry images (screenshots etc.).
+				if (message.content.some(block => block.type === "image")) continue;
+				const text = message.content
+					.filter(isTextContent)
+					.map(block => block.text)
+					.join("\n");
+				const textTokens = countTokens(text);
+				if (textTokens < MIN_TOOL_RESULT_TOKENS) continue;
+				const needed = snapcompact.frames(text, { shape });
+				if (needed === 0 || needed > budget) continue;
+				if (!passesSavingsGate(needed, shape, textTokens)) continue;
+				const frames = this.#framesFor(this.#toolCache, message.toolCallId, text, shape);
+				messages[index] = { ...message, content: [{ type: "text", text: toolResultNote }, ...frames] };
+				budget -= frames.length;
+				changed = true;
+			}
+			// Drop cache entries for tool calls no longer in the context
+			// (compacted away) so the cache stays bounded by live history.
+			for (const key of this.#toolCache.keys()) {
+				if (!liveToolCallIds.has(key)) this.#toolCache.delete(key);
+			}
+		}
+
+		let systemPrompt = context.systemPrompt;
+		if (this.options.renderSystemPrompt && context.systemPrompt?.length && budget > 0) {
+			const joined = context.systemPrompt.join("\n\n");
+			const needed = snapcompact.frames(joined, { shape });
+			const userIndex = messages.findIndex(message => message.role === "user");
+			if (
+				needed > 0 &&
+				needed <= Math.min(budget, MAX_SYSTEM_PROMPT_FRAMES) &&
+				passesSavingsGate(needed, shape, countTokens(joined)) &&
+				// No user message to carry the frames → leave the prompt as text.
+				userIndex >= 0
+			) {
+				const hash = Bun.hash(joined);
+				let cached = this.#systemCache;
+				if (!cached || cached.hash !== hash) {
+					cached = {
+						hash,
+						frames: snapcompact.renderMany(joined, { shape, maxFrames: MAX_SYSTEM_PROMPT_FRAMES }),
+					};
+					this.#systemCache = cached;
+				}
+				const frames = cached.frames;
+				const original = messages[userIndex] as UserMessage;
+				const originalContent: (TextContent | ImageContent)[] =
+					typeof original.content === "string" ? [{ type: "text", text: original.content }] : original.content;
+				messages[userIndex] = {
+					...original,
+					content: [{ type: "text", text: systemFramesNote }, ...frames, ...originalContent],
+				};
+				systemPrompt = [systemStub];
+				budget -= frames.length;
+				changed = true;
+			}
+		}
+
+		if (!changed) return context;
+		return { ...context, systemPrompt, messages };
+	}
+
+	#framesFor(
+		cache: Map<string, FrameCacheEntry>,
+		key: string,
+		text: string,
+		shape: snapcompact.Shape,
+	): ImageContent[] {
+		const hash = Bun.hash(text);
+		const cached = cache.get(key);
+		if (cached && cached.hash === hash) return cached.frames;
+		const frames = snapcompact.renderMany(text, { shape });
+		cache.set(key, { hash, frames });
+		return frames;
+	}
+}

package/src/slash-commands/helpers/active-oauth-account.ts

@@ -0,0 +1,44 @@
+import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
+import type { OAuthAccountIdentity } from "../../session/auth-storage";
+
+function normalizeIdentityValue(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim().toLowerCase() : undefined;
+}
+
+/**
+ * True when a single usage-limit column belongs to the given OAuth identity.
+ *
+ * Single definition of the matching rules for both `/usage` renderers:
+ * - `accountId` ↔ report metadata `accountId`/`account_id` or `limit.scope.accountId`
+ * - `email`     ↔ report metadata `email`
+ * - `projectId` ↔ report metadata `projectId` or `limit.scope.projectId`
+ *   (Google-style providers key usage on the GCP project, not an account id)
+ */
+export function limitMatchesActiveAccount(
+	report: UsageReport,
+	limit: UsageLimit,
+	identity: OAuthAccountIdentity | undefined,
+): boolean {
+	if (!identity) return false;
+	const metadata = report.metadata ?? {};
+	const activeAccountId = normalizeIdentityValue(identity.accountId);
+	if (activeAccountId) {
+		const reportAccountId = normalizeIdentityValue(metadata.accountId) ?? normalizeIdentityValue(metadata.account_id);
+		if (reportAccountId === activeAccountId) return true;
+		if (normalizeIdentityValue(limit.scope.accountId) === activeAccountId) return true;
+	}
+	const activeEmail = normalizeIdentityValue(identity.email);
+	if (activeEmail && normalizeIdentityValue(metadata.email) === activeEmail) return true;
+	const activeProjectId = normalizeIdentityValue(identity.projectId);
+	if (activeProjectId) {
+		if (normalizeIdentityValue(metadata.projectId) === activeProjectId) return true;
+		if (normalizeIdentityValue(limit.scope.projectId) === activeProjectId) return true;
+	}
+	return false;
+}
+
+/** True when any limit column in `report` belongs to the given OAuth identity. */
+export function reportMatchesActiveAccount(report: UsageReport, identity: OAuthAccountIdentity | undefined): boolean {
+	if (!identity) return false;
+	return report.limits.some(limit => limitMatchesActiveAccount(report, limit, identity));
+}

package/src/slash-commands/helpers/usage-report.ts

@@ -1,5 +1,7 @@
 import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
+import type { OAuthAccountIdentity } from "../../session/auth-storage";
 import type { SlashCommandRuntime } from "../types";
+import { reportMatchesActiveAccount } from "./active-oauth-account";
 import { formatDuration, renderAsciiBar } from "./format";
 
 function formatProviderName(provider: string): string {
@@ -31,7 +33,11 @@ function formatUsageReportAccount(report: UsageReport, limit: UsageLimit, index:
 	return `account ${index + 1}`;
 }
 
-function renderUsageReports(reports: UsageReport[], nowMs: number): string {
+function renderUsageReports(
+	reports: UsageReport[],
+	nowMs: number,
+	resolveActiveAccount?: (provider: string) => OAuthAccountIdentity | undefined,
+): string {
 	const latestFetchedAt = Math.max(...reports.map(report => report.fetchedAt ?? 0));
 	const lines = [`Usage${latestFetchedAt ? ` (${formatDuration(nowMs - latestFetchedAt)} ago)` : ""}`];
 	const grouped = new Map<string, UsageReport[]>();
@@ -45,7 +51,9 @@ function renderUsageReports(reports: UsageReport[], nowMs: number): string {
 		left.localeCompare(right),
 	)) {
 		lines.push("", formatProviderName(provider));
+		const activeAccount = resolveActiveAccount?.(provider);
 		for (const report of providerReports) {
+			const inUse = reportMatchesActiveAccount(report, activeAccount);
 			if (report.limits.length === 0) {
 				const email = typeof report.metadata?.email === "string" ? report.metadata.email : "account";
 				lines.push(`- ${email}: no limits reported`);
@@ -56,7 +64,9 @@ function renderUsageReports(reports: UsageReport[], nowMs: number): string {
 				const window = limit.window?.label ?? limit.scope.windowId;
 				const tier = limit.scope.tier ? ` (${limit.scope.tier})` : "";
 				lines.push(`- ${limit.label}${tier}${window ? ` — ${window}` : ""}`);
-				lines.push(`  ${formatUsageReportAccount(report, limit, index)}: ${formatUsageAmount(limit)}`);
+				lines.push(
+					`  ${formatUsageReportAccount(report, limit, index)}: ${formatUsageAmount(limit)}${inUse ? "  ← in use by this session" : ""}`,
+				);
 				lines.push(`  ${renderAsciiBar(limit.amount.usedFraction)}`);
 				if (limit.window?.resetsAt && limit.window.resetsAt > nowMs) {
 					lines.push(`  resets in ${formatDuration(limit.window.resetsAt - nowMs)}`);
@@ -79,7 +89,18 @@ export async function buildUsageReportText(runtime: SlashCommandRuntime): Promis
 	};
 	if (provider.fetchUsageReports) {
 		const reports = await provider.fetchUsageReports();
-		if (reports && reports.length > 0) return renderUsageReports(reports, Date.now());
+		if (reports && reports.length > 0) {
+			const currentProvider = runtime.session.model?.provider;
+			const activeAccount = currentProvider
+				? runtime.session.modelRegistry.authStorage.getOAuthAccountIdentity(
+						currentProvider,
+						runtime.session.sessionId,
+					)
+				: undefined;
+			return renderUsageReports(reports, Date.now(), providerId =>
+				providerId === currentProvider ? activeAccount : undefined,
+			);
+		}
 	}
 
 	const stats = runtime.session.sessionManager.getUsageStatistics();