feat(N): workflow pipeline, 3D viewer, worker management, QC tests

- workflow_builder.py: fix broken stubs, add render_order_line_still_task
  (resolves step_path from DB instead of passing order_line_id as step_path)
- domains/rendering/tasks.py: add render_order_line_still_task,
  export_gltf_for_order_line_task, export_blend_for_order_line_task,
  generate_gltf_geometry_task (trimesh STL→GLB, no Blender needed)
- tasks/step_tasks.py: add generate_gltf_geometry_task for CadFile GLB export
- cad router: POST /{id}/generate-gltf-geometry endpoint (admin/PM)
- worker router: GET /celery-workers + POST /scale (docker compose subprocess)
- Dockerfile: pip install -e "[dev]" to enable pytest
- docker-compose.yml: docker socket + compose file mount on backend
- ThreeDViewer.tsx: mode toggle (geometry/production), wireframe, env presets,
  download buttons (GLB + .blend)
- CadPreview.tsx: load gltf_geometry/gltf_production/blend_production assets
  from MediaAsset table and pass URLs to ThreeDViewer
- ProductDetail.tsx: "View 3D" button → /cad/:id, "Generate GLB" button
- media router/service: cad_file_id filter on GET /api/media
- WorkerManagement.tsx: new page with worker status, queue depth, scale controls
- App.tsx + Layout.tsx: /workers route + sidebar link (admin/PM)
- tests: test_rendering_service.py, test_orders_service.py (backend)
- tests: WorkerActivity.test.tsx, WorkerManagement.test.tsx (frontend)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/app/tasks/step_tasks.py

@@ -245,6 +245,69 @@ def generate_stl_cache(self, cad_file_id: str, quality: str):
         raise self.retry(exc=exc, countdown=30, max_retries=2)
 
 
+@celery_app.task(bind=True, name="app.tasks.step_tasks.generate_gltf_geometry_task", queue="thumbnail_rendering", max_retries=1)
+def generate_gltf_geometry_task(self, cad_file_id: str):
+    """Export a geometry-only GLB from the STL low-quality cache using trimesh.
+
+    Creates a MediaAsset with asset_type='gltf_geometry' and cad_file_id set.
+    No Blender required — trimesh handles the STL→GLB conversion.
+    """
+    from pathlib import Path as _Path
+    from sqlalchemy import create_engine
+    from sqlalchemy.orm import Session
+    from app.config import settings as app_settings
+    from app.models.cad_file import CadFile
+
+    sync_url = app_settings.database_url.replace("+asyncpg", "")
+    eng = create_engine(sync_url)
+    with Session(eng) as session:
+        cad_file = session.get(CadFile, cad_file_id)
+        if not cad_file or not cad_file.stored_path:
+            logger.error("generate_gltf_geometry_task: no stored_path for %s", cad_file_id)
+            return
+        step_path_str = cad_file.stored_path
+    eng.dispose()
+
+    step = _Path(step_path_str)
+    stl_path = step.parent / f"{step.stem}_low.stl"
+    if not stl_path.exists():
+        logger.error("generate_gltf_geometry_task: STL not found %s", stl_path)
+        raise RuntimeError(f"STL cache not found: {stl_path}")
+
+    output_path = step.parent / f"{step.stem}_geometry.glb"
+    try:
+        import trimesh
+        mesh = trimesh.load(str(stl_path))
+        mesh.export(str(output_path))
+        logger.info("generate_gltf_geometry_task: exported %s", output_path.name)
+    except Exception as exc:
+        logger.error("generate_gltf_geometry_task failed for %s: %s", cad_file_id, exc)
+        raise self.retry(exc=exc, countdown=15)
+
+    # Create MediaAsset record
+    import asyncio
+
+    async def _store():
+        from app.database import AsyncSessionLocal
+        from app.domains.media.models import MediaAsset, MediaAssetType
+        async with AsyncSessionLocal() as db:
+            import uuid
+            asset = MediaAsset(
+                cad_file_id=uuid.UUID(cad_file_id),
+                asset_type=MediaAssetType.gltf_geometry,
+                storage_key=str(output_path),
+                mime_type="model/gltf-binary",
+                file_size_bytes=output_path.stat().st_size if output_path.exists() else None,
+            )
+            db.add(asset)
+            await db.commit()
+            return str(asset.id)
+
+    asset_id = asyncio.get_event_loop().run_until_complete(_store())
+    logger.info("generate_gltf_geometry_task: MediaAsset %s created for cad %s", asset_id, cad_file_id)
+    return {"glb_path": str(output_path), "asset_id": asset_id}
+
+
 @celery_app.task(bind=True, name="app.tasks.step_tasks.regenerate_thumbnail", queue="thumbnail_rendering")
 def regenerate_thumbnail(self, cad_file_id: str, part_colors: dict):
     """Regenerate thumbnail with per-part colours."""