fix: honor specific-tier fallbacks in proxy path

packages/backend/src/routing/dto/resolve-response.ts

@@ -12,4 +12,5 @@ export interface ResolveResponse {
   reason: ScoringReason;
   auth_type?: AuthType;
   specificity_category?: SpecificityCategory;
+  fallback_models?: string[] | null;
 }

packages/backend/src/routing/proxy/__tests__/proxy.service.spec.ts

@@ -1761,6 +1761,52 @@ describe('ProxyService', () => {
       expect(result.meta.fallbackIndex).toBeUndefined();
     });
 
+    it('tries specificity fallback models before tier fallbacks when a specific-tier route fails', async () => {
+      resolveService.resolve.mockResolvedValue({
+        tier: 'standard',
+        model: 'gpt-5.4',
+        provider: 'OpenAI',
+        confidence: 0.95,
+        score: 0,
+        reason: 'specificity',
+        specificity_category: 'coding',
+        fallback_models: ['claude-sonnet-4'],
+      });
+      providerKeyService.getProviderApiKey
+        .mockResolvedValueOnce('sk-openai')
+        .mockResolvedValueOnce('sk-ant');
+      providerClient.forward
+        .mockResolvedValueOnce({
+          response: new Response('error', { status: 429 }),
+          isGoogle: false,
+          isAnthropic: false,
+          isChatGpt: false,
+        })
+        .mockResolvedValueOnce({
+          response: new Response('{}', { status: 200 }),
+          isGoogle: false,
+          isAnthropic: true,
+          isChatGpt: false,
+        });
+      tierService.getTiers.mockResolvedValue([
+        { tier: 'standard', fallback_models: null },
+      ] as never);
+      pricingCache.getByModel.mockReturnValue({ provider: 'Anthropic' } as never);
+
+      const result = await service.proxyRequest({
+        agentId: 'agent-1',
+        userId: 'user-1',
+        body,
+        sessionKey: 'default',
+      });
+
+      expect(result.meta.fallbackFromModel).toBe('gpt-5.4');
+      expect(result.meta.fallbackIndex).toBe(0);
+      expect(result.meta.primaryErrorStatus).toBe(429);
+      expect(result.meta.model).toBe('claude-sonnet-4');
+      expect(result.meta.specificity_category).toBe('coding');
+    });
+
     it('tries fallback model when primary returns 429', async () => {
       resolveService.resolve.mockResolvedValue({
         tier: 'standard',

packages/backend/src/routing/proxy/proxy.service.ts

@@ -177,7 +177,7 @@ export class ProxyService {
     if (!forward.response.ok && shouldTriggerFallback(forward.response.status)) {
       const tiers = await this.tierService.getTiers(agentId);
       const assignment = tiers.find((t) => t.tier === resolved.tier);
-      const fallbackModels = assignment?.fallback_models;
+      const fallbackModels = resolved.fallback_models ?? assignment?.fallback_models;
 
       if (fallbackModels && fallbackModels.length > 0) {
         const primaryStatus = forward.response.status;

packages/backend/src/routing/resolve.service.spec.ts

@@ -421,6 +421,7 @@ describe('ResolveService', () => {
           override_provider: 'anthropic',
           override_auth_type: null,
           auto_assigned_model: null,
+          fallback_models: ['gpt-4o', 'deepseek-chat'],
         },
       ]);
       mockProviderKeyService.hasActiveProvider.mockResolvedValue(true);
@@ -434,6 +435,7 @@ describe('ResolveService', () => {
       expect(result.provider).toBe('anthropic');
       expect(result.reason).toBe('specificity');
       expect(result.specificity_category).toBe('coding');
+      expect(result.fallback_models).toEqual(['gpt-4o', 'deepseek-chat']);
     });
 
     it('should return null when no active assignments exist', async () => {

packages/backend/src/routing/resolve/resolve.service.ts

@@ -162,6 +162,7 @@ export class ResolveService {
       reason: 'specificity',
       auth_type: authType,
       specificity_category: detected.category,
+      fallback_models: assignment.fallback_models ?? null,
     };
   }
 

packages/backend/src/routing/routing-core/tier.service.ts

@@ -8,7 +8,7 @@ import { RoutingCacheService } from './routing-cache.service';
 import { ProviderService } from './provider.service';
 import { ModelDiscoveryService } from '../../model-discovery/model-discovery.service';
 import { randomUUID } from 'crypto';
-import { TIERS } from '../../scoring/types';
+import { TIERS, Tier } from '../../scoring/types';
 import { isManifestUsableProvider } from '../../common/utils/subscription-support';
 
 @Injectable()
@@ -39,7 +39,7 @@ export class TierService {
 
     if (rows.length === 0) {
       // Batch tier inserts — create all 4 tier rows in one query
-      const created: TierAssignment[] = TIERS.map((tier) =>
+      const created: TierAssignment[] = TIERS.map((tier: Tier) =>
         Object.assign(new TierAssignment(), {
           id: randomUUID(),
           user_id: userId ?? '',