gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.eaa4973bc

package/packages/pi-coding-agent/src/core/extensions/extension-registry.ts

@@ -0,0 +1,222 @@
+/**
+ * Extension Registry — manages manifest reading, registry persistence, and enable/disable state.
+ *
+ * Extensions without manifests always load (backwards compatible).
+ * A fresh install has an empty registry — all extensions enabled by default.
+ * The only way an extension stops loading is an explicit `gsd extensions disable <id>`.
+ */
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { getAgentDir } from "../../config.js";
+import { dirname, join } from "node:path";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface ExtensionManifest {
+  id: string;
+  name: string;
+  version: string;
+  description: string;
+  tier: "core" | "bundled" | "community";
+  requires: { platform: string };
+  provides?: {
+    tools?: string[];
+    commands?: string[];
+    hooks?: string[];
+    shortcuts?: string[];
+  };
+  dependencies?: {
+    extensions?: string[];
+    runtime?: string[];
+  };
+}
+
+export interface ExtensionRegistryEntry {
+  id: string;
+  enabled: boolean;
+  source: "bundled" | "user" | "project";
+  disabledAt?: string;
+  disabledReason?: string;
+  version?: string;           // From manifest, used for semver comparison
+  installedFrom?: string;     // Original specifier: npm package name, git URL, or local path
+  installType?: "npm" | "git" | "local";  // Explicit source type
+}
+
+export interface ExtensionRegistry {
+  version: 1;
+  entries: Record<string, ExtensionRegistryEntry>;
+}
+
+// ─── Validation ─────────────────────────────────────────────────────────────
+
+function isRegistry(data: unknown): data is ExtensionRegistry {
+  if (typeof data !== "object" || data === null) return false;
+  const obj = data as Record<string, unknown>;
+  return obj.version === 1 && typeof obj.entries === "object" && obj.entries !== null;
+}
+
+function isManifest(data: unknown): data is ExtensionManifest {
+  if (typeof data !== "object" || data === null) return false;
+  const obj = data as Record<string, unknown>;
+  return (
+    typeof obj.id === "string" &&
+    typeof obj.name === "string" &&
+    typeof obj.version === "string" &&
+    typeof obj.tier === "string"
+  );
+}
+
+// ─── Registry Path ──────────────────────────────────────────────────────────
+
+export function getRegistryPath(): string {
+  return join(dirname(getAgentDir()), "extensions", "registry.json");
+}
+
+// ─── Registry I/O ───────────────────────────────────────────────────────────
+
+function defaultRegistry(): ExtensionRegistry {
+  return { version: 1, entries: {} };
+}
+
+export function loadRegistry(): ExtensionRegistry {
+  const filePath = getRegistryPath();
+  try {
+    if (!existsSync(filePath)) return defaultRegistry();
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return isRegistry(parsed) ? parsed : defaultRegistry();
+  } catch {
+    return defaultRegistry();
+  }
+}
+
+export function saveRegistry(registry: ExtensionRegistry): void {
+  const filePath = getRegistryPath();
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const tmp = filePath + ".tmp";
+    writeFileSync(tmp, JSON.stringify(registry, null, 2), "utf-8");
+    renameSync(tmp, filePath);
+  } catch {
+    // Non-fatal — don't let persistence failures break operation
+  }
+}
+
+// ─── Query ──────────────────────────────────────────────────────────────────
+
+/** Returns true if the extension is enabled (missing entries default to enabled). */
+export function isExtensionEnabled(registry: ExtensionRegistry, id: string): boolean {
+  const entry = registry.entries[id];
+  if (!entry) return true;
+  return entry.enabled;
+}
+
+// ─── Mutations ──────────────────────────────────────────────────────────────
+
+export function enableExtension(registry: ExtensionRegistry, id: string): void {
+  const entry = registry.entries[id];
+  if (entry) {
+    entry.enabled = true;
+    delete entry.disabledAt;
+    delete entry.disabledReason;
+  } else {
+    registry.entries[id] = { id, enabled: true, source: "bundled" };
+  }
+}
+
+/**
+ * Disable an extension. Returns an error string if the extension is core (cannot disable),
+ * or null on success.
+ */
+export function disableExtension(
+  registry: ExtensionRegistry,
+  id: string,
+  manifest: ExtensionManifest | null,
+  reason?: string,
+): string | null {
+  if (manifest?.tier === "core") {
+    return `Cannot disable "${id}" — it is a core extension.`;
+  }
+  const entry = registry.entries[id];
+  if (entry) {
+    entry.enabled = false;
+    entry.disabledAt = new Date().toISOString();
+    entry.disabledReason = reason;
+  } else {
+    registry.entries[id] = {
+      id,
+      enabled: false,
+      source: "bundled",
+      disabledAt: new Date().toISOString(),
+      disabledReason: reason,
+    };
+  }
+  return null;
+}
+
+// ─── Manifest Reading ───────────────────────────────────────────────────────
+
+/** Read extension-manifest.json from a directory. Returns null if missing or invalid. */
+export function readManifest(extensionDir: string): ExtensionManifest | null {
+  const manifestPath = join(extensionDir, "extension-manifest.json");
+  if (!existsSync(manifestPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    return isManifest(raw) ? raw : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Given an entry path (e.g. `.../extensions/browser-tools/index.ts`),
+ * resolve the parent directory and read its manifest.
+ */
+export function readManifestFromEntryPath(entryPath: string): ExtensionManifest | null {
+  const dir = dirname(entryPath);
+  return readManifest(dir);
+}
+
+// ─── Discovery ──────────────────────────────────────────────────────────────
+
+/** Scan all subdirectories of extensionsDir for manifests. Returns a Map<id, manifest>. */
+export function discoverAllManifests(extensionsDir: string): Map<string, ExtensionManifest> {
+  const manifests = new Map<string, ExtensionManifest>();
+  if (!existsSync(extensionsDir)) return manifests;
+
+  for (const entry of readdirSync(extensionsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const manifest = readManifest(join(extensionsDir, entry.name));
+    if (manifest) {
+      manifests.set(manifest.id, manifest);
+    }
+  }
+  return manifests;
+}
+
+/**
+ * Auto-populate registry entries for newly discovered extensions.
+ * Extensions already in the registry are left untouched.
+ */
+export function ensureRegistryEntries(extensionsDir: string): void {
+  const manifests = discoverAllManifests(extensionsDir);
+  if (manifests.size === 0) return;
+
+  const registry = loadRegistry();
+  let changed = false;
+
+  for (const [id, manifest] of manifests) {
+    if (!registry.entries[id]) {
+      registry.entries[id] = {
+        id,
+        enabled: true,
+        source: "bundled",
+      };
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    saveRegistry(registry);
+  }
+}

package/packages/pi-coding-agent/src/core/extensions/loader.ts

@@ -39,6 +39,8 @@ import { execCommand } from "../exec.js";
 import { getUntrustedExtensionPaths } from "./project-trust.js";
 export { isProjectTrusted, trustProject, getUntrustedExtensionPaths } from "./project-trust.js";
 import { registerToolCompatibility } from "../tools/tool-compatibility-registry.js";
+import { mergeExtensionEntryPaths } from "./extension-discovery.js";
+import { sortExtensionPaths } from "./extension-sort.js";
 import type {
 	Extension,
 	ExtensionAPI,
@@ -847,24 +849,21 @@ export async function loadExtensionFromFactory(
 /**
  * Load extensions from paths.
  *
- * Extensions are loaded in parallel to reduce wall-clock time (~30-50% faster
- * than sequential loading for I/O-bound jiti compilation).
+ * Paths are expected to be topologically sorted by caller (see sortExtensionPaths).
+ * Factories are awaited sequentially so a dependency's factory fully initializes
+ * (registers tools, commands, hooks on `pi`) before any dependent's factory runs.
  */
 export async function loadExtensions(paths: string[], cwd: string, eventBus?: EventBus): Promise<LoadExtensionsResult> {
 	const resolvedEventBus = eventBus ?? createEventBus();
 	const runtime = createExtensionRuntime();
 
-	const results = await Promise.all(
-		paths.map((extPath) => loadExtension(extPath, cwd, resolvedEventBus, runtime)),
-	);
-
 	const extensions: Extension[] = [];
 	const errors: Array<{ path: string; error: string }> = [];
 
-	for (let i = 0; i < results.length; i++) {
-		const { extension, error } = results[i];
+	for (const extPath of paths) {
+		const { extension, error } = await loadExtension(extPath, cwd, resolvedEventBus, runtime);
 		if (error) {
-			errors.push({ path: paths[i], error });
+			errors.push({ path: extPath, error });
 		} else if (extension) {
 			extensions.push(extension);
 		}
@@ -873,6 +872,7 @@ export async function loadExtensions(paths: string[], cwd: string, eventBus?: Ev
 	return {
 		extensions,
 		errors,
+		warnings: [],
 		runtime,
 	};
 }
@@ -1034,7 +1034,12 @@ export async function discoverAndLoadExtensions(
 
 	// 2. Global extensions: agentDir/extensions/
 	const globalExtDir = path.join(agentDir, "extensions");
-	addPaths(discoverExtensionsInDir(globalExtDir));
+	// 2b. Installed extensions: ~/.gsd/extensions/ merged with bundled (D-14, D-15)
+	// Discovery handles ID-based merge — loader stays dumb.
+	const installedExtDir = path.join(path.dirname(agentDir), "extensions");
+	const globalPaths = discoverExtensionsInDir(globalExtDir);
+	const mergedPaths = mergeExtensionEntryPaths(globalPaths, installedExtDir);
+	addPaths(mergedPaths);
 
 	// 3. Explicitly configured paths
 	for (const p of configuredPaths) {
@@ -1054,5 +1059,13 @@ export async function discoverAndLoadExtensions(
 		addPaths([resolved]);
 	}
 
-	return loadExtensions(allPaths, cwd, eventBus);
+	// Topological sort: ensure declared dependencies load first (D-06, D-07)
+	const { sortedPaths, warnings: sortWarnings } = sortExtensionPaths(allPaths)
+	// Emit warnings to stderr immediately — loader runs before ctx.ui is ready (D-08)
+	for (const w of sortWarnings) {
+		process.stderr.write(`[gsd] ${w.message}\n`)
+	}
+	const result = await loadExtensions(sortedPaths, cwd, eventBus)
+	result.warnings.push(...sortWarnings)
+	return result
 }

package/packages/pi-coding-agent/src/core/extensions/types.ts

@@ -1783,10 +1783,18 @@ export interface Extension {
 	lifecycleHooks: LifecycleHookMap;
 }
 
+/** Warning from extension dependency sort (missing deps, cycles). */
+export interface ExtensionLoadWarning {
+	declaringId: string;
+	missingId: string;
+	message: string;
+}
+
 /** Result of loading extensions. */
 export interface LoadExtensionsResult {
 	extensions: Extension[];
 	errors: Array<{ path: string; error: string }>;
+	warnings: ExtensionLoadWarning[];
 	/** Shared runtime - actions are throwing stubs until runner.initialize() */
 	runtime: ExtensionRuntime;
 }

package/packages/pi-coding-agent/src/core/lsp/lsp-integration.test.ts

@@ -14,6 +14,7 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
+import { spawnSync } from "node:child_process";
 
 // ---------------------------------------------------------------------------
 // Helpers — lightweight JSON-RPC over stdio (no dependency on our LSP code)
@@ -251,11 +252,23 @@ function fileToUri(filePath: string): string {
 	return `file://${path.resolve(filePath)}`;
 }
 
+function hasTypescriptLanguageServer(): boolean {
+	const probe = spawnSync("typescript-language-server", ["--help"], {
+		stdio: "ignore",
+	});
+	return probe.status === 0 || probe.status === 1;
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
 test("LSP integration: typescript-language-server", async (t) => {
+	if (!hasTypescriptLanguageServer()) {
+		t.skip("typescript-language-server not installed in this environment");
+		return;
+	}
+
 	const { dir, cleanup } = createTempProject();
 	const mainPath = path.join(dir, "src", "main.ts");
 	const mathPath = path.join(dir, "src", "math.ts");

package/packages/pi-coding-agent/src/core/model-registry-auth-mode.test.ts

@@ -15,11 +15,11 @@ function createRegistry(hasAuthFn?: (provider: string) => boolean): ModelRegistr
 		getApiKey: async () => undefined,
 	} as unknown as AuthStorage;
 
-	return new ModelRegistry(authStorage, undefined);
+	return new ModelRegistry(authStorage, "");
 }
 
 function createInMemoryRegistry(data: AuthStorageData = {}): ModelRegistry {
-	return new ModelRegistry(AuthStorage.inMemory(data), undefined);
+	return new ModelRegistry(AuthStorage.inMemory(data), "");
 }
 
 function createProviderModel(id: string, api?: string): NonNullable<Parameters<ModelRegistry["registerProvider"]>[1]["models"]>[number] {

package/packages/pi-coding-agent/src/core/resource-loader.ts

@@ -242,7 +242,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 		this.systemPromptOverride = options.systemPromptOverride;
 		this.appendSystemPromptOverride = options.appendSystemPromptOverride;
 
-		this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
+		this.extensionsResult = { extensions: [], errors: [], warnings: [], runtime: createExtensionRuntime() };
 		this.skills = [];
 		this.skillDiagnostics = [];
 		this.prompts = [];

package/packages/pi-coding-agent/src/core/sdk.test.ts

@@ -3,7 +3,8 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { CredentialCooldownError } from "./sdk.js";
+import { canRestoreSessionModel, CredentialCooldownError } from "./sdk.js";
+import type { Model } from "@gsd/pi-ai";
 
 // ─── CredentialCooldownError ──────────────────────────────────────────────────
 
@@ -87,3 +88,26 @@ describe("CredentialCooldownError", () => {
 		assert.equal(plain.retryAfterMs, 15_000);
 	});
 });
+
+describe("canRestoreSessionModel", () => {
+	const model = {
+		provider: "claude-code",
+		id: "claude-sonnet",
+	} as Model<any>;
+
+	it("allows keyless external providers when the provider is request-ready", () => {
+		const registry = {
+			isProviderRequestReady: (provider: string) => provider === "claude-code",
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), true);
+	});
+
+	it("blocks restore when the provider is not request-ready", () => {
+		const registry = {
+			isProviderRequestReady: () => false,
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), false);
+	});
+});

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -31,6 +31,13 @@ export class CredentialCooldownError extends Error {
 		this.retryAfterMs = retryAfterMs;
 	}
 }
+
+export function canRestoreSessionModel(
+	modelRegistry: Pick<ModelRegistry, "isProviderRequestReady">,
+	model: Model<any>,
+): boolean {
+	return modelRegistry.isProviderRequestReady(model.provider);
+}
 import { Agent, type AgentMessage, type ThinkingLevel } from "@gsd/pi-agent-core";
 import type { Message, Model } from "@gsd/pi-ai";
 import { getAgentDir, getDocsPath } from "../config.js";
@@ -262,9 +269,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// If session has data, try to restore model from it
 	if (!model && hasExistingSession && existingSession.model) {
 		const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
-		if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
-			model = restoredModel;
-		}
+			if (restoredModel && canRestoreSessionModel(modelRegistry, restoredModel)) {
+				model = restoredModel;
+			}
 		if (!model) {
 			modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
 		}

package/packages/pi-coding-agent/src/core/system-prompt.ts

@@ -109,9 +109,9 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	}
 
 	// Get absolute paths to documentation and examples
-	const readmePath = getReadmePath();
-	const docsPath = getDocsPath();
-	const examplesPath = getExamplesPath();
+	const readmePath = toPosixPath(getReadmePath());
+	const docsPath = toPosixPath(getDocsPath());
+	const examplesPath = toPosixPath(getExamplesPath());
 
 	// Build tools list based on selected tools.
 	// Built-ins use toolDescriptions. Custom tools can provide one-line snippets.

package/packages/pi-coding-agent/src/core/tools/path-utils.test.ts

@@ -1,11 +1,12 @@
 import { describe, it, mock, afterEach } from "node:test";
 import assert from "node:assert/strict";
+import { resolve as resolvePath } from "node:path";
 import { resolveToCwd, expandPath } from "./path-utils.js";
 
 describe("resolveToCwd", () => {
 	it("resolves relative paths against cwd", () => {
 		const result = resolveToCwd("foo/bar.txt", "/home/user/project");
-		assert.equal(result, "/home/user/project/foo/bar.txt");
+		assert.equal(result, resolvePath("/home/user/project", "foo/bar.txt"));
 	});
 
 	it("returns absolute paths unchanged", () => {

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/provider-display-name.test.ts

@@ -1,14 +1,11 @@
-// GSD-2 — Provider display name mapping tests
+// GSD-2 — Provider display name + auth badge tests
 import { test, describe } from "node:test";
 import assert from "node:assert/strict";
-import { providerDisplayName } from "../model-selector.js";
+import { providerAuthBadge, providerDisplayName } from "../model-selector.js";
 
 describe("providerDisplayName", () => {
-	test("renames 'anthropic' to 'anthropic-api'", () => {
-		assert.equal(providerDisplayName("anthropic"), "anthropic-api");
-	});
-
-	test("passes through unmapped providers unchanged", () => {
+	test("passes providers through unchanged", () => {
+		assert.equal(providerDisplayName("anthropic"), "anthropic");
 		assert.equal(providerDisplayName("claude-code"), "claude-code");
 		assert.equal(providerDisplayName("openai"), "openai");
 		assert.equal(providerDisplayName("bedrock"), "bedrock");
@@ -16,3 +13,16 @@ describe("providerDisplayName", () => {
 		assert.equal(providerDisplayName("openrouter"), "openrouter");
 	});
 });
+
+describe("providerAuthBadge", () => {
+	test("returns human-readable labels for each auth mode", () => {
+		assert.equal(providerAuthBadge("apiKey"), "API key");
+		assert.equal(providerAuthBadge("oauth"), "OAuth");
+		assert.equal(providerAuthBadge("externalCli"), "CLI");
+	});
+
+	test("returns empty string for 'none' and undefined", () => {
+		assert.equal(providerAuthBadge("none"), "");
+		assert.equal(providerAuthBadge(undefined), "");
+	});
+});

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

@@ -2,7 +2,7 @@ import { type Component, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import type { AgentSession } from "../../../core/agent-session.js";
 import type { ReadonlyFooterDataProvider } from "../../../core/footer-data-provider.js";
 import { theme } from "../theme/theme.js";
-import { providerDisplayName } from "./model-selector.js";
+import { providerAuthBadge, providerDisplayName } from "./model-selector.js";
 
 /**
  * Sanitize text for display in a single-line status.
@@ -199,13 +199,22 @@ export class FooterComponent implements Component {
 				thinkingLevel === "off" ? `${modelName} • thinking off` : `${modelName} • ${thinkingLevel}`;
 		}
 
-		// Prepend the provider in parentheses if there are multiple providers and there's enough room
+		// Prepend the provider in parentheses if there are multiple providers and there's enough room.
+		// Include the auth mode so users can tell at a glance whether the active model is
+		// API-key-backed, OAuth-backed, or delegated to a third-party CLI.
 		let rightSide = rightSideWithoutProvider;
 		if (this.footerData.getAvailableProviderCount() > 1 && displayModel) {
-			rightSide = `(${providerDisplayName(displayModel.provider)}) ${rightSideWithoutProvider}`;
+			const authMode = this.session.modelRegistry.getProviderAuthMode(displayModel.provider);
+			const authLabel = providerAuthBadge(authMode);
+			const providerLabel = providerDisplayName(displayModel.provider);
+			const parenthetical = authLabel ? `${providerLabel} · ${authLabel}` : providerLabel;
+			rightSide = `(${parenthetical}) ${rightSideWithoutProvider}`;
 			if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) {
-				// Too wide, fall back
-				rightSide = rightSideWithoutProvider;
+				// Too wide: drop the auth suffix first, then fall back to no parenthetical.
+				rightSide = `(${providerLabel}) ${rightSideWithoutProvider}`;
+				if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) {
+					rightSide = rightSideWithoutProvider;
+				}
 			}
 		}
 

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

@@ -9,19 +9,32 @@ import {
 	Text,
 	type TUI,
 } from "@gsd/pi-tui";
-import type { ModelRegistry } from "../../../core/model-registry.js";
+import type { ModelRegistry, ProviderAuthMode } from "../../../core/model-registry.js";
 import type { SettingsManager } from "../../../core/settings-manager.js";
 import { theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyHint } from "./keybinding-hints.js";
 
-/** Display names for providers in the model selector UI. */
-const PROVIDER_DISPLAY_NAMES: Record<string, string> = {
-	anthropic: "anthropic-api",
-};
-
 export function providerDisplayName(provider: string): string {
-	return PROVIDER_DISPLAY_NAMES[provider] ?? provider;
+	return provider;
+}
+
+/**
+ * Short, user-facing label for a provider's auth mode. Returned strings are
+ * suitable for use as a suffix/badge alongside the provider name.
+ * Returns an empty string for modes that don't need a badge (e.g. "none").
+ */
+export function providerAuthBadge(authMode?: ProviderAuthMode): string {
+	switch (authMode) {
+		case "apiKey":
+			return "API key";
+		case "oauth":
+			return "OAuth";
+		case "externalCli":
+			return "CLI";
+		default:
+			return "";
+	}
 }
 
 function formatTokenCount(count: number): string {
@@ -140,7 +153,8 @@ export class ModelSelectorComponent extends Container implements Focusable {
 			this.scopeHintText = new Text(this.getScopeHintText(), 0, 0);
 			this.addChild(this.scopeHintText);
 		} else {
-			const hintText = "Only showing models with configured API keys (see README for details)";
+			const hintText =
+				"Only showing models with configured credentials (API key, OAuth, or CLI). See README for details.";
 			this.addChild(new Text(theme.fg("warning", hintText), 0, 0));
 		}
 		this.addChild(new Spacer(1));
@@ -409,7 +423,12 @@ export class ModelSelectorComponent extends Container implements Focusable {
 
 			const ctx = formatTokenCount(item.model.contextWindow);
 			const ctxBadge = theme.fg("muted", `${ctx}`);
-			const providerBadge = theme.fg("muted", `[${providerDisplayName(item.provider)}]`);
+			const authMode = this.modelRegistry.getProviderAuthMode(item.provider);
+			const authLabel = providerAuthBadge(authMode);
+			const providerBadgeText = authLabel
+				? `[${providerDisplayName(item.provider)} · ${authLabel}]`
+				: `[${providerDisplayName(item.provider)}]`;
+			const providerBadge = theme.fg("muted", providerBadgeText);
 			const checkmark = isCurrent ? theme.fg("success", " ✓") : "";
 
 			let line: string;
@@ -445,7 +464,19 @@ export class ModelSelectorComponent extends Container implements Focusable {
 		const maxVisible = 12;
 
 		if (this.groupedRows.length === 0) {
-			this.listContainer.addChild(new Text(theme.fg("muted", "  No models available"), 0, 0));
+			this.listContainer.addChild(
+				new Text(theme.fg("muted", "  No providers configured."), 0, 0),
+			);
+			this.listContainer.addChild(
+				new Text(
+					theme.fg(
+						"muted",
+						"  Run /login (OAuth), set an API key, or install a CLI provider. See README.",
+					),
+					0,
+					0,
+				),
+			);
 			return;
 		}
 
@@ -467,11 +498,14 @@ export class ModelSelectorComponent extends Container implements Focusable {
 				// Provider group header — always unselectable
 				const providerLabel = theme.fg("borderAccent", providerDisplayName(row.provider));
 				const count = theme.fg("muted", ` (${row.count})`);
+				const authMode = this.modelRegistry.getProviderAuthMode(row.provider);
+				const authLabel = providerAuthBadge(authMode);
+				const authText = authLabel ? theme.fg("muted", ` · via ${authLabel}`) : "";
 				// Add blank line before header if not the very first visible row
 				if (i > startIndex) {
 					this.listContainer.addChild(new Text("", 0, 0));
 				}
-				this.listContainer.addChild(new Text(`  ${providerLabel}${count}`, 0, 0));
+				this.listContainer.addChild(new Text(`  ${providerLabel}${count}${authText}`, 0, 0));
 			} else {
 				// Model row
 				const isSelected = i === this.selectedGroupIndex;