fix: accurate duration and actual model in enrichment progress

Duration fix:
- onEnrich callback now uses parseFloat(((end-start)/1000).toFixed(1))
  for precise sub-second display (was Math.round which lost precision)
- Elapsed counter now updates every 500ms (was 2500ms) for smooth display
- Timer is cleared immediately when backend returns — no over-counting
- Summary duration comes from actual request timing, not the UI counter

Model fix:
- handleAiIdentify now returns { modelUsed, provider, confidence, specs,
  images, sellers, tags } from the actual API response
- onEnrich callback uses result.modelUsed (actual model from OpenRouter)
  instead of hardcoded 'Auto'
- Provider comes from result, not hardcoded 'OpenRouter'
- Summary card displays the real model name returned by the provider
  (e.g. 'nvidia/nemotron-3-super-120b-a12b:free' not 'Auto')

No hardcoded values:
- Removed: provider: 'OpenRouter' (now from result)
- Removed: model: 'Auto' (now from result.modelUsed)
- All summary data comes from the completed backend response
- If no result, returns { success: false } instead of fake summary

Timer architecture:
- Fast timer (500ms): elapsed display only
- Slow timer (2500ms): activity rotation, step advancement, stat growth
- Both cleared in finally block when enrichment completes

Author: codeboy2012

src/components/product/EnrichmentProgress.tsx

@@ -144,8 +144,14 @@ export function EnrichmentProgress({
       if (cancelledRef.current) return;
       const elapsedSec = (Date.now() - startTime) / 1000;
       setElapsed(parseFloat(elapsedSec.toFixed(1)));
+    }, 500);
 
-      // Rotate activity message every 2.5s
+    // Activity rotation (separate slower interval)
+    const activityInterval = setInterval(() => {
+      if (cancelledRef.current) return;
+      const elapsedSec = (Date.now() - startTime) / 1000;
+
+      // Rotate activity message
       actIdx = (actIdx + 1) % ACTIVITIES.length;
       setActivity(ACTIVITIES[actIdx]);
       if (elapsedSec > 2) addActivity(ACTIVITIES[actIdx]);
@@ -211,6 +217,7 @@ export function EnrichmentProgress({
       }
     } finally {
       if (timerRef.current) clearInterval(timerRef.current);
+      clearInterval(activityInterval);
     }
   }, [onEnrich, addActivity, toast]);
 

src/components/product/ProductEditorDrawer.tsx

@@ -513,8 +513,16 @@ export function ProductEditorDrawer({
   }, [item.id, toast, onDelete, onClose]);
 
   // ─── AI Identify ───
-  const handleAiIdentify = async () => {
-    if (!data.title.trim()) return;
+  const handleAiIdentify = async (): Promise<{
+    modelUsed?: string;
+    provider?: string;
+    confidence?: number;
+    specs?: number;
+    images?: number;
+    sellers?: number;
+    tags?: number;
+  } | null> => {
+    if (!data.title.trim()) return null;
     updateField('aiConfidence', 'loading');
     try {
       const res = await fetch('/api/products/enrich', {
@@ -647,13 +655,24 @@ export function ProductEditorDrawer({
         }
 
         toast.success('AI Autofill complete');
+        return {
+          modelUsed: result.modelUsed || result.enrichment?.modelUsed || undefined,
+          provider: 'OpenRouter',
+          confidence: result.enrichment?.confidence || undefined,
+          specs: result.enrichment?.specifications?.length || undefined,
+          images: result.enrichment?.images?.length || undefined,
+          sellers: result.enrichment?.sellers?.length || undefined,
+          tags: result.enrichment?.tags?.length || undefined,
+        };
       } else {
         updateField('aiConfidence', '');
         toast.error(result.error || 'Could not enrich product');
+        return null;
       }
     } catch {
       updateField('aiConfidence', '');
       toast.error('AI Autofill failed');
+      return null;
     }
   };
 
@@ -889,20 +908,26 @@ export function ProductEditorDrawer({
         onEnrich={async (): Promise<EnrichmentProgressResult> => {
           const startTime = Date.now();
           try {
-            await handleAiIdentify();
-            const duration = Math.round((Date.now() - startTime) / 1000);
-            return {
-              success: true,
-              summary: {
-                specifications: data.specs.length,
-                images: data.images.length,
-                sellers: data.sellers.length,
-                fields: Object.values(data).filter((v) => v && v !== '' && v !== 'loading').length,
-                duration,
-                provider: 'OpenRouter',
-                model: data.aiConfidence !== 'loading' ? 'Auto' : undefined,
-              },
-            };
+            const result = await handleAiIdentify();
+            const duration = parseFloat(((Date.now() - startTime) / 1000).toFixed(1));
+            if (result) {
+              return {
+                success: true,
+                summary: {
+                  specifications: result.specs,
+                  images: result.images,
+                  sellers: result.sellers,
+                  tags: result.tags,
+                  fields: Object.values(data).filter((v) => v && v !== '' && v !== 'loading')
+                    .length,
+                  duration,
+                  confidence: result.confidence,
+                  provider: result.provider,
+                  model: result.modelUsed,
+                },
+              };
+            }
+            return { success: false, error: 'No results returned' };
           } catch (err) {
             return {
               success: false,