fix: stale default provider root cause + Doctor diagnostic accuracy

Root cause: deleting a provider left a dangling default_provider_id in
settings. Resolver fell back to env vars, bypassing the user's configured
provider. Doctor diagnosed symptoms (no credentials, env fallback) but
couldn't fix the root cause.

Direct fixes:
- providers/[id]/route.ts: DELETE now clears stale default_provider_id
  and auto-selects the next available provider
- providers/models/route.ts: GET auto-heals stale default on page load
  (safe — this is an explicit API endpoint, not a diagnostic read path)
- provider-resolver.ts: removed auto-heal from resolveProvider() read
  path to prevent side effects during Doctor diagnostics

Doctor improvements:
- provider.default-missing: message now explains root cause ("default
  points to deleted record, resolver falls back to env")
- auth.resolved-no-creds: distinguishes "provider has no key" from
  "fell back to env due to stale default"
- set-default-provider repair: now addresses provider.default-missing
- apply-provider-to-session: validates providerId exists, auto-fixes
  stale default if needed
- Network probe: only checks api.anthropic.com in env mode, avoids
  "Anthropic API unreachable" noise when user is on Kimi/GLM etc.

file-tree.tsx: removed duplicate tabIndex on outer treeitem div —
single tab stop on the trigger row only.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 7418

src/app/api/doctor/repair/route.ts

@@ -111,13 +111,29 @@ export async function POST(request: NextRequest) {
 
       case 'apply-provider-to-session': {
         // Apply the default (or specified) provider to a session
-        const providerId = params?.providerId || getDefaultProviderId();
+        let providerId = params?.providerId || getDefaultProviderId();
         if (!providerId) {
           return NextResponse.json(
             { error: 'No default provider configured and no providerId specified' },
             { status: 400 },
           );
         }
+        // Validate the provider actually exists — stale default IDs are a known issue
+        const targetProvider = getProvider(providerId);
+        if (!targetProvider) {
+          // Try first available provider instead
+          const { getAllProviders } = await import('@/lib/db');
+          const all = getAllProviders();
+          if (all.length > 0) {
+            providerId = all[0].id;
+            setDefaultProviderId(providerId); // also fix the stale default
+          } else {
+            return NextResponse.json(
+              { error: `Provider "${providerId}" not found and no alternatives available` },
+              { status: 404 },
+            );
+          }
+        }
         if (params?.sessionId) {
           updateSessionProviderId(params.sessionId, providerId);
         } else {

src/app/api/providers/[id]/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { getProvider, updateProvider, deleteProvider } from '@/lib/db';
+import { getProvider, updateProvider, deleteProvider, getDefaultProviderId, setDefaultProviderId, getAllProviders } from '@/lib/db';
 import type { ProviderResponse, ErrorResponse, UpdateProviderRequest, ApiProvider } from '@/types';
 
 interface RouteContext {
@@ -83,6 +83,18 @@ export async function DELETE(_request: NextRequest, context: RouteContext) {
       );
     }
 
+    // If the deleted provider was the default, clear the stale reference
+    // and auto-switch to the first remaining provider (if any).
+    const currentDefault = getDefaultProviderId();
+    if (currentDefault === id) {
+      const remaining = getAllProviders();
+      if (remaining.length > 0) {
+        setDefaultProviderId(remaining[0].id);
+      } else {
+        setDefaultProviderId('');
+      }
+    }
+
     return NextResponse.json({ success: true });
   } catch (error) {
     return NextResponse.json<ErrorResponse>(

src/app/api/providers/models/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server';
-import { getAllProviders, getDefaultProviderId, getModelsForProvider, getSetting } from '@/lib/db';
+import { getAllProviders, getDefaultProviderId, setDefaultProviderId, getProvider, getModelsForProvider, getSetting } from '@/lib/db';
 import { getContextWindow } from '@/lib/model-context';
 import { getDefaultModelsForProvider, inferProtocolFromLegacy, findPresetForLegacy } from '@/lib/provider-catalog';
 import type { Protocol } from '@/lib/provider-catalog';
@@ -188,8 +188,15 @@ export async function GET() {
       });
     }
 
-    // Determine default provider
-    const defaultProviderId = getDefaultProviderId() || groups[0].provider_id;
+    // Determine default provider — auto-heal stale references on read
+    let defaultProviderId = getDefaultProviderId();
+    if (defaultProviderId && !getProvider(defaultProviderId)) {
+      // Stale default (provider was deleted). Fix it now.
+      const firstValid = groups.find(g => g.provider_id !== 'env');
+      defaultProviderId = firstValid?.provider_id || '';
+      setDefaultProviderId(defaultProviderId);
+    }
+    defaultProviderId = defaultProviderId || groups[0]?.provider_id || '';
 
     return NextResponse.json({
       groups,

src/components/ai-elements/file-tree.tsx

@@ -142,7 +142,6 @@ export const FileTreeFolder = ({
         <div
           className={cn("", className)}
           role="treeitem"
-          tabIndex={0}
           {...props}
         >
           <CollapsibleTrigger asChild>

src/lib/provider-doctor.ts

@@ -237,10 +237,12 @@ async function runAuthProbe(): Promise<ProbeResult> {
       findings.push({
         severity: 'warn',
         code: 'auth.resolved-no-creds',
-        message: 'Resolved provider reports no usable credentials',
+        message: resolved.provider
+          ? `Provider "${resolved.provider.name}" is selected but has no usable credentials`
+          : 'Resolver fell back to environment variables — no configured provider is active',
         detail: resolved.provider
-          ? `Provider "${resolved.provider.name}" (${resolved.protocol})`
-          : 'Environment mode',
+          ? `Check the API key for "${resolved.provider.name}" in Settings → Providers`
+          : 'This usually means the default provider was deleted or never set. Check the Provider/Model probe for details.',
       });
     }
     // Check for provider-level auth style conflict
@@ -310,14 +312,17 @@ async function runProviderProbe(): Promise<ProbeResult> {
       findings.push({
         severity: 'error',
         code: 'provider.default-missing',
-        message: `Default provider ID "${defaultId}" not found in database`,
+        message: `Default provider points to a deleted record — resolver falls back to environment variables, bypassing your configured provider`,
+        detail: providers.length > 0
+          ? `${providers.length} valid provider(s) exist but none is selected as default. Click "Fix" to set the first one.`
+          : 'No providers configured. Add a provider in Settings → Providers.',
       });
     }
   } else if (providers.length > 0) {
     findings.push({
       severity: 'warn',
       code: 'provider.no-default',
-      message: 'Providers exist but no default is set',
+      message: 'Providers exist but no default is set — new conversations will use environment variables',
     });
   }
 
@@ -503,8 +508,14 @@ async function runNetworkProbe(): Promise<ProbeResult> {
   // Collect unique base URLs to check
   const urlsToCheck = new Map<string, string>(); // url -> label
 
-  // Default Anthropic API
-  urlsToCheck.set('https://api.anthropic.com', 'Anthropic API');
+  // Only check Anthropic API if the current resolution actually uses it
+  // (env mode with no providers, or provider with anthropic base_url).
+  // Avoid showing "Anthropic API unreachable" noise when user is on Kimi/GLM etc.
+  const resolved = resolveProvider();
+  const isEnvMode = !resolved.provider;
+  if (isEnvMode) {
+    urlsToCheck.set('https://api.anthropic.com', 'Anthropic API');
+  }
 
   // Provider-specific URLs
   const providers = getAllProviders();
@@ -570,9 +581,9 @@ async function runNetworkProbe(): Promise<ProbeResult> {
 const REPAIR_ACTIONS: RepairAction[] = [
   {
     type: 'set-default-provider',
-    label: 'Set default provider',
-    description: 'Configure a default provider so sessions have a clear auth path',
-    addresses: ['provider.no-default', 'auth.no-credentials'],
+    label: 'Set first valid provider as default',
+    description: 'Fix the stale default by pointing to an existing provider',
+    addresses: ['provider.no-default', 'provider.default-missing', 'auth.no-credentials'],
   },
   {
     type: 'apply-provider-to-session',

src/lib/provider-resolver.ts

@@ -97,6 +97,10 @@ export function resolveProvider(opts: ResolveOptions = {}): ResolvedProvider {
     // No provider specified — use global default
     const defaultId = getDefaultProviderId();
     if (defaultId) provider = getProvider(defaultId);
+    // Note: stale default (provider deleted but setting remains) is NOT
+    // auto-healed here — resolver is a read path that may run during
+    // diagnostics. Auto-heal happens in: DELETE /api/providers/[id],
+    // POST /api/doctor/repair, and startup migration in chat/page.tsx.
   }
   // effectiveProviderId === 'env' → provider stays undefined