gsd-pi 2.17.0 → 2.19.0

package/packages/pi-coding-agent/src/core/models-json-writer.ts

@@ -0,0 +1,188 @@
+/**
+ * Safe read-modify-write for models.json with file locking.
+ * Prevents concurrent writes from corrupting the config file.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import lockfile from "proper-lockfile";
+import { getAgentDir } from "../config.js";
+
+interface ModelDefinition {
+	id: string;
+	name?: string;
+	api?: string;
+	baseUrl?: string;
+	reasoning?: boolean;
+	input?: ("text" | "image")[];
+	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
+	contextWindow?: number;
+	maxTokens?: number;
+}
+
+interface ProviderConfig {
+	baseUrl?: string;
+	apiKey?: string;
+	api?: string;
+	headers?: Record<string, string>;
+	authHeader?: boolean;
+	models?: ModelDefinition[];
+	modelOverrides?: Record<string, Record<string, unknown>>;
+}
+
+interface ModelsConfig {
+	providers: Record<string, ProviderConfig>;
+}
+
+export class ModelsJsonWriter {
+	private modelsJsonPath: string;
+
+	constructor(modelsJsonPath?: string) {
+		this.modelsJsonPath = modelsJsonPath ?? join(getAgentDir(), "models.json");
+	}
+
+	/**
+	 * Add a model to a provider. Creates the provider if it doesn't exist.
+	 */
+	addModel(provider: string, model: ModelDefinition, providerConfig?: Partial<ProviderConfig>): void {
+		this.withLock((config) => {
+			if (!config.providers[provider]) {
+				config.providers[provider] = {
+					...providerConfig,
+					models: [],
+				};
+			}
+
+			const providerEntry = config.providers[provider];
+			if (!providerEntry.models) {
+				providerEntry.models = [];
+			}
+
+			// Replace existing model with same id, or append
+			const existingIndex = providerEntry.models.findIndex((m) => m.id === model.id);
+			if (existingIndex >= 0) {
+				providerEntry.models[existingIndex] = model;
+			} else {
+				providerEntry.models.push(model);
+			}
+
+			return config;
+		});
+	}
+
+	/**
+	 * Remove a model from a provider. Removes the provider if no models remain.
+	 */
+	removeModel(provider: string, modelId: string): void {
+		this.withLock((config) => {
+			const providerEntry = config.providers[provider];
+			if (!providerEntry?.models) return config;
+
+			providerEntry.models = providerEntry.models.filter((m) => m.id !== modelId);
+
+			// Clean up empty provider (no models and no overrides)
+			if (providerEntry.models.length === 0 && !providerEntry.modelOverrides) {
+				delete config.providers[provider];
+			}
+
+			return config;
+		});
+	}
+
+	/**
+	 * Set or update an entire provider configuration.
+	 */
+	setProvider(provider: string, providerConfig: ProviderConfig): void {
+		this.withLock((config) => {
+			config.providers[provider] = providerConfig;
+			return config;
+		});
+	}
+
+	/**
+	 * Remove a provider and all its models.
+	 */
+	removeProvider(provider: string): void {
+		this.withLock((config) => {
+			delete config.providers[provider];
+			return config;
+		});
+	}
+
+	/**
+	 * List all providers and their configurations.
+	 */
+	listProviders(): ModelsConfig {
+		return this.readConfig();
+	}
+
+	private readConfig(): ModelsConfig {
+		if (!existsSync(this.modelsJsonPath)) {
+			return { providers: {} };
+		}
+		try {
+			const content = readFileSync(this.modelsJsonPath, "utf-8");
+			return JSON.parse(content) as ModelsConfig;
+		} catch {
+			return { providers: {} };
+		}
+	}
+
+	private writeConfig(config: ModelsConfig): void {
+		const dir = dirname(this.modelsJsonPath);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		writeFileSync(this.modelsJsonPath, JSON.stringify(config, null, 2), "utf-8");
+	}
+
+	private acquireLockWithRetry(): () => void {
+		const maxAttempts = 10;
+		const delayMs = 20;
+		let lastError: unknown;
+
+		// Ensure file exists for locking
+		const dir = dirname(this.modelsJsonPath);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		if (!existsSync(this.modelsJsonPath)) {
+			writeFileSync(this.modelsJsonPath, JSON.stringify({ providers: {} }, null, 2), "utf-8");
+		}
+
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			try {
+				return lockfile.lockSync(this.modelsJsonPath, { realpath: false });
+			} catch (error) {
+				const code =
+					typeof error === "object" && error !== null && "code" in error
+						? String((error as { code?: unknown }).code)
+						: undefined;
+				if (code !== "ELOCKED" || attempt === maxAttempts) {
+					throw error;
+				}
+				lastError = error;
+				const start = Date.now();
+				while (Date.now() - start < delayMs) {
+					// Busy-wait (same pattern as auth-storage.ts)
+				}
+			}
+		}
+
+		throw (lastError as Error) ?? new Error("Failed to acquire models.json lock");
+	}
+
+	private withLock(fn: (config: ModelsConfig) => ModelsConfig): void {
+		let release: (() => void) | undefined;
+		try {
+			release = this.acquireLockWithRetry();
+			const config = this.readConfig();
+			const updated = fn(config);
+			this.writeConfig(updated);
+		} finally {
+			if (release) {
+				release();
+			}
+		}
+	}
+}

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -79,6 +79,13 @@ export interface FallbackSettings {
 	chains?: Record<string, FallbackChainEntry[]>; // keyed by chain name
 }
 
+export interface ModelDiscoverySettings {
+	enabled?: boolean; // default: false
+	providers?: string[]; // limit discovery to specific providers
+	ttlMinutes?: number; // override default TTLs (in minutes)
+	autoRefreshOnModelSelect?: boolean; // default: false - refresh discovery when opening model selector
+}
+
 export type TransportSetting = Transport;
 
 /**
@@ -134,6 +141,7 @@ export interface Settings {
 	bashInterceptor?: BashInterceptorSettings;
 	taskIsolation?: TaskIsolationSettings;
 	fallback?: FallbackSettings;
+	modelDiscovery?: ModelDiscoverySettings;
 }
 
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -1076,4 +1084,17 @@ export class SettingsManager {
 			chains: this.getFallbackChains(),
 		};
 	}
+
+	getModelDiscoverySettings(): ModelDiscoverySettings {
+		return this.settings.modelDiscovery ?? {};
+	}
+
+	setModelDiscoveryEnabled(enabled: boolean): void {
+		if (!this.globalSettings.modelDiscovery) {
+			this.globalSettings.modelDiscovery = {};
+		}
+		this.globalSettings.modelDiscovery.enabled = enabled;
+		this.markModified("modelDiscovery", "enabled");
+		this.save();
+	}
 }

package/packages/pi-coding-agent/src/core/slash-commands.ts

@@ -28,6 +28,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	{ name: "hotkeys", description: "Show all keyboard shortcuts" },
 	{ name: "fork", description: "Create a new fork from a previous message" },
 	{ name: "tree", description: "Navigate session tree (switch branches)" },
+	{ name: "provider", description: "Manage provider configuration" },
 	{ name: "login", description: "Login with OAuth provider" },
 	{ name: "logout", description: "Logout from OAuth provider" },
 	{ name: "new", description: "Start a new session" },

package/packages/pi-coding-agent/src/index.ts

@@ -143,7 +143,11 @@ export {
 // Footer data provider (git branch + extension statuses - data not otherwise available to extensions)
 export type { ReadonlyFooterDataProvider } from "./core/footer-data-provider.js";
 export { convertToLlm } from "./core/messages.js";
+export { ModelDiscoveryCache } from "./core/discovery-cache.js";
+export type { DiscoveredModel, DiscoveryResult, ProviderDiscoveryAdapter } from "./core/model-discovery.js";
+export { getDiscoverableProviders, getDiscoveryAdapter } from "./core/model-discovery.js";
 export { ModelRegistry } from "./core/model-registry.js";
+export { ModelsJsonWriter } from "./core/models-json-writer.js";
 export type {
 	PackageManager,
 	PathMetadata,
@@ -307,6 +311,7 @@ export {
 	LoginDialogComponent,
 	ModelSelectorComponent,
 	OAuthSelectorComponent,
+	ProviderManagerComponent,
 	type RenderDiffOptions,
 	rawKeyHint,
 	renderDiff,

package/packages/pi-coding-agent/src/main.ts

@@ -11,7 +11,7 @@ import { createInterface } from "readline";
 import { type Args, parseArgs, printHelp } from "./cli/args.js";
 import { selectConfig } from "./cli/config-selector.js";
 import { processFileArguments } from "./cli/file-processor.js";
-import { listModels } from "./cli/list-models.js";
+import { discoverAndPrintModels, listModels } from "./cli/list-models.js";
 import { selectSession } from "./cli/session-picker.js";
 import { APP_NAME, getAgentDir, getModelsPath, VERSION } from "./config.js";
 import { AuthStorage } from "./core/auth-storage.js";
@@ -660,9 +660,26 @@ export async function main(args: string[]) {
 		process.exit(0);
 	}
 
+	if (parsed.addProvider) {
+		const { ModelsJsonWriter } = await import("./core/models-json-writer.js");
+		const writer = new ModelsJsonWriter();
+		writer.setProvider(parsed.addProvider, {
+			baseUrl: parsed.addProviderBaseUrl,
+			apiKey: parsed.apiKey,
+		});
+		console.log(`Provider "${parsed.addProvider}" added to models.json`);
+		process.exit(0);
+	}
+
+	if (parsed.discoverModels !== undefined) {
+		const provider = typeof parsed.discoverModels === "string" ? parsed.discoverModels : undefined;
+		await discoverAndPrintModels(modelRegistry, provider);
+		process.exit(0);
+	}
+
 	if (parsed.listModels !== undefined) {
 		const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-		await listModels(modelRegistry, searchPattern);
+		await listModels(modelRegistry, { searchPattern, discover: parsed.discover });
 		process.exit(0);
 	}
 

package/packages/pi-coding-agent/src/modes/interactive/components/index.ts

@@ -18,6 +18,7 @@ export { appKey, appKeyHint, editorKey, keyHint, rawKeyHint } from "./keybinding
 export { LoginDialogComponent } from "./login-dialog.js";
 export { ModelSelectorComponent } from "./model-selector.js";
 export { OAuthSelectorComponent } from "./oauth-selector.js";
+export { ProviderManagerComponent } from "./provider-manager.js";
 export { type ModelsCallbacks, type ModelsConfig, ScopedModelsSelectorComponent } from "./scoped-models-selector.js";
 export { SessionSelectorComponent } from "./session-selector.js";
 export { type SettingsCallbacks, type SettingsConfig, SettingsSelectorComponent } from "./settings-selector.js";

package/packages/pi-coding-agent/src/modes/interactive/components/model-selector.ts

@@ -160,7 +160,7 @@ export class ModelSelectorComponent extends Container implements Focusable {
 
 		// Load available models (built-in models still work even if models.json failed)
 		try {
-			const availableModels = await this.modelRegistry.getAvailable();
+			const availableModels = this.modelRegistry.getAvailable();
 			models = availableModels.map((model: Model<any>) => ({
 				provider: model.provider,
 				id: model.id,

package/packages/pi-coding-agent/src/modes/interactive/components/provider-manager.ts

@@ -0,0 +1,163 @@
+/**
+ * TUI component for managing provider configurations.
+ * Shows providers with auth status, discovery support, and model counts.
+ */
+
+import {
+	Container,
+	type Focusable,
+	getEditorKeybindings,
+	Spacer,
+	Text,
+	type TUI,
+} from "@gsd/pi-tui";
+import type { AuthStorage } from "../../../core/auth-storage.js";
+import { getDiscoverableProviders } from "../../../core/model-discovery.js";
+import type { ModelRegistry } from "../../../core/model-registry.js";
+import { theme } from "../theme/theme.js";
+import { rawKeyHint } from "./keybinding-hints.js";
+
+interface ProviderInfo {
+	name: string;
+	hasAuth: boolean;
+	supportsDiscovery: boolean;
+	modelCount: number;
+}
+
+export class ProviderManagerComponent extends Container implements Focusable {
+	private _focused = false;
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+	}
+
+	private providers: ProviderInfo[] = [];
+	private selectedIndex = 0;
+	private listContainer: Container;
+	private tui: TUI;
+	private authStorage: AuthStorage;
+	private modelRegistry: ModelRegistry;
+	private onDone: () => void;
+	private onDiscover: (provider: string) => void;
+
+	constructor(
+		tui: TUI,
+		authStorage: AuthStorage,
+		modelRegistry: ModelRegistry,
+		onDone: () => void,
+		onDiscover: (provider: string) => void,
+	) {
+		super();
+
+		this.tui = tui;
+		this.authStorage = authStorage;
+		this.modelRegistry = modelRegistry;
+		this.onDone = onDone;
+		this.onDiscover = onDiscover;
+
+		// Header
+		this.addChild(new Text(theme.fg("accent", "Provider Manager"), 0, 0));
+		this.addChild(new Spacer(1));
+
+		// Hints
+		const hints = [
+			rawKeyHint("d", "discover"),
+			rawKeyHint("r", "remove auth"),
+			rawKeyHint("esc", "close"),
+		].join("  ");
+		this.addChild(new Text(hints, 0, 0));
+		this.addChild(new Spacer(1));
+
+		// List
+		this.listContainer = new Container();
+		this.addChild(this.listContainer);
+
+		this.loadProviders();
+		this.updateList();
+	}
+
+	private loadProviders(): void {
+		const discoverableSet = new Set(getDiscoverableProviders());
+		const allModels = this.modelRegistry.getAll();
+
+		// Group models by provider
+		const providerModelCounts = new Map<string, number>();
+		for (const model of allModels) {
+			providerModelCounts.set(model.provider, (providerModelCounts.get(model.provider) ?? 0) + 1);
+		}
+
+		// Build provider list from all known providers
+		const providerNames = new Set([
+			...providerModelCounts.keys(),
+			...discoverableSet,
+		]);
+
+		this.providers = Array.from(providerNames)
+			.sort()
+			.map((name) => ({
+				name,
+				hasAuth: this.authStorage.hasAuth(name),
+				supportsDiscovery: discoverableSet.has(name),
+				modelCount: providerModelCounts.get(name) ?? 0,
+			}));
+	}
+
+	private updateList(): void {
+		this.listContainer.clear();
+
+		for (let i = 0; i < this.providers.length; i++) {
+			const p = this.providers[i];
+			const isSelected = i === this.selectedIndex;
+
+			const authBadge = p.hasAuth ? theme.fg("success", "[auth]") : theme.fg("muted", "[no auth]");
+			const discoveryBadge = p.supportsDiscovery ? theme.fg("accent", "[discovery]") : "";
+			const countBadge = theme.fg("muted", `(${p.modelCount} models)`);
+
+			const prefix = isSelected ? theme.fg("accent", "> ") : "  ";
+			const nameText = isSelected ? theme.fg("accent", p.name) : p.name;
+
+			const parts = [prefix, nameText, " ", authBadge];
+			if (discoveryBadge) parts.push(" ", discoveryBadge);
+			parts.push(" ", countBadge);
+
+			this.listContainer.addChild(new Text(parts.join(""), 0, 0));
+		}
+
+		if (this.providers.length === 0) {
+			this.listContainer.addChild(new Text(theme.fg("muted", "  No providers configured"), 0, 0));
+		}
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getEditorKeybindings();
+
+		if (kb.matches(keyData, "selectUp")) {
+			if (this.providers.length === 0) return;
+			this.selectedIndex = this.selectedIndex === 0 ? this.providers.length - 1 : this.selectedIndex - 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "selectDown")) {
+			if (this.providers.length === 0) return;
+			this.selectedIndex = this.selectedIndex === this.providers.length - 1 ? 0 : this.selectedIndex + 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "selectCancel")) {
+			this.onDone();
+		} else if (keyData === "d" || keyData === "D") {
+			const provider = this.providers[this.selectedIndex];
+			if (provider?.supportsDiscovery) {
+				this.onDiscover(provider.name);
+			}
+		} else if (keyData === "r" || keyData === "R") {
+			const provider = this.providers[this.selectedIndex];
+			if (provider?.hasAuth) {
+				this.authStorage.remove(provider.name);
+				this.loadProviders();
+				this.updateList();
+				this.tui.requestRender();
+			}
+		}
+	}
+}

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -83,6 +83,7 @@ import { appKey, appKeyHint, editorKey, formatKeyForDisplay, keyHint, rawKeyHint
 import { LoginDialogComponent } from "./components/login-dialog.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
 import { OAuthSelectorComponent } from "./components/oauth-selector.js";
+import { ProviderManagerComponent } from "./components/provider-manager.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SelectSubmenu, SettingsSelectorComponent, THINKING_DESCRIPTIONS } from "./components/settings-selector.js";
@@ -1997,6 +1998,11 @@ export class InteractiveMode {
 				this.editor.setText("");
 				return;
 			}
+			if (text === "/provider") {
+				this.showProviderManager();
+				this.editor.setText("");
+				return;
+			}
 			if (text === "/login") {
 				this.showOAuthSelector("login");
 				this.editor.setText("");
@@ -3746,6 +3752,37 @@ export class InteractiveMode {
 		this.showStatus("Resumed session");
 	}
 
+	private showProviderManager(): void {
+		this.showSelector((done) => {
+			const component = new ProviderManagerComponent(
+				this.ui,
+				this.session.modelRegistry.authStorage,
+				this.session.modelRegistry,
+				() => {
+					done();
+					this.ui.requestRender();
+				},
+				async (provider: string) => {
+					this.showStatus(`Discovering models for ${provider}...`);
+					try {
+						const results = await this.session.modelRegistry.discoverModels([provider]);
+						const result = results[0];
+						if (result?.error) {
+							this.showError(`Discovery failed: ${result.error}`);
+						} else {
+							this.showStatus(`Discovered ${result?.models.length ?? 0} models from ${provider}`);
+						}
+					} catch (error) {
+						this.showError(error instanceof Error ? error.message : String(error));
+					}
+					done();
+					this.ui.requestRender();
+				},
+			);
+			return { component, focus: component };
+		});
+	}
+
 	private async showOAuthSelector(mode: "login" | "logout"): Promise<void> {
 		if (mode === "logout") {
 			const providers = this.session.modelRegistry.authStorage.list();

package/src/resources/extensions/gsd/activity-log.ts

@@ -8,7 +8,7 @@
  * Diagnostic extraction is handled by session-forensics.ts.
  */
 
-import { writeFileSync, mkdirSync, readdirSync, unlinkSync, statSync, openSync, closeSync, constants } from "node:fs";
+import { writeFileSync, writeSync, mkdirSync, readdirSync, unlinkSync, statSync, openSync, closeSync, constants } from "node:fs";
 import { createHash } from "node:crypto";
 import { join } from "node:path";
 
@@ -23,6 +23,15 @@ interface ActivityLogState {
 
 const activityLogState = new Map<string, ActivityLogState>();
 
+/**
+ * Clear accumulated activity log state (#611).
+ * Call when auto-mode stops to prevent unbounded memory growth
+ * from lastSnapshotKeyByUnit maps accumulating across units.
+ */
+export function clearActivityLogState(): void {
+  activityLogState.clear();
+}
+
 function scanNextSequence(activityDir: string): number {
   let maxSeq = 0;
   try {
@@ -46,9 +55,21 @@ function getActivityState(activityDir: string): ActivityLogState {
   return state;
 }
 
-function snapshotKey(unitType: string, unitId: string, content: string): string {
-  const digest = createHash("sha1").update(content).digest("hex");
-  return `${unitType}\0${unitId}\0${digest}`;
+/**
+ * Build a lightweight dedup key from session entries without serializing
+ * the entire content to a string (#611). Uses entry count + hash of
+ * the last few entries as a fingerprint instead of hashing megabytes.
+ */
+function snapshotKey(unitType: string, unitId: string, entries: unknown[]): string {
+  const hash = createHash("sha1");
+  hash.update(`${unitType}\0${unitId}\0${entries.length}\0`);
+  // Hash only the last 3 entries as a fingerprint — if the session grew,
+  // the count change alone detects it; if content changed, the tail hash catches it.
+  const tail = entries.slice(-3);
+  for (const entry of tail) {
+    hash.update(JSON.stringify(entry));
+  }
+  return hash.digest("hex");
 }
 
 function nextActivityFilePath(
@@ -91,14 +112,23 @@ export function saveActivityLog(
     mkdirSync(activityDir, { recursive: true });
 
     const safeUnitId = unitId.replace(/\//g, "-");
-    const content = `${entries.map(entry => JSON.stringify(entry)).join("\n")}\n`;
     const state = getActivityState(activityDir);
     const unitKey = `${unitType}\0${safeUnitId}`;
-    const key = snapshotKey(unitType, safeUnitId, content);
+    // Use lightweight fingerprint instead of serializing all entries (#611)
+    const key = snapshotKey(unitType, safeUnitId, entries);
     if (state.lastSnapshotKeyByUnit.get(unitKey) === key) return;
 
     const filePath = nextActivityFilePath(activityDir, state, unitType, safeUnitId);
-    writeFileSync(filePath, content, "utf-8");
+    // Stream entries to disk line-by-line instead of building one massive string (#611).
+    // For large sessions, the single-string approach allocated hundreds of MB.
+    const fd = openSync(filePath, "w");
+    try {
+      for (const entry of entries) {
+        writeSync(fd, JSON.stringify(entry) + "\n");
+      }
+    } finally {
+      closeSync(fd);
+    }
     state.nextSeq += 1;
     state.lastSnapshotKeyByUnit.set(unitKey, key);
   } catch (e) {

package/src/resources/extensions/gsd/auto-dashboard.ts

@@ -10,7 +10,7 @@ import type { ExtensionContext, ExtensionCommandContext } from "@gsd/pi-coding-a
 import type { GSDState } from "./types.js";
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
-import { getLedger, getProjectTotals, formatCost, formatTokenCount } from "./metrics.js";
+import { getLedger, getProjectTotals, formatCost, formatTokenCount, formatTierSavings } from "./metrics.js";
 import {
   resolveMilestoneFile,
   resolveSliceFile,
@@ -39,6 +39,8 @@ export interface AutoDashboardData {
   projectedRemainingCost?: number;
   /** Whether token profile has been auto-downgraded due to budget prediction */
   profileDowngraded?: boolean;
+  /** Number of pending captures awaiting triage (0 if none or file missing) */
+  pendingCaptureCount: number;
 }
 
 // ─── Unit Description Helpers ─────────────────────────────────────────────────
@@ -239,6 +241,7 @@ export function updateProgressWidget(
   unitId: string,
   state: GSDState,
   accessors: WidgetStateAccessors,
+  tierBadge?: string,
 ): void {
   if (!ctx.hasUI) return;
 
@@ -319,7 +322,8 @@ export function updateProgressWidget(
 
         const target = task ? `${task.id}: ${task.title}` : unitId;
         const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
-        const phaseBadge = theme.fg("dim", phaseLabel);
+        const tierTag = tierBadge ? theme.fg("dim", `[${tierBadge}] `) : "";
+        const phaseBadge = `${tierTag}${theme.fg("dim", phaseLabel)}`;
         lines.push(rightAlign(actionLeft, phaseBadge, width));
         lines.push("");
 
@@ -414,6 +418,14 @@ export function updateProgressWidget(
             ? `${modelPhase}${theme.fg("dim", modelDisplay)}`
             : "";
           lines.push(rightAlign(`${pad}${sLeft}`, sRight, width));
+
+          // Dynamic routing savings summary
+          if (mLedger && mLedger.units.some(u => u.tier)) {
+            const savings = formatTierSavings(mLedger.units);
+            if (savings) {
+              lines.push(truncateToWidth(theme.fg("dim", `${pad}${savings}`), width));
+            }
+          }
         }
 
         const hintParts: string[] = [];