@semiont/react-ui 0.2.34-build.91 → 0.2.34-build.92

package/src/features/resource-viewer/__tests__/DetectionFlowBug.test.tsx

@@ -2,58 +2,68 @@
  * FAILING TEST: Reproduces the bug where detection events fire but state doesn't update
  *
  * Based on console logs from production:
- * ✅ detection:start emitted
- * ✅ detection:progress emitted
- * ❌ detectingMotivation remains null
- * ❌ detectionProgress remains null
+ * ✅ annotate:assist-request emitted
+ * ✅ annotate:assist-progress emitted
+ * ❌ assistingMotivation remains null
+ * ❌ progress remains null
  *
- * UPDATED: Now tests useDetectionFlow hook instead of DetectionFlowContainer
+ * UPDATED: Now tests useAnnotationFlow hook instead of DetectionFlowContainer
  */
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { render, screen, waitFor } from '@testing-library/react';
 import { act } from 'react';
-import { useDetectionFlow } from '../../../hooks/useDetectionFlow';
+import { useAnnotationFlow } from '../../../hooks/useAnnotationFlow';
 import { EventBusProvider, useEventBus, resetEventBusForTesting } from '../../../contexts/EventBusContext';
 import { ApiClientProvider } from '../../../contexts/ApiClientContext';
 import { AuthTokenProvider } from '../../../contexts/AuthTokenContext';
 import { SSEClient } from '@semiont/api-client';
 
+// Mock Toast module to prevent "useToast must be used within a ToastProvider" errors
+vi.mock('../../../components/Toast', () => ({
+  useToast: () => ({
+    showSuccess: vi.fn(),
+    showError: vi.fn(),
+    showInfo: vi.fn(),
+    showWarning: vi.fn(),
+  }),
+}));
+
 describe('REPRODUCING BUG: Detection state not updating', () => {
   beforeEach(() => {
     resetEventBusForTesting();
     vi.clearAllMocks();
 
     // Minimal mock - SSE streams not needed for this test
-    vi.spyOn(SSEClient.prototype, 'detectReferences').mockReturnValue({ onProgress: vi.fn().mockReturnThis(), onComplete: vi.fn().mockReturnThis(), onError: vi.fn().mockReturnThis(), close: vi.fn() } as any);
-    vi.spyOn(SSEClient.prototype, 'detectHighlights').mockReturnValue({ onProgress: vi.fn().mockReturnThis(), onComplete: vi.fn().mockReturnThis(), onError: vi.fn().mockReturnThis(), close: vi.fn() } as any);
-    vi.spyOn(SSEClient.prototype, 'detectComments').mockReturnValue({ onProgress: vi.fn().mockReturnThis(), onComplete: vi.fn().mockReturnThis(), onError: vi.fn().mockReturnThis(), close: vi.fn() } as any);
-    vi.spyOn(SSEClient.prototype, 'detectAssessments').mockReturnValue({ onProgress: vi.fn().mockReturnThis(), onComplete: vi.fn().mockReturnThis(), onError: vi.fn().mockReturnThis(), close: vi.fn() } as any);
+    vi.spyOn(SSEClient.prototype, 'annotateReferences').mockReturnValue({ onProgress: vi.fn().mockReturnThis(), onComplete: vi.fn().mockReturnThis(), onError: vi.fn().mockReturnThis(), close: vi.fn() } as any);
+    vi.spyOn(SSEClient.prototype, 'annotateHighlights').mockReturnValue({ onProgress: vi.fn().mockReturnThis(), onComplete: vi.fn().mockReturnThis(), onError: vi.fn().mockReturnThis(), close: vi.fn() } as any);
+    vi.spyOn(SSEClient.prototype, 'annotateComments').mockReturnValue({ onProgress: vi.fn().mockReturnThis(), onComplete: vi.fn().mockReturnThis(), onError: vi.fn().mockReturnThis(), close: vi.fn() } as any);
+    vi.spyOn(SSEClient.prototype, 'annotateAssessments').mockReturnValue({ onProgress: vi.fn().mockReturnThis(), onComplete: vi.fn().mockReturnThis(), onError: vi.fn().mockReturnThis(), close: vi.fn() } as any);
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
-  it('SHOULD update state when detection:start event is emitted', async () => {
+  it('SHOULD update state when annotate:assist-request event is emitted', async () => {
     let eventBusInstance: any;
     let currentState: any;
 
     // Component to capture EventBus and hook state
     function TestComponent() {
       eventBusInstance = useEventBus();
-      const state = useDetectionFlow('http://localhost:8080/resources/test' as any);
+      const state = useAnnotationFlow('http://localhost:8080/resources/test' as any);
       currentState = state;
 
-      console.log('[TEST] useDetectionFlow state:', {
-        detectingMotivation: state.detectingMotivation,
-        detectionProgress: state.detectionProgress,
+      console.log('[TEST] useAnnotationFlow state:', {
+        assistingMotivation: state.assistingMotivation,
+        progress: state.progress,
       });
 
       return (
         <div>
-          <div data-testid="detecting">{state.detectingMotivation || 'null'}</div>
-          <div data-testid="progress">{state.detectionProgress?.message || 'null'}</div>
+          <div data-testid="detecting">{state.assistingMotivation || 'null'}</div>
+          <div data-testid="progress">{state.progress?.message || 'null'}</div>
         </div>
       );
     }
@@ -72,40 +82,40 @@ describe('REPRODUCING BUG: Detection state not updating', () => {
     expect(screen.getByTestId('detecting')).toHaveTextContent('null');
     expect(screen.getByTestId('progress')).toHaveTextContent('null');
 
-    console.log('[TEST] Emitting detection:start event...');
+    console.log('[TEST] Emitting annotate:assist-request event...');
 
-    // Emit detection:start event (exactly like production)
+    // Emit annotate:assist-request event (exactly like production)
     act(() => {
-      eventBusInstance.get('detection:start').next({
+      eventBusInstance.get('annotate:assist-request').next({
         motivation: 'linking',
         options: { entityTypes: ['Location'] }
       });
     });
 
-    console.log('[TEST] After detection:start, checking state...');
+    console.log('[TEST] After annotate:assist-request, checking state...');
 
     // THIS SHOULD PASS but currently FAILS
     await waitFor(() => {
       expect(screen.getByTestId('detecting')).toHaveTextContent('linking');
     }, { timeout: 1000 });
 
-    expect(currentState.detectingMotivation).toBe('linking');
-    expect(currentState.detectionProgress).toBeNull(); // Should clear on start
+    expect(currentState.assistingMotivation).toBe('linking');
+    expect(currentState.progress).toBeNull(); // Should clear on start
   });
 
-  it('SHOULD update state when detection:progress event is emitted', async () => {
+  it('SHOULD update state when annotate:assist-progress event is emitted', async () => {
     let eventBusInstance: any;
     let currentState: any;
 
     function TestComponent() {
       eventBusInstance = useEventBus();
-      const state = useDetectionFlow('http://localhost:8080/resources/test' as any);
+      const state = useAnnotationFlow('http://localhost:8080/resources/test' as any);
       currentState = state;
 
       return (
         <div>
-          <div data-testid="detecting">{state.detectingMotivation || 'null'}</div>
-          <div data-testid="progress">{state.detectionProgress?.message || 'null'}</div>
+          <div data-testid="detecting">{state.assistingMotivation || 'null'}</div>
+          <div data-testid="progress">{state.progress?.message || 'null'}</div>
         </div>
       );
     }
@@ -120,11 +130,11 @@ describe('REPRODUCING BUG: Detection state not updating', () => {
       </EventBusProvider>
     );
 
-    console.log('[TEST] Emitting detection:progress event...');
+    console.log('[TEST] Emitting annotate:assist-progress event...');
 
-    // Emit detection:progress event (exactly like production)
+    // Emit annotate:assist-progress event (exactly like production)
     act(() => {
-      eventBusInstance.get('detection:progress').next({
+      eventBusInstance.get('annotate:progress').next({
         status: 'started',
         resourceId: 'test',
         totalEntityTypes: 1,
@@ -133,14 +143,14 @@ describe('REPRODUCING BUG: Detection state not updating', () => {
       });
     });
 
-    console.log('[TEST] After detection:progress, checking state...');
+    console.log('[TEST] After annotate:assist-progress, checking state...');
 
     // THIS SHOULD PASS but currently FAILS
     await waitFor(() => {
       expect(screen.getByTestId('progress')).toHaveTextContent('Starting entity detection...');
     }, { timeout: 1000 });
 
-    expect(currentState.detectionProgress).toMatchObject({
+    expect(currentState.progress).toMatchObject({
       status: 'started',
       message: 'Starting entity detection...'
     });
@@ -152,17 +162,17 @@ describe('REPRODUCING BUG: Detection state not updating', () => {
 
     function TestComponent() {
       eventBusInstance = useEventBus();
-      const state = useDetectionFlow('http://localhost:8080/resources/f45fd44f9cb0b0fe1b7980d3d034bc61' as any);
+      const state = useAnnotationFlow('http://localhost:8080/resources/f45fd44f9cb0b0fe1b7980d3d034bc61' as any);
 
       stateSnapshots.push({
-        detectingMotivation: state.detectingMotivation,
-        detectionProgress: state.detectionProgress,
+        assistingMotivation: state.assistingMotivation,
+        progress: state.progress,
       });
 
       return (
         <div>
-          <div data-testid="detecting">{state.detectingMotivation || 'null'}</div>
-          <div data-testid="progress">{state.detectionProgress?.message || 'null'}</div>
+          <div data-testid="detecting">{state.assistingMotivation || 'null'}</div>
+          <div data-testid="progress">{state.progress?.message || 'null'}</div>
         </div>
       );
     }
@@ -182,18 +192,18 @@ describe('REPRODUCING BUG: Detection state not updating', () => {
 
     // Exactly like production logs
     act(() => {
-      console.log('[EventBus] emit: detection:start {motivation: "linking", options: {...}}');
-      eventBusInstance.get('detection:start').next({
+      console.log('[EventBus] emit: annotate:assist-request {motivation: "linking", options: {...}}');
+      eventBusInstance.get('annotate:assist-request').next({
         motivation: 'linking',
         options: { entityTypes: ['Location'] }
       });
     });
 
-    console.log('After detection:start:', stateSnapshots[stateSnapshots.length - 1]);
+    console.log('After annotate:assist-request:', stateSnapshots[stateSnapshots.length - 1]);
 
     act(() => {
-      console.log('[EventBus] emit: detection:progress {status: "started", ...}');
-      eventBusInstance.get('detection:progress').next({
+      console.log('[EventBus] emit: annotate:assist-progress {status: "started", ...}');
+      eventBusInstance.get('annotate:progress').next({
         status: 'started',
         resourceId: 'f45fd44f9cb0b0fe1b7980d3d034bc61',
         totalEntityTypes: 1,
@@ -202,11 +212,11 @@ describe('REPRODUCING BUG: Detection state not updating', () => {
       });
     });
 
-    console.log('After detection:progress:', stateSnapshots[stateSnapshots.length - 1]);
+    console.log('After annotate:assist-progress:', stateSnapshots[stateSnapshots.length - 1]);
 
     act(() => {
-      console.log('[EventBus] emit: detection:progress {status: "scanning", ...}');
-      eventBusInstance.get('detection:progress').next({
+      console.log('[EventBus] emit: annotate:assist-progress {status: "scanning", ...}');
+      eventBusInstance.get('annotate:progress').next({
         status: 'scanning',
         resourceId: 'f45fd44f9cb0b0fe1b7980d3d034bc61',
         currentEntityType: 'Location',
@@ -216,19 +226,19 @@ describe('REPRODUCING BUG: Detection state not updating', () => {
       });
     });
 
-    console.log('After second detection:progress:', stateSnapshots[stateSnapshots.length - 1]);
+    console.log('After second annotate:assist-progress:', stateSnapshots[stateSnapshots.length - 1]);
     console.log('=== END REPRODUCTION ===\n');
 
     // THIS IS THE BUG: Events fire but state never updates
-    // Production logs show: detectingMotivation: null, detectionProgress: null
+    // Production logs show: assistingMotivation: null, progress: null
     // Even though events were emitted
     await waitFor(() => {
       const currentSnapshot = stateSnapshots[stateSnapshots.length - 1];
       console.log('Final state check:', currentSnapshot);
 
       // These SHOULD pass but will FAIL if bug is present
-      expect(currentSnapshot.detectingMotivation).toBe('linking');
-      expect(currentSnapshot.detectionProgress?.message).toBe('Scanning for Location...');
+      expect(currentSnapshot.assistingMotivation).toBe('linking');
+      expect(currentSnapshot.progress?.message).toBe('Scanning for Location...');
     }, { timeout: 2000 });
   });
 });

package/src/features/resource-viewer/__tests__/DetectionFlowIntegration.test.tsx

@@ -4,7 +4,7 @@
  * Tests the COMPLETE detection flow with real component composition:
  * - EventBusProvider (REAL)
  * - ApiClientProvider (REAL, with MOCKED client)
- * - useDetectionFlow (REAL)
+ * - useAnnotationFlow (REAL)
  * - useResolutionFlow (REAL)
  * - useEventSubscriptions (REAL)
  *
@@ -25,7 +25,7 @@ import React from 'react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { render, screen, waitFor } from '@testing-library/react';
 import { act } from 'react';
-import { useDetectionFlow } from '../../../hooks/useDetectionFlow';
+import { useAnnotationFlow } from '../../../hooks/useAnnotationFlow';
 import { EventBusProvider, useEventBus, resetEventBusForTesting } from '../../../contexts/EventBusContext';
 import { ApiClientProvider } from '../../../contexts/ApiClientContext';
 import { AuthTokenProvider } from '../../../contexts/AuthTokenContext';
@@ -33,6 +33,16 @@ import { SSEClient } from '@semiont/api-client';
 import type { Motivation } from '@semiont/core';
 import { resourceUri } from '@semiont/core';
 import type { Emitter } from 'mitt';
+
+// Mock Toast module to prevent "useToast must be used within a ToastProvider" errors
+vi.mock('../../../components/Toast', () => ({
+  useToast: () => ({
+    showSuccess: vi.fn(),
+    showError: vi.fn(),
+    showInfo: vi.fn(),
+    showWarning: vi.fn(),
+  }),
+}));
 import type { EventMap } from '@semiont/core';
 
 // Mock SSE stream - SSE now emits directly to EventBus, no callbacks
@@ -44,8 +54,8 @@ const createMockSSEStream = () => {
 
 describe('Detection Flow - Feature Integration', () => {
   let mockStream: ReturnType<typeof createMockSSEStream>;
-  let detectReferencesSpy: any;
-  let detectHighlightsSpy: any;
+  let annotateReferencesSpy: any;
+  let annotateHighlightsSpy: any;
   let detectCommentsSpy: any;
 
   beforeEach(() => {
@@ -56,23 +66,23 @@ describe('Detection Flow - Feature Integration', () => {
     mockStream = createMockSSEStream();
 
     // Spy on SSEClient prototype methods
-    detectReferencesSpy = vi.spyOn(SSEClient.prototype, 'detectReferences').mockReturnValue(mockStream as any);
-    detectHighlightsSpy = vi.spyOn(SSEClient.prototype, 'detectHighlights').mockReturnValue(mockStream as any);
-    detectCommentsSpy = vi.spyOn(SSEClient.prototype, 'detectComments').mockReturnValue(mockStream as any);
-    vi.spyOn(SSEClient.prototype, 'detectAssessments').mockReturnValue(mockStream as any);
+    annotateReferencesSpy = vi.spyOn(SSEClient.prototype, 'annotateReferences').mockReturnValue(mockStream as any);
+    annotateHighlightsSpy = vi.spyOn(SSEClient.prototype, 'annotateHighlights').mockReturnValue(mockStream as any);
+    detectCommentsSpy = vi.spyOn(SSEClient.prototype, 'annotateComments').mockReturnValue(mockStream as any);
+    vi.spyOn(SSEClient.prototype, 'annotateAssessments').mockReturnValue(mockStream as any);
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
-  it('should call detectReferences exactly ONCE when detection starts (not twice)', async () => {
+  it('should call annotateReferences exactly ONCE when detection starts (not twice)', async () => {
     const testUri = resourceUri('http://localhost:4000/resources/test-resource');
 
     // Render with real component composition
     const { emitDetectionStart } = renderDetectionFlow(testUri);
 
-    // Trigger detection for linking (uses detectReferences)
+    // Trigger detection for linking (uses annotateReferences)
     act(() => {
       emitDetectionStart('linking', {
         entityTypes: ['Person', 'Organization'],
@@ -83,11 +93,11 @@ describe('Detection Flow - Feature Integration', () => {
     // CRITICAL ASSERTION: API called exactly once (not twice!)
     // This would FAIL if useResolutionFlow was called in multiple places
     await waitFor(() => {
-      expect(detectReferencesSpy).toHaveBeenCalledTimes(1);
+      expect(annotateReferencesSpy).toHaveBeenCalledTimes(1);
     });
 
     // Verify correct parameters (eventBus is passed but we don't need to verify its exact value)
-    expect(detectReferencesSpy).toHaveBeenCalledWith(
+    expect(annotateReferencesSpy).toHaveBeenCalledWith(
       testUri,
       {
         entityTypes: ['Person', 'Organization'],
@@ -97,7 +107,7 @@ describe('Detection Flow - Feature Integration', () => {
     );
   });
 
-  it('should propagate SSE progress events to useDetectionFlow state', async () => {
+  it('should propagate SSE progress events to useAnnotationFlow state', async () => {
     const testUri = resourceUri('http://localhost:4000/resources/test-resource');
 
     // Render with state observer
@@ -112,12 +122,12 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Wait for stream to be created
     await waitFor(() => {
-      expect(detectReferencesSpy).toHaveBeenCalled();
+      expect(annotateReferencesSpy).toHaveBeenCalled();
     });
 
     // Simulate SSE progress event being emitted to EventBus (how SSE actually works now)
     act(() => {
-      getEventBus().get('detection:progress').next({
+      getEventBus().get('annotate:progress').next({
         status: 'scanning',
         message: 'Scanning for Person...',
         currentEntityType: 'Person',
@@ -146,12 +156,12 @@ describe('Detection Flow - Feature Integration', () => {
     });
 
     await waitFor(() => {
-      expect(detectHighlightsSpy).toHaveBeenCalledTimes(1);
+      expect(annotateHighlightsSpy).toHaveBeenCalledTimes(1);
     });
 
     // First progress update via EventBus
     act(() => {
-      getEventBus().get('detection:progress').next({
+      getEventBus().get('annotate:progress').next({
         status: 'started',
         message: 'Starting analysis...',
         percentage: 0,
@@ -164,7 +174,7 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Second progress update via EventBus
     act(() => {
-      getEventBus().get('detection:progress').next({
+      getEventBus().get('annotate:progress').next({
         status: 'analyzing',
         message: 'Analyzing text...',
         percentage: 50,
@@ -177,7 +187,7 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Final progress update via EventBus
     act(() => {
-      getEventBus().get('detection:progress').next({
+      getEventBus().get('annotate:progress').next({
         status: 'complete',
         message: 'Created 14 highlights',
         percentage: 100,
@@ -204,7 +214,7 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Send final progress via EventBus
     act(() => {
-      getEventBus().get('detection:progress').next({
+      getEventBus().get('annotate:progress').next({
         status: 'complete',
         message: 'Created 14 highlights',
       });
@@ -216,7 +226,7 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Emit completion event
     act(() => {
-      getEventBus().get('detection:complete').next({ motivation: 'highlighting' });
+      getEventBus().get('annotate:assist-finished').next({ motivation: 'highlighting' });
     });
 
     // Verify: detecting flag cleared BUT progress still visible
@@ -237,7 +247,7 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Add some progress via EventBus
     act(() => {
-      getEventBus().get('detection:progress').next({
+      getEventBus().get('annotate:progress').next({
         status: 'scanning',
         message: 'Scanning...',
       });
@@ -249,7 +259,19 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Emit failure
     act(() => {
-      getEventBus().get('detection:failed').next({ type: 'job.failed', resourceId: 'test-resource' as any, payload: { jobId: 'job-1' as any, jobType: 'detection', error: 'Network error' } });
+      getEventBus().get('annotate:assist-failed').next({
+        type: 'job.failed' as const,
+        resourceId: 'test-resource' as any,
+        userId: 'user' as any,
+        id: 'evt-1' as any,
+        timestamp: new Date().toISOString(),
+        version: 1,
+        payload: {
+          jobId: 'job-1' as any,
+          jobType: 'detection',
+          error: 'Network error',
+        },
+      });
     });
 
     // Verify: both detecting and progress cleared
@@ -269,8 +291,8 @@ describe('Detection Flow - Feature Integration', () => {
     });
 
     await waitFor(() => {
-      expect(detectHighlightsSpy).toHaveBeenCalledTimes(1);
-      expect(detectHighlightsSpy).toHaveBeenCalledWith(testUri, {
+      expect(annotateHighlightsSpy).toHaveBeenCalledTimes(1);
+      expect(annotateHighlightsSpy).toHaveBeenCalledWith(testUri, {
         instructions: 'Find important text',
       }, expect.objectContaining({ auth: undefined }));
     });
@@ -306,7 +328,7 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Add an additional event listener (simulating multiple subscribers)
     const additionalListener = vi.fn();
-    const subscription = getEventBus().get('detection:start').subscribe(additionalListener);
+    const subscription = getEventBus().get('annotate:assist-request').subscribe(additionalListener);
 
     // Trigger detection
     act(() => {
@@ -315,11 +337,11 @@ describe('Detection Flow - Feature Integration', () => {
 
     // Wait for operation to complete
     await waitFor(() => {
-      expect(detectReferencesSpy).toHaveBeenCalled();
+      expect(annotateReferencesSpy).toHaveBeenCalled();
     });
 
     // VERIFY: API called exactly once, even though multiple listeners exist
-    expect(detectReferencesSpy).toHaveBeenCalledTimes(1);
+    expect(annotateReferencesSpy).toHaveBeenCalledTimes(1);
 
     // VERIFY: Our additional listener was called (events work)
     expect(additionalListener).toHaveBeenCalledTimes(1);
@@ -329,7 +351,7 @@ describe('Detection Flow - Feature Integration', () => {
 });
 
 /**
- * Helper: Render useDetectionFlow hook with real component composition
+ * Helper: Render useAnnotationFlow hook with real component composition
  * Returns methods to interact with the rendered component
  */
 function renderDetectionFlow(testUri: string) {
@@ -343,12 +365,12 @@ function renderDetectionFlow(testUri: string) {
 
   // Test harness component that uses the hook
   function DetectionFlowTestHarness() {
-    const { detectionProgress, detectingMotivation } = useDetectionFlow(testUri as any);
+    const { progress, assistingMotivation } = useAnnotationFlow(testUri as any);
     return (
       <div>
-        <div data-testid="detecting">{detectingMotivation || 'none'}</div>
+        <div data-testid="detecting">{assistingMotivation || 'none'}</div>
         <div data-testid="progress">
-          {detectionProgress?.message || 'No progress'}
+          {progress?.message || 'No progress'}
         </div>
       </div>
     );
@@ -367,7 +389,7 @@ function renderDetectionFlow(testUri: string) {
 
   return {
     emitDetectionStart: (motivation: Motivation, options: any) => {
-      eventBusInstance.get('detection:start').next({ motivation, options });
+      eventBusInstance.get('annotate:assist-request').next({ motivation, options });
     },
     getEventBus: () => eventBusInstance,
   };

package/src/features/resource-viewer/__tests__/GenerationFlowIntegration.test.tsx

@@ -32,6 +32,16 @@ import { resourceUri, annotationUri } from '@semiont/core';
 import type { Emitter } from 'mitt';
 import type { EventMap } from '@semiont/core';
 
+// Mock Toast module to prevent "useToast must be used within a ToastProvider" errors
+vi.mock('../../../components/Toast', () => ({
+  useToast: () => ({
+    showSuccess: vi.fn(),
+    showError: vi.fn(),
+    showInfo: vi.fn(),
+    showWarning: vi.fn(),
+  }),
+}));
+
 // Mock SSE stream - SSE now emits directly to EventBus, no callbacks
 const createMockGenerationStream = () => {
   return {
@@ -66,7 +76,7 @@ describe('Generation Flow - Feature Integration', () => {
     vi.restoreAllMocks();
   });
 
-  it('should open modal when generation:modal-open event is emitted', async () => {
+  it('should open modal when generate:modal-open event is emitted', async () => {
     const testResourceUri = resourceUri('http://localhost:4000/resources/test-resource');
     const testAnnotationUri = annotationUri('http://localhost:4000/resources/test-resource/annotations/test-annotation');
 
@@ -157,7 +167,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Simulate SSE progress callback being invoked
     act(() => {
-      getEventBus().get('generation:progress').next({
+      getEventBus().get('generate:progress').next({
         status: 'generating',
         message: 'Generating content...',
         percentage: 25,
@@ -193,7 +203,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // First progress update
     act(() => {
-      getEventBus().get('generation:progress').next({
+      getEventBus().get('generate:progress').next({
         status: 'started',
         message: 'Starting generation...',
         percentage: 0,
@@ -206,7 +216,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Second progress update
     act(() => {
-      getEventBus().get('generation:progress').next({
+      getEventBus().get('generate:progress').next({
         status: 'generating',
         message: 'Creating document structure...',
         percentage: 50,
@@ -219,7 +229,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Final progress update via onComplete
     act(() => {
-      getEventBus().get('generation:complete').next({
+      getEventBus().get('generate:finished').next({
         status: 'complete',
         referenceId: testAnnotationUri,
         message: 'Document created successfully',
@@ -256,7 +266,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Simulate completion with final chunk
     act(() => {
-      getEventBus().get('generation:progress').next({
+      getEventBus().get('generate:progress').next({
         status: 'complete',
         message: 'Complete',
         resourceName: 'Generated Document',
@@ -265,7 +275,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Emit completion event
     act(() => {
-      getEventBus().get('generation:complete').next({
+      getEventBus().get('generate:finished').next({
         status: 'complete',
         referenceId: testAnnotationUri,
         resourceName: 'Generated Document',
@@ -295,7 +305,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Add some progress
     act(() => {
-      getEventBus().get('generation:progress').next({
+      getEventBus().get('generate:progress').next({
         status: 'generating',
         message: 'Generating...',
       });
@@ -307,7 +317,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Emit failure
     act(() => {
-      getEventBus().get('generation:failed').next({ error: new Error('Network error') });
+      getEventBus().get('generate:failed').next({ error: new Error('Network error') });
     });
 
     // Verify: progress cleared and not generating
@@ -327,7 +337,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Add an additional event listener (simulating multiple subscribers)
     const additionalListener = vi.fn();
-    const subscription = getEventBus().get('generation:start').subscribe(additionalListener);
+    const subscription = getEventBus().get('generate:request').subscribe(additionalListener);
 
     // Trigger generation
     act(() => {
@@ -373,7 +383,7 @@ describe('Generation Flow - Feature Integration', () => {
 
     // Simulate onComplete with final chunk
     act(() => {
-      getEventBus().get('generation:complete').next({
+      getEventBus().get('generate:finished').next({
         status: 'complete',
         referenceId: testAnnotationUri,
         message: 'Document created: My Document',
@@ -403,7 +413,7 @@ function renderGenerationFlow(
   function EventBusCapture() {
     eventBusInstance = useEventBus();
 
-    // Set up resolution flow (annotation:update-body, reference:link)
+    // Set up resolution flow (resolve:update-body, resolve:link)
     useResolutionFlow(testResourceUri);
 
     return null;
@@ -419,8 +429,6 @@ function renderGenerationFlow(
     } = useGenerationFlow(
       'en',
       testResourceUri.split('/resources/')[1] || 'test-resource',
-      vi.fn(),
-      vi.fn(),
       vi.fn()
     );
 
@@ -456,7 +464,7 @@ function renderGenerationFlow(
       resourceUri: ResourceUri,
       defaultTitle: string
     ) => {
-      eventBusInstance.get('generation:modal-open').next({
+      eventBusInstance.get('generate:modal-open').next({
         annotationUri,
         resourceUri,
         defaultTitle,
@@ -474,7 +482,7 @@ function renderGenerationFlow(
         context: any;
       }
     ) => {
-      eventBusInstance.get('generation:start').next({
+      eventBusInstance.get('generate:request').next({
         annotationUri,
         resourceUri,
         options,