@oh-my-pi/pi-coding-agent 13.5.2 → 13.5.4

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## [Unreleased]
 
+## [13.5.4] - 2026-03-01
+### Added
+
+- Added `authServerUrl` field to `AuthDetectionResult` to capture OAuth server metadata from `Mcp-Auth-Server` headers
+- Added `extractMcpAuthServerUrl()` function to parse and validate `Mcp-Auth-Server` URLs from error messages
+- Added support for `/.well-known/oauth-protected-resource` discovery endpoint to resolve authorization servers
+- Added recursive auth server discovery to follow `authorization_servers` references when discovering OAuth endpoints
+
+- Added `omp agents unpack` CLI subcommand to export bundled subagent definitions to `~/.omp/agent/agents` by default, with `--project` support for `./.omp/agents`
+### Changed
+
+- Enhanced `discoverOAuthEndpoints()` to accept optional `authServerUrl` parameter and query both auth server and resource server for OAuth metadata
+- Improved OAuth metadata extraction to handle additional field name variations (`clientId`, `default_client_id`, `public_client_id`)
+- Refactored OAuth endpoint discovery logic into reusable `findEndpoints()` helper for consistent metadata parsing across multiple sources
+- Task subagents now strip inherited `AGENTS.md` context files and the task tool prompt no longer warns against repeating AGENTS guidance, aligning subagent context with explicit task inputs ([#233](https://github.com/can1357/oh-my-pi/issues/233))
+
+### Fixed
+
+- Fixed MCP OAuth discovery to honor `Mcp-Auth-Server` metadata and resolve authorization endpoints from the declared auth server, restoring Figma MCP login URLs with `client_id` ([#235](https://github.com/can1357/oh-my-pi/issues/235))
+
+## [13.5.3] - 2026-03-01
+
+### Added
+
+- Auto-include `ast_grep` and `ast_edit` tools when their text-based counterparts (`grep`, `edit`) are requested and the AST tools are enabled
+- Enforced tool decision in plan mode—agent now requires calling either `ask` or `exit_plan_mode` when a turn ends without a required tool call
+- Auto-correction of escaped tab indentation in edits (enabled by default, controllable via `PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS` environment variable)
+- Warning when suspicious Unicode escape placeholder `\uDDDD` is detected in edit content
+
+### Changed
+
+- Updated bash tool description to conditionally show `ast_grep` and `ast_edit` guidance based on tool availability in the session
+- Replaced timeout-based cancellation with AbortSignal-based cancellation in the `ask` tool for more reliable user interaction handling
+- Updated `ask` tool to distinguish between user-initiated cancellation and timeout-driven auto-selection, with only user cancellation aborting the turn
+- Updated hashline documentation to clarify that `\t` in JSON represents a real tab character, not a literal backslash-t sequence
+
+### Fixed
+
+- Fixed race condition in dialog overlay handling where multiple concurrent resolutions could occur
+- Cancelling the `ask` tool now aborts the current turn instead of returning a normal cancelled selection, while timeout-driven auto-cancel still returns without aborting
+
 ## [13.5.2] - 2026-03-01
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.5.2",
+	"version": "13.5.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.5.2",
-		"@oh-my-pi/pi-agent-core": "13.5.2",
-		"@oh-my-pi/pi-ai": "13.5.2",
-		"@oh-my-pi/pi-natives": "13.5.2",
-		"@oh-my-pi/pi-tui": "13.5.2",
-		"@oh-my-pi/pi-utils": "13.5.2",
+		"@oh-my-pi/omp-stats": "13.5.4",
+		"@oh-my-pi/pi-agent-core": "13.5.4",
+		"@oh-my-pi/pi-ai": "13.5.4",
+		"@oh-my-pi/pi-natives": "13.5.4",
+		"@oh-my-pi/pi-tui": "13.5.4",
+		"@oh-my-pi/pi-utils": "13.5.4",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/cli/agents-cli.ts

@@ -0,0 +1,138 @@
+/**
+ * Agents CLI command handlers.
+ *
+ * Handles `omp agents unpack` for writing bundled agent definitions to disk.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getAgentDir, getProjectDir, isEnoent } from "@oh-my-pi/pi-utils";
+import { YAML } from "bun";
+import chalk from "chalk";
+import { theme } from "../modes/theme/theme";
+import { loadBundledAgents } from "../task/agents";
+import type { AgentDefinition } from "../task/types";
+
+export type AgentsAction = "unpack";
+
+export interface AgentsCommandArgs {
+	action: AgentsAction;
+	flags: {
+		force?: boolean;
+		json?: boolean;
+		dir?: string;
+		user?: boolean;
+		project?: boolean;
+	};
+}
+
+interface UnpackResult {
+	targetDir: string;
+	total: number;
+	written: string[];
+	skipped: string[];
+}
+
+function writeStdout(line: string): void {
+	process.stdout.write(`${line}\n`);
+}
+
+function resolveTargetDir(flags: AgentsCommandArgs["flags"]): string {
+	if (flags.dir && flags.dir.trim().length > 0) {
+		return path.resolve(getProjectDir(), flags.dir.trim());
+	}
+
+	if (flags.user && flags.project) {
+		throw new Error("Choose either --user or --project, not both.");
+	}
+
+	if (flags.project) {
+		return path.resolve(getProjectDir(), ".omp", "agents");
+	}
+
+	return path.join(getAgentDir(), "agents");
+}
+
+function toFrontmatter(agent: AgentDefinition): Record<string, unknown> {
+	const frontmatter: Record<string, unknown> = {
+		name: agent.name,
+		description: agent.description,
+	};
+
+	if (agent.tools && agent.tools.length > 0) frontmatter.tools = agent.tools;
+	if (agent.spawns !== undefined) frontmatter.spawns = agent.spawns;
+	if (agent.model && agent.model.length > 0) frontmatter.model = agent.model;
+	if (agent.thinkingLevel) frontmatter["thinking-level"] = agent.thinkingLevel;
+	if (agent.output !== undefined) frontmatter.output = agent.output;
+	if (agent.blocking) frontmatter.blocking = true;
+
+	return frontmatter;
+}
+
+function serializeAgent(agent: AgentDefinition): string {
+	const frontmatter = YAML.stringify(toFrontmatter(agent), null, 2).trimEnd();
+	const body = agent.systemPrompt.trim();
+	return `---\n${frontmatter}\n---\n\n${body}\n`;
+}
+
+async function unpackBundledAgents(flags: AgentsCommandArgs["flags"]): Promise<UnpackResult> {
+	const targetDir = resolveTargetDir(flags);
+	await fs.mkdir(targetDir, { recursive: true });
+
+	const bundledAgents = [...loadBundledAgents()].sort((a, b) => a.name.localeCompare(b.name));
+	const written: string[] = [];
+	const skipped: string[] = [];
+
+	for (const agent of bundledAgents) {
+		const filePath = path.join(targetDir, `${agent.name}.md`);
+		if (!flags.force) {
+			try {
+				await fs.stat(filePath);
+				skipped.push(filePath);
+				continue;
+			} catch (error) {
+				if (!isEnoent(error)) throw error;
+			}
+		}
+
+		await Bun.write(filePath, serializeAgent(agent));
+		written.push(filePath);
+	}
+
+	return {
+		targetDir,
+		total: bundledAgents.length,
+		written,
+		skipped,
+	};
+}
+
+export async function runAgentsCommand(cmd: AgentsCommandArgs): Promise<void> {
+	switch (cmd.action) {
+		case "unpack": {
+			const result = await unpackBundledAgents(cmd.flags);
+			if (cmd.flags.json) {
+				writeStdout(JSON.stringify(result, null, 2));
+				return;
+			}
+
+			writeStdout(chalk.bold(`Bundled agents: ${result.total}`));
+			writeStdout(chalk.dim(`Target directory: ${result.targetDir}`));
+			writeStdout(chalk.green(`${theme.status.success} Written: ${result.written.length}`));
+			if (result.skipped.length > 0) {
+				writeStdout(
+					chalk.yellow(
+						`${theme.status.warning} Skipped existing: ${result.skipped.length} (use --force to overwrite)`,
+					),
+				);
+			}
+
+			for (const filePath of result.written) {
+				writeStdout(chalk.dim(`  + ${filePath}`));
+			}
+			for (const filePath of result.skipped) {
+				writeStdout(chalk.dim(`  = ${filePath}`));
+			}
+			return;
+		}
+	}
+}

package/src/cli/args.ts

@@ -247,7 +247,10 @@ ${chalk.bold("Available Tools (all enabled by default):")}
   fetch      - Fetch and process URLs
   web_search - Search the web
   ask        - Ask user questions (interactive mode only)
-`;
+
+${chalk.bold("Useful Commands:")}
+  omp agents unpack           - Export bundled subagents to ~/.omp/agent/agents (default)
+  omp agents unpack --project - Export bundled subagents to ./.omp/agents`;
 }
 
 export function printHelp(): void {

package/src/cli.ts

@@ -16,6 +16,7 @@ process.title = APP_NAME;
 
 const commands: CommandEntry[] = [
 	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
+	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
 	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
 	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },

package/src/commands/agents.ts

@@ -0,0 +1,57 @@
+/**
+ * Manage bundled task agents.
+ */
+import { Args, Command, Flags, renderCommandHelp } from "@oh-my-pi/pi-utils/cli";
+import { type AgentsAction, type AgentsCommandArgs, runAgentsCommand } from "../cli/agents-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: AgentsAction[] = ["unpack"];
+
+export default class Agents extends Command {
+	static description = "Manage bundled task agents";
+
+	static args = {
+		action: Args.string({
+			description: "Agents action",
+			required: false,
+			options: ACTIONS,
+		}),
+	};
+
+	static flags = {
+		force: Flags.boolean({ char: "f", description: "Overwrite existing agent files" }),
+		json: Flags.boolean({ description: "Output JSON" }),
+		dir: Flags.string({ description: "Output directory (overrides --user/--project)" }),
+		user: Flags.boolean({ description: "Write to ~/.omp/agent/agents (default)" }),
+		project: Flags.boolean({ description: "Write to ./.omp/agents" }),
+	};
+
+	static examples = [
+		"# Export bundled agents into user config (default)\n  omp agents unpack",
+		"# Export bundled agents into project config\n  omp agents unpack --project",
+		"# Overwrite existing local agent files\n  omp agents unpack --project --force",
+		"# Export into a custom directory\n  omp agents unpack --dir ./tmp/agents --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Agents);
+		if (!args.action) {
+			renderCommandHelp("omp", "agents", Agents);
+			return;
+		}
+
+		const cmd: AgentsCommandArgs = {
+			action: args.action as AgentsAction,
+			flags: {
+				force: flags.force,
+				json: flags.json,
+				dir: flags.dir,
+				user: flags.user,
+				project: flags.project,
+			},
+		};
+
+		await initTheme();
+		await runAgentsCommand(cmd);
+	}
+}

package/src/config/prompt-templates.ts

@@ -255,7 +255,8 @@ handlebars.registerHelper("SECTION_SEPERATOR", (name: unknown): string => sectio
  */
 function formatHashlineRef(lineNum: unknown, content: unknown): { num: number; text: string; ref: string } {
 	const num = typeof lineNum === "number" ? lineNum : Number.parseInt(String(lineNum), 10);
-	const text = typeof content === "string" ? content : String(content ?? "");
+	const raw = typeof content === "string" ? content : String(content ?? "");
+	const text = raw.replace(/\\t/g, "\t").replace(/\\n/g, "\n").replace(/\\r/g, "\r");
 	const ref = `${num}#${computeLineHash(num, text)}`;
 	return { num, text, ref };
 }

package/src/exa/mcp-client.ts

@@ -16,6 +16,61 @@ export function findApiKey(): string | null {
 	return $env.EXA_API_KEY;
 }
 
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (typeof value !== "object" || value === null) return null;
+	return value as Record<string, unknown>;
+}
+
+function parseJsonContent(text: string): unknown | null {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Normalize tools/call payloads across MCP servers.
+ *
+ * Exa currently returns different shapes depending on deployment/environment:
+ * - direct payload in result
+ * - structured payload under result.structuredContent / result.data / result.result
+ * - JSON payload embedded as text in result.content[]
+ */
+function normalizeMcpToolPayload(payload: unknown): unknown {
+	const candidates: unknown[] = [];
+	const root = asRecord(payload);
+
+	if (root) {
+		if (root.structuredContent !== undefined) candidates.push(root.structuredContent);
+		if (root.data !== undefined) candidates.push(root.data);
+		if (root.result !== undefined) candidates.push(root.result);
+		candidates.push(root);
+
+		const content = root.content;
+		if (Array.isArray(content)) {
+			for (const item of content) {
+				const part = asRecord(item);
+				if (!part) continue;
+				const text = part.text;
+				if (typeof text !== "string" || text.trim().length === 0) continue;
+				const parsed = parseJsonContent(text);
+				if (parsed !== null) candidates.push(parsed);
+			}
+		}
+	} else {
+		candidates.push(payload);
+	}
+
+	for (const candidate of candidates) {
+		if (isSearchResponse(candidate)) {
+			return candidate;
+		}
+	}
+
+	return payload;
+}
+
 /** Fetch available tools from Exa MCP */
 export async function fetchExaTools(apiKey: string | null, toolNames: string[]): Promise<MCPTool[]> {
 	const params = new URLSearchParams();
@@ -65,7 +120,7 @@ export async function callExaTool(
 		throw new Error(`MCP error: ${response.error.message}`);
 	}
 
-	return response.result;
+	return normalizeMcpToolPayload(response.result);
 }
 
 /** Call a tool on Websets MCP */
@@ -85,7 +140,7 @@ export async function callWebsetsTool(
 		throw new Error(`MCP error: ${response.error.message}`);
 	}
 
-	return response.result;
+	return normalizeMcpToolPayload(response.result);
 }
 
 /** Format search results for LLM */

package/src/mcp/oauth-discovery.ts

@@ -16,9 +16,25 @@ export interface AuthDetectionResult {
 	requiresAuth: boolean;
 	authType?: "oauth" | "apikey" | "unknown";
 	oauth?: OAuthEndpoints;
+	authServerUrl?: string;
 	message?: string;
 }
 
+function parseMcpAuthServerUrl(errorMessage: string): string | undefined {
+	const match = errorMessage.match(/Mcp-Auth-Server:\s*([^;\]\s]+)/i);
+	if (!match || !match[1]) return undefined;
+
+	try {
+		return new URL(match[1]).toString();
+	} catch {
+		return undefined;
+	}
+}
+
+export function extractMcpAuthServerUrl(error: Error): string | undefined {
+	return parseMcpAuthServerUrl(error.message);
+}
+
 /**
  * Detect if an error indicates authentication is required.
  * Checks for common auth error patterns.
@@ -178,6 +194,8 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
 		return { requiresAuth: false };
 	}
 
+	const authServerUrl = extractMcpAuthServerUrl(error);
+
 	// Try to extract OAuth endpoints
 	const oauth = extractOAuthEndpoints(error);
 
@@ -186,6 +204,7 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
 			requiresAuth: true,
 			authType: "oauth",
 			oauth,
+			authServerUrl,
 			message: "Server requires OAuth authentication. Launching authorization flow...",
 		};
 	}
@@ -201,6 +220,7 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
 		return {
 			requiresAuth: true,
 			authType: "apikey",
+			authServerUrl,
 			message: "Server requires API key authentication.",
 		};
 	}
@@ -209,6 +229,7 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
 	return {
 		requiresAuth: true,
 		authType: "unknown",
+		authServerUrl,
 		message: "Server requires authentication but type could not be determined.",
 	};
 }
@@ -217,56 +238,110 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
  * Try to discover OAuth endpoints by querying the server's well-known endpoints.
  * This is a fallback when error responses don't include OAuth metadata.
  */
-export async function discoverOAuthEndpoints(serverUrl: string): Promise<OAuthEndpoints | null> {
+export async function discoverOAuthEndpoints(
+	serverUrl: string,
+	authServerUrl?: string,
+): Promise<OAuthEndpoints | null> {
 	const wellKnownPaths = [
 		"/.well-known/oauth-authorization-server",
 		"/.well-known/openid-configuration",
+		"/.well-known/oauth-protected-resource",
 		"/oauth/metadata",
 		"/.mcp/auth",
 		"/authorize", // Some MCP servers expose OAuth config here
 	];
+	const urlsToQuery = [authServerUrl, serverUrl].filter((value): value is string => Boolean(value));
+	const visitedAuthServers = new Set<string>();
 
-	for (const path of wellKnownPaths) {
-		try {
-			const url = new URL(path, serverUrl);
-			const response = await fetch(url.toString(), {
-				method: "GET",
-				headers: { Accept: "application/json" },
-			});
+	const findEndpoints = (metadata: Record<string, unknown>): OAuthEndpoints | null => {
+		if (metadata.authorization_endpoint && metadata.token_endpoint) {
+			const scopesSupported = Array.isArray(metadata.scopes_supported)
+				? metadata.scopes_supported.filter((scope): scope is string => typeof scope === "string").join(" ")
+				: undefined;
+			return {
+				authorizationUrl: String(metadata.authorization_endpoint),
+				tokenUrl: String(metadata.token_endpoint),
+				clientId:
+					typeof metadata.client_id === "string"
+						? metadata.client_id
+						: typeof metadata.clientId === "string"
+							? metadata.clientId
+							: typeof metadata.default_client_id === "string"
+								? metadata.default_client_id
+								: typeof metadata.public_client_id === "string"
+									? metadata.public_client_id
+									: undefined,
+				scopes:
+					scopesSupported ||
+					(typeof metadata.scopes === "string"
+						? metadata.scopes
+						: typeof metadata.scope === "string"
+							? metadata.scope
+							: undefined),
+			};
+		}
 
-			if (response.ok) {
-				const metadata = (await response.json()) as Record<string, any>;
+		if (metadata.oauth || metadata.authorization || metadata.auth) {
+			const oauthData = (metadata.oauth || metadata.authorization || metadata.auth) as Record<string, unknown>;
+			if (typeof oauthData.authorization_url === "string" && typeof oauthData.token_url === "string") {
+				return {
+					authorizationUrl: oauthData.authorization_url || String(oauthData.authorizationUrl),
+					tokenUrl: oauthData.token_url || String(oauthData.tokenUrl),
+					clientId:
+						typeof oauthData.client_id === "string"
+							? oauthData.client_id
+							: typeof oauthData.clientId === "string"
+								? oauthData.clientId
+								: typeof oauthData.default_client_id === "string"
+									? oauthData.default_client_id
+									: typeof oauthData.public_client_id === "string"
+										? oauthData.public_client_id
+										: undefined,
+					scopes:
+						typeof oauthData.scopes === "string"
+							? oauthData.scopes
+							: typeof oauthData.scope === "string"
+								? oauthData.scope
+								: undefined,
+				};
+			}
+		}
 
-				// Check for standard OAuth discovery format
-				if (metadata.authorization_endpoint && metadata.token_endpoint) {
-					return {
-						authorizationUrl: metadata.authorization_endpoint,
-						tokenUrl: metadata.token_endpoint,
-						clientId:
-							metadata.client_id || metadata.clientId || metadata.default_client_id || metadata.public_client_id,
-						scopes: metadata.scopes_supported?.join(" ") || metadata.scopes || metadata.scope,
-					};
-				}
+		return null;
+	};
+
+	for (const baseUrl of urlsToQuery) {
+		visitedAuthServers.add(baseUrl);
+		for (const path of wellKnownPaths) {
+			try {
+				const url = new URL(path, baseUrl);
+				const response = await fetch(url.toString(), {
+					method: "GET",
+					headers: { Accept: "application/json" },
+				});
 
-				// Check for MCP-specific format
-				if (metadata.oauth || metadata.authorization || metadata.auth) {
-					const oauthData = metadata.oauth || metadata.authorization || metadata.auth;
-					if (oauthData.authorization_url && oauthData.token_url) {
-						return {
-							authorizationUrl: oauthData.authorization_url || oauthData.authorizationUrl,
-							tokenUrl: oauthData.token_url || oauthData.tokenUrl,
-							clientId:
-								oauthData.client_id ||
-								oauthData.clientId ||
-								oauthData.default_client_id ||
-								oauthData.public_client_id,
-							scopes: oauthData.scopes || oauthData.scope,
-						};
+				if (response.ok) {
+					const metadata = (await response.json()) as Record<string, unknown>;
+					const endpoints = findEndpoints(metadata);
+					if (endpoints) return endpoints;
+
+					if (path === "/.well-known/oauth-protected-resource") {
+						const authServers = Array.isArray(metadata.authorization_servers)
+							? metadata.authorization_servers.filter((entry): entry is string => typeof entry === "string")
+							: [];
+
+						for (const discoveredAuthServer of authServers) {
+							if (visitedAuthServers.has(discoveredAuthServer)) {
+								continue;
+							}
+							const discovered = await discoverOAuthEndpoints(serverUrl, discoveredAuthServer);
+							if (discovered) return discovered;
+						}
 					}
 				}
+			} catch {
+				// Ignore errors, try next path
 			}
-		} catch {
-			// Ignore errors, try next path
 		}
 	}
 

package/src/modes/components/mcp-add-wizard.ts

@@ -947,7 +947,7 @@ export class MCPAddWizard extends Container {
 				let oauth = authResult.authType === "oauth" ? (authResult.oauth ?? null) : null;
 				if (!oauth && this.#state.transport !== "stdio" && this.#state.url) {
 					try {
-						oauth = await discoverOAuthEndpoints(this.#state.url);
+						oauth = await discoverOAuthEndpoints(this.#state.url, authResult.authServerUrl);
 					} catch {
 						// Ignore discovery failures and fallback to manual auth.
 					}

package/src/modes/controllers/command-controller.ts

@@ -983,19 +983,6 @@ function resolveAggregateStatus(limits: UsageLimit[]): UsageLimit["status"] {
 	return "exhausted";
 }
 
-function isZeroUsage(limit: UsageLimit): boolean {
-	const amount = limit.amount;
-	if (amount.usedFraction !== undefined) return amount.usedFraction <= 0;
-	if (amount.used !== undefined) return amount.used <= 0;
-	if (amount.unit === "percent" && amount.used !== undefined) return amount.used <= 0;
-	if (amount.remainingFraction !== undefined) return amount.remainingFraction >= 1;
-	return false;
-}
-
-function isZeroUsageGroup(limits: UsageLimit[]): boolean {
-	return limits.length > 0 && limits.every(limit => isZeroUsage(limit));
-}
-
 function formatAggregateAmount(limits: UsageLimit[]): string {
 	const fractions = limits
 		.map(limit => resolveFraction(limit))
@@ -1117,13 +1104,6 @@ function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs
 			}
 		}
 
-		const providerAllZero = isZeroUsageGroup(Array.from(limitGroups.values()).flatMap(group => group.limits));
-		if (providerAllZero) {
-			const providerTitle = `${resolveStatusIcon("ok", uiTheme)} ${uiTheme.fg("accent", `${providerName} (0%)`)}`;
-			lines.push(uiTheme.bold(providerTitle));
-			continue;
-		}
-
 		lines.push(uiTheme.bold(uiTheme.fg("accent", providerName)));
 
 		for (const group of limitGroups.values()) {
@@ -1144,18 +1124,6 @@ function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs
 
 			const status = resolveAggregateStatus(sortedLimits);
 			const statusIcon = resolveStatusIcon(status, uiTheme);
-			if (isZeroUsageGroup(sortedLimits)) {
-				const resetText = resolveResetRange(sortedLimits, nowMs);
-				const resetSuffix = resetText ? ` | ${resetText}` : "";
-				const windowSuffix = formatWindowSuffix(group.label, group.windowLabel, uiTheme);
-				lines.push(
-					`${statusIcon} ${uiTheme.bold(group.label)} ${windowSuffix} ${uiTheme.fg(
-						"dim",
-						`0%${resetSuffix}`,
-					)}`.trim(),
-				);
-				continue;
-			}
 
 			const windowSuffix = formatWindowSuffix(group.label, group.windowLabel, uiTheme);
 			lines.push(`${statusIcon} ${uiTheme.bold(group.label)} ${windowSuffix}`.trim());