Remove strategy-era frontend contract handling

Author: gildesmarais

frontend/src/__tests__/App.test.tsx

@@ -553,7 +553,6 @@ describe('App', () => {
         retryable: true,
         nextAction: 'retry',
         retryAction: 'alternate',
-        nextStrategy: 'browserless',
         message: 'Browserless failed.',
       },
       convertFeed: mockConvertFeed,
@@ -663,6 +662,43 @@ describe('App', () => {
     expect(screen.queryByRole('button', { name: /Retry with .*/ })).not.toBeInTheDocument();
   });
 
+  it('keeps extraction-empty failures generic and input-corrective', async () => {
+    mockUseFeedConversion.mockReturnValue({
+      isConverting: false,
+      result: undefined,
+      error: {
+        kind: 'input',
+        code: 'NO_FEED_ITEMS_EXTRACTED',
+        retryable: false,
+        nextAction: 'correct_input',
+        retryAction: 'none',
+        message: 'Could not extract feed items. Try a more specific listing URL or explicit selectors.',
+      },
+      convertFeed: mockConvertFeed,
+      clearError: mockClearConversionError,
+      clearResult: mockClearResult,
+      retryReadinessCheck: mockRetryReadinessCheck,
+      restoreResult: mockRestoreResult,
+    });
+    mockUseAccessToken.mockReturnValue({
+      token: 'saved-token',
+      hasToken: true,
+      saveToken: mockSaveToken,
+      clearToken: mockClearToken,
+      isLoading: false,
+      error: undefined,
+    });
+
+    render(<App />);
+
+    await screen.findByText(
+      'Could not extract feed items. Try a more specific listing URL or explicit selectors.'
+    );
+    expect(screen.queryByText('Enter access token')).not.toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Try again' })).not.toBeInTheDocument();
+    expect(mockClearToken).not.toHaveBeenCalled();
+  });
+
   it('shows the utility links in a user-focused order', () => {
     globalThis.history.replaceState({}, '', 'http://localhost:3000/create');
     render(<App />);

frontend/src/__tests__/ResultDisplay.test.tsx

@@ -181,7 +181,7 @@ describe('ResultDisplay', () => {
     });
   });
 
-  it('shows an automatic retry notice when fallback strategy succeeded', async () => {
+  it('shows a generic automatic recovery notice when the backend reports recovery', async () => {
     render(
       <ResultDisplay
         result={

frontend/src/__tests__/mocks/server.ts

@@ -21,26 +21,6 @@ export const server = setupServer(
       },
     });
   }),
-  http.get('/api/v1/strategies', () => {
-    return HttpResponse.json({
-      success: true,
-      data: {
-        strategies: [
-          {
-            id: 'faraday',
-            name: 'faraday',
-            display_name: 'Default',
-          },
-          {
-            id: 'browserless',
-            name: 'browserless',
-            display_name: 'JavaScript pages (recommended)',
-          },
-        ],
-      },
-      meta: { total: 2 },
-    });
-  }),
   http.get('/api/v1/feeds/:token/status', () => {
     return HttpResponse.json(buildFeedStatusResponse());
   })
@@ -83,7 +63,6 @@ export interface StructuredErrorOverrides {
   retryable?: boolean;
   next_action?: 'enter_token' | 'correct_input' | 'retry' | 'wait' | 'none';
   retry_action?: 'alternate' | 'primary' | 'none';
-  next_strategy?: string;
 }
 
 export function buildFeedResponse(overrides: FeedResponseOverrides = {}) {
@@ -139,7 +118,6 @@ export function buildStructuredErrorResponse(overrides: StructuredErrorOverrides
       retryable: overrides.retryable ?? false,
       next_action: overrides.next_action ?? 'none',
       retry_action: overrides.retry_action ?? 'none',
-      ...(overrides.next_strategy ? { next_strategy: overrides.next_strategy } : {}),
     },
   };
 }

frontend/src/__tests__/useFeedConversion.contract.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { renderHook, act, waitFor } from '@testing-library/preact';
+import { renderHook, act } from '@testing-library/preact';
 import { http, HttpResponse } from 'msw';
 import { server, buildFeedResponse, buildStructuredErrorResponse } from './mocks/server';
 import { useFeedConversion } from '../hooks/useFeedConversion';
@@ -30,20 +30,7 @@ describe('useFeedConversion contract', () => {
           { status: 201 }
         );
       }),
-      http.get('/api/v1/feeds/generated-token/status', () =>
-        HttpResponse.json(
-          buildFeedResponse({
-            feed_token: 'generated-token',
-            public_url: '/api/v1/feeds/generated-token',
-            json_public_url: '/api/v1/feeds/generated-token.json',
-            conversion: {
-              readiness_phase: 'feed_ready',
-              preview_status: 'ready',
-              warnings: [],
-            },
-          })
-        )
-      )
+      http.get('/api/v1/feeds/generated-token/status', () => HttpResponse.json(buildFeedResponse()))
     );
 
     const { result } = renderHook(() => useFeedConversion());
@@ -56,12 +43,6 @@ describe('useFeedConversion contract', () => {
     expect(result.current.error).toBeUndefined();
     expect(result.current.result?.feed.feed_token).toBe('generated-token');
     expect(result.current.result?.readinessPhase).toBe('link_created');
-
-    await waitFor(() => {
-      expect(result.current.result?.readinessPhase).toBe('feed_ready');
-      expect((result.current.result as any)?.previewStatus).toBe('ready');
-      expect((result.current.result as any)?.warnings).toEqual([]);
-    });
   });
 
   it('propagates structured auth failures without parsing the message text', async () => {
@@ -102,7 +83,48 @@ describe('useFeedConversion contract', () => {
     });
   });
 
-  it('marks degraded result metadata when the status endpoint reports warnings', async () => {
+  it('treats extraction-empty failures as corrective input errors without strategy metadata', async () => {
+    server.use(
+      http.post('/api/v1/feeds', async () =>
+        HttpResponse.json(
+          buildStructuredErrorResponse({
+            code: 'NO_FEED_ITEMS_EXTRACTED',
+            message: 'Could not extract feed items. Try a more specific listing URL or explicit selectors.',
+            kind: 'input',
+            retryable: false,
+            next_action: 'correct_input',
+            retry_action: 'none',
+          }),
+          { status: 422 }
+        )
+      )
+    );
+
+    const { result } = renderHook(() => useFeedConversion());
+
+    await act(async () => {
+      await expect(result.current.convertFeed('https://example.com/articles', 'token')).rejects.toMatchObject(
+        {
+          kind: 'input',
+          code: 'NO_FEED_ITEMS_EXTRACTED',
+          nextAction: 'correct_input',
+          retryAction: 'none',
+          retryable: false,
+          message: 'Could not extract feed items. Try a more specific listing URL or explicit selectors.',
+        }
+      );
+    });
+
+    expect(result.current.error).toMatchObject({
+      kind: 'input',
+      code: 'NO_FEED_ITEMS_EXTRACTED',
+      nextAction: 'correct_input',
+      retryAction: 'none',
+      retryable: false,
+    });
+  });
+
+  it('accepts create responses even when later polling surfaces degraded status warnings', async () => {
     server.use(
       http.post('/api/v1/feeds', async ({ request }) => {
         const body = (await request.json()) as { url: string };
@@ -151,18 +173,9 @@ describe('useFeedConversion contract', () => {
       await result.current.convertFeed('https://example.com/articles', 'token');
     });
 
-    await waitFor(() => {
-      expect(result.current.result?.readinessPhase).toBe('feed_ready');
-      expect((result.current.result as any)?.previewStatus).toBe('degraded');
-      expect((result.current.result as any)?.warnings).toEqual([
-        {
-          code: 'preview_partial',
-          message: 'Preview content could not be fully verified.',
-          retryable: true,
-          nextAction: 'retry',
-        },
-      ]);
-    });
+    expect(result.current.error).toBeUndefined();
+    expect(result.current.result?.feed.feed_token).toBe('generated-token');
+    expect(result.current.result?.readinessPhase).toBe('link_created');
   });
 
   it('rejects camelCase-only create payloads to enforce canonical snake_case contract', async () => {

frontend/src/api/contracts.ts

@@ -61,7 +61,6 @@ export interface FeedCreationError {
   retryable: boolean;
   nextAction: FeedNextAction;
   retryAction: FeedRetryAction;
-  nextStrategy?: string;
   message: string;
   status?: number;
 }

frontend/src/hooks/useFeedConversion.ts

@@ -56,7 +56,6 @@ interface RawErrorEnvelope {
   retryable?: unknown;
   next_action?: unknown;
   retry_action?: unknown;
-  next_strategy?: unknown;
   message?: unknown;
 }
 
@@ -606,9 +605,8 @@ function normalizeFeedCreationErrorFromResponse(
   const retryAction = normalizeRetryAction(envelope?.retry_action, nextAction, retryable);
   const code = normalizeString(envelope?.code) || fallbackErrorCode(status, kind);
   const message = normalizeString(envelope?.message) || fallbackErrorMessage(status, kind, nextAction);
-  const nextStrategy = normalizeString(envelope?.next_strategy);
 
-  return buildStructuredError(kind, code, retryable, nextAction, retryAction, message, status, nextStrategy);
+  return buildStructuredError(kind, code, retryable, nextAction, retryAction, message, status);
 }
 
 function progressFromResult(result: CreatedFeedResult): ResultProgressState {
@@ -631,16 +629,14 @@ function buildStructuredError(
   nextAction: FeedNextAction,
   retryAction: FeedRetryAction,
   message: string,
-  status?: number,
-  nextStrategy?: string
+  status?: number
 ): FeedCreationError {
   return {
     kind,
     code,
     retryable,
     nextAction,
     retryAction,
-    ...(nextStrategy ? { nextStrategy } : {}),
     message,
     ...(typeof status === 'number' ? { status } : {}),
   };
@@ -903,7 +899,6 @@ function isErrorEnvelope(value: unknown): value is RawErrorEnvelope {
     candidate.retryable !== undefined ||
     candidate.next_action !== undefined ||
     candidate.retry_action !== undefined ||
-    candidate.next_strategy !== undefined ||
     candidate.message !== undefined
   );
 }