@goscribe/server 1.1.7 → 1.3.0

package/src/routers/workspace.ts

@@ -1,13 +1,20 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
-import { router, publicProcedure, authedProcedure } from '../trpc.js';
+import { router, publicProcedure, authedProcedure, verifiedProcedure } from '../trpc.js';
 import { supabaseClient } from '../lib/storage.js';
-import { ArtifactType } from '@prisma/client';
+import { ArtifactType } from '../lib/constants.js';
 import { aiSessionService } from '../lib/ai-session.js';
 import PusherService from '../lib/pusher.js';
 import { members } from './members.js';
 import { logger } from '../lib/logger.js';
 import type { PrismaClient } from '@prisma/client';
+import { getUserStorageLimit } from '../lib/subscription_service.js';
+import { getUserUsage, getUserPlanLimits } from '../lib/usage_service.js';
+import {
+  notifyArtifactFailed,
+  notifyArtifactReady,
+  notifyWorkspaceDeleted,
+} from '../lib/notification-service.js';
 
 // Helper function to update and emit analysis progress
 async function updateAnalysisProgress(
@@ -22,6 +29,65 @@ async function updateAnalysisProgress(
   await PusherService.emitAnalysisProgress(workspaceId, progress);
 }
 
+// DRY helper to build progress steps for artifact generation pipeline
+type StepStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'error';
+const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'] as const;
+
+function buildProgressSteps(
+  currentStep: typeof PIPELINE_STEPS[number],
+  currentStatus: StepStatus,
+  config: { generateStudyGuide: boolean; generateFlashcards: boolean },
+  overrides?: Partial<Record<typeof PIPELINE_STEPS[number], StepStatus>>
+): Record<string, { order: number; status: StepStatus }> {
+  const stepIndex = PIPELINE_STEPS.indexOf(currentStep);
+  const steps: Record<string, { order: number; status: StepStatus }> = {};
+
+  for (let i = 0; i < PIPELINE_STEPS.length; i++) {
+    const step = PIPELINE_STEPS[i];
+    let status: StepStatus;
+
+    if (overrides?.[step]) {
+      status = overrides[step]!;
+    } else if (i < stepIndex) {
+      status = 'completed';
+    } else if (i === stepIndex) {
+      status = currentStatus;
+    } else {
+      // Future steps: check if they're configured
+      if (step === 'studyGuide' && !config.generateStudyGuide) {
+        status = 'skipped';
+      } else if (step === 'flashcards' && !config.generateFlashcards) {
+        status = 'skipped';
+      } else {
+        status = 'pending';
+      }
+    }
+
+    steps[step] = { order: i + 1, status };
+  }
+
+  return steps;
+}
+
+function buildProgress(
+  status: string,
+  filename: string,
+  fileType: string,
+  currentStep: typeof PIPELINE_STEPS[number],
+  currentStepStatus: StepStatus,
+  config: { generateStudyGuide: boolean; generateFlashcards: boolean },
+  extra?: Record<string, any>
+) {
+  return {
+    status,
+    filename,
+    fileType,
+    startedAt: new Date().toISOString(),
+    steps: buildProgressSteps(currentStep, currentStepStatus, config, extra as any),
+    ...extra,
+  };
+}
+
 // Helper function to calculate search relevance score
 function calculateRelevance(query: string, ...texts: (string | null | undefined)[]): number {
   const queryLower = query.toLowerCase();
@@ -86,6 +152,42 @@ export const workspace = router({
       return { workspaces, folders };
     }),
 
+  /**
+   * Fetches the entire directory tree for the user.
+   * Includes Folders, Workspaces (files), and Uploads (sub-files).
+   */
+  getTree: authedProcedure
+    .query(async ({ ctx }) => {
+      const userId = ctx.session.user.id;
+
+      // 1. Fetch all folders
+      const allFolders = await ctx.db.folder.findMany({
+        where: { ownerId: userId },
+        orderBy: { updatedAt: 'desc' },
+      });
+
+      // 2. Fetch all workspaces
+      const allWorkspaces = await ctx.db.workspace.findMany({
+        where: { ownerId: userId },
+        include: {
+          uploads: {
+            select: {
+              id: true,
+              name: true,
+              mimeType: true,
+              createdAt: true,
+            }
+          }
+        },
+        orderBy: { updatedAt: 'desc' },
+      });
+
+      return {
+        folders: allFolders,
+        workspaces: allWorkspaces,
+      };
+    }),
+
   create: authedProcedure
     .input(z.object({
       name: z.string().min(1).max(100),
@@ -114,7 +216,12 @@ export const workspace = router({
         },
       });
 
-      aiSessionService.initSession(ws.id, ctx.session.user.id);
+      await aiSessionService.initSession(ws.id, ctx.session.user.id).catch((err) => {
+        logger.error('Failed to init AI session on workspace creation:', err);
+      });
+
+      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+
       return ws;
     }),
   createFolder: authedProcedure
@@ -132,16 +239,28 @@ export const workspace = router({
           parentId: input.parentId ?? null,
         },
       });
+
+      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+
       return folder;
     }),
   updateFolder: authedProcedure
     .input(z.object({
       id: z.string(),
       name: z.string().min(1).max(100).optional(),
-      color: z.string().optional(),
+      markerColor: z.string().nullable().optional(),
     }))
     .mutation(async ({ ctx, input }) => {
-      const folder = await ctx.db.folder.update({ where: { id: input.id }, data: { name: input.name, color: input.color ?? '#9D00FF' } });
+      const folder = await ctx.db.folder.update({
+        where: { id: input.id },
+        data: {
+          name: input.name,
+          markerColor: input.markerColor
+        }
+      });
+
+      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+
       return folder;
     }),
   deleteFolder: authedProcedure
@@ -150,6 +269,9 @@ export const workspace = router({
     }))
     .mutation(async ({ ctx, input }) => {
       const folder = await ctx.db.folder.delete({ where: { id: input.id } });
+
+      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+
       return folder;
     }),
   get: authedProcedure
@@ -182,24 +304,132 @@ export const workspace = router({
       });
 
       const spaceLeft = await ctx.db.fileAsset.aggregate({
-        where: { workspaceId: { in: workspaces.map(ws => ws.id) }, userId: ctx.session.user.id },
+        where: { workspaceId: { in: workspaces.map((ws: any) => ws.id) }, userId: ctx.session.user.id },
         _sum: { size: true },
       });
 
+      const storageLimit = await getUserStorageLimit(ctx.session.user.id);
+
       return {
         workspaces: workspaces.length,
         folders: folders.length,
         lastUpdated: lastUpdated?.updatedAt,
         spaceUsed: spaceLeft._sum?.size ?? 0,
-        spaceTotal: 1000000000,
+        spaceTotal: storageLimit,
       };
     }),
+
+  // Study analytics: streaks, flashcard mastery, worksheet accuracy
+  getStudyAnalytics: authedProcedure
+    .query(async ({ ctx }) => {
+      const userId = ctx.session.user.id;
+
+      // Gather all study activity dates
+      const flashcardProgress = await ctx.db.flashcardProgress.findMany({
+        where: { userId },
+        select: { lastStudiedAt: true },
+      });
+
+      const worksheetProgress = await ctx.db.worksheetQuestionProgress.findMany({
+        where: { userId },
+        select: { updatedAt: true, completedAt: true },
+      });
+
+      // Build a set of unique study days (YYYY-MM-DD)
+      const studyDays = new Set<string>();
+      for (const fp of flashcardProgress) {
+        if (fp.lastStudiedAt) {
+          studyDays.add(fp.lastStudiedAt.toISOString().split('T')[0]);
+        }
+      }
+      for (const wp of worksheetProgress) {
+        if (wp.completedAt) {
+          studyDays.add(wp.completedAt.toISOString().split('T')[0]);
+        } else {
+          studyDays.add(wp.updatedAt.toISOString().split('T')[0]);
+        }
+      }
+
+      // Calculate streak (consecutive days ending today or yesterday)
+      const sortedDays = [...studyDays].sort().reverse();
+      let streak = 0;
+
+      if (sortedDays.length > 0) {
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const yesterday = new Date(today);
+        yesterday.setDate(yesterday.getDate() - 1);
+
+        const todayStr = today.toISOString().split('T')[0];
+        const yesterdayStr = yesterday.toISOString().split('T')[0];
+
+        // Streak only counts if the most recent study day is today or yesterday
+        if (sortedDays[0] === todayStr || sortedDays[0] === yesterdayStr) {
+          streak = 1;
+          for (let i = 1; i < sortedDays.length; i++) {
+            const current = new Date(sortedDays[i - 1]);
+            const prev = new Date(sortedDays[i]);
+            const diffDays = (current.getTime() - prev.getTime()) / (1000 * 60 * 60 * 24);
+            if (diffDays === 1) {
+              streak++;
+            } else {
+              break;
+            }
+          }
+        }
+      }
+
+      // Weekly activity (last 7 days)
+      const weeklyActivity: boolean[] = [];
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      for (let i = 6; i >= 0; i--) {
+        const d = new Date(today);
+        d.setDate(d.getDate() - i);
+        const dayStr = d.toISOString().split('T')[0];
+        weeklyActivity.push(studyDays.has(dayStr));
+      }
+
+      // Flashcard stats
+      const totalCards = await ctx.db.flashcardProgress.count({ where: { userId } });
+      const masteredCards = await ctx.db.flashcardProgress.count({
+        where: { userId, masteryLevel: { gte: 80 } },
+      });
+      const dueCards = await ctx.db.flashcardProgress.count({
+        where: { userId, nextReviewAt: { lte: new Date() } },
+      });
+
+      // Worksheet stats
+      const completedQuestions = await ctx.db.worksheetQuestionProgress.count({
+        where: { userId, completedAt: { not: null } },
+      });
+      const correctQuestions = await ctx.db.worksheetQuestionProgress.count({
+        where: { userId, correct: true },
+      });
+
+      return {
+        streak,
+        totalStudyDays: studyDays.size,
+        weeklyActivity,
+        flashcards: {
+          total: totalCards,
+          mastered: masteredCards,
+          dueForReview: dueCards,
+        },
+        worksheets: {
+          completed: completedQuestions,
+          correct: correctQuestions,
+          accuracy: completedQuestions > 0 ? Math.round((correctQuestions / completedQuestions) * 100) : 0,
+        },
+      };
+    }),
+
   update: authedProcedure
     .input(z.object({
       id: z.string(),
       name: z.string().min(1).max(100).optional(),
       description: z.string().max(500).optional(),
-      color: z.string().optional(),
+      markerColor: z.string().nullable().optional(),
       icon: z.string().optional(),
     }))
     .mutation(async ({ ctx, input }) => {
@@ -212,10 +442,14 @@ export const workspace = router({
         data: {
           title: input.name ?? existed.title,
           description: input.description,
-          color: input.color ?? existed.color,
+          // Preserve explicit null ("None color") instead of falling back.
+          markerColor: input.markerColor !== undefined ? input.markerColor : existed.markerColor,
           icon: input.icon ?? existed.icon,
         },
       });
+
+      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+
       return updated;
     }),
   delete: authedProcedure
@@ -223,10 +457,41 @@ export const workspace = router({
       id: z.string(),
     }))
     .mutation(async ({ ctx, input }) => {
+      const workspaceToDelete = await ctx.db.workspace.findFirst({
+        where: { id: input.id, ownerId: ctx.session.user.id },
+        select: {
+          id: true,
+          title: true,
+          ownerId: true,
+          members: {
+            select: { userId: true },
+          },
+        },
+      });
+
+      if (!workspaceToDelete) throw new TRPCError({ code: 'NOT_FOUND' });
+
+      const actor = await ctx.db.user.findUnique({
+        where: { id: ctx.session.user.id },
+        select: { name: true, email: true },
+      });
+      const actorName = actor?.name || actor?.email || 'A user';
+
+      await notifyWorkspaceDeleted(ctx.db, {
+        recipientUserIds: workspaceToDelete.members.map((m) => m.userId),
+        actorUserId: ctx.session.user.id,
+        actorName,
+        workspaceId: workspaceToDelete.id,
+        workspaceTitle: workspaceToDelete.title,
+      });
+
       const deleted = await ctx.db.workspace.deleteMany({
         where: { id: input.id, ownerId: ctx.session.user.id },
       });
       if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
+
+      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+
       return true;
     }),
   getFolderInformation: authedProcedure
@@ -260,9 +525,11 @@ export const workspace = router({
       const user = await ctx.db.user.findFirst({ where: { id: ctx.session.user.id } });
       if (!user || !user.email) throw new TRPCError({ code: 'NOT_FOUND' });
       const sharedWith = await ctx.db.workspace.findMany({ where: { members: { some: { userId: ctx.session.user.id } } } });
-      const invitations = await ctx.db.workspaceInvitation.findMany({ where: { email: user.email, acceptedAt: null }, include: {
-        workspace: true,
-      } });
+      const invitations = await ctx.db.workspaceInvitation.findMany({
+        where: { email: user.email, acceptedAt: null }, include: {
+          workspace: true,
+        }
+      });
 
       return { shared: sharedWith, invitations };
     }),
@@ -281,6 +548,24 @@ export const workspace = router({
       // ensure workspace belongs to user
       const ws = await ctx.db.workspace.findFirst({ where: { id: input.id, ownerId: ctx.session.user.id } });
       if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
+
+      // Check storage limit
+      const workspaces = await ctx.db.workspace.findMany({
+        where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
+      });
+      const spaceUsed = await ctx.db.fileAsset.aggregate({
+        where: { workspaceId: { in: workspaces.map((w: any) => w.id) }, userId: ctx.session.user.id },
+        _sum: { size: true },
+      });
+      const storageLimit = await getUserStorageLimit(ctx.session.user.id);
+      const totalSize = input.files.reduce((acc, file) => acc + file.size, 0);
+      if ((spaceUsed._sum?.size ?? 0) + totalSize > storageLimit) {
+        logger.warn(`Storage limit exceeded for user ${ctx.session.user.id}. Used: ${spaceUsed._sum?.size}, Tried to upload: ${totalSize}, Limit: ${storageLimit}`);
+        throw new TRPCError({
+          code: 'FORBIDDEN',
+          message: `Storage limit exceeded. Maximum allowed storage is ${(storageLimit / (1024 * 1024 * 1024)).toFixed(1)}GB.`
+        });
+      }
       const results = [];
 
       for (const file of input.files) {
@@ -298,13 +583,13 @@ export const workspace = router({
         // 2. Generate signed URL for direct upload
         const objectKey = `${ctx.session.user.id}/${record.id}-${file.filename}`;
         const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
-          .from('files')
+          .from('media')
           .createSignedUploadUrl(objectKey); // 5 minutes
 
         if (signedUrlError) {
           throw new TRPCError({
             code: 'INTERNAL_SERVER_ERROR',
-            message: `Failed to generate upload URL: ${signedUrlError.message}`
+            message: `Failed to upload file`
           });
         }
 
@@ -312,7 +597,7 @@ export const workspace = router({
         await ctx.db.fileAsset.update({
           where: { id: record.id },
           data: {
-            bucket: 'files',
+            bucket: 'media',
             objectKey: objectKey,
           },
         });
@@ -347,7 +632,7 @@ export const workspace = router({
             .from(file.bucket)
             .remove([file.objectKey])
             .catch((err: unknown) => {
-              console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+              logger.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
             });
         }
       }
@@ -369,6 +654,23 @@ export const workspace = router({
       size: z.number(),
     }))
     .query(async ({ ctx, input }) => {
+      // Check storage limit
+      const workspaces = await ctx.db.workspace.findMany({
+        where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
+      });
+      const spaceUsed = await ctx.db.fileAsset.aggregate({
+        where: { workspaceId: { in: workspaces.map((w: any) => w.id) }, userId: ctx.session.user.id },
+        _sum: { size: true },
+      });
+      const storageLimit = await getUserStorageLimit(ctx.session.user.id);
+      if ((spaceUsed._sum?.size ?? 0) + input.size > storageLimit) {
+        logger.warn(`Storage limit exceeded for user ${ctx.session.user.id}. Used: ${spaceUsed._sum?.size}, Tried to upload: ${input.size}, Limit: ${storageLimit}`);
+        throw new TRPCError({
+          code: 'FORBIDDEN',
+          message: `Storage limit exceeded. Maximum allowed storage is ${(storageLimit / (1024 * 1024 * 1024)).toFixed(1)}GB.`
+        });
+      }
+
       const objectKey = `workspace_${ctx.session.user.id}/${input.workspaceId}-file_${input.filename}`;
       const fileAsset = await ctx.db.fileAsset.create({
         data: {
@@ -383,9 +685,10 @@ export const workspace = router({
       });
       const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
         .from('media')
-        .createSignedUploadUrl(objectKey); // 5 minutes
+        .createSignedUploadUrl(objectKey, { upsert: true });
       if (signedUrlError) {
-        throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to generate upload URL: ${signedUrlError.message}` });
+        logger.error('Signed upload URL error:', signedUrlError);
+        throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to create upload URL: ${signedUrlError.message}` });
       }
 
       await ctx.db.workspace.update({
@@ -398,7 +701,7 @@ export const workspace = router({
         uploadUrl: signedUrlData.signedUrl,
       };
     }),
-  uploadAndAnalyzeMedia: authedProcedure
+  uploadAndAnalyzeMedia: verifiedProcedure
     .input(z.object({
       workspaceId: z.string(),
       files: z.array(z.object({
@@ -414,7 +717,7 @@ export const workspace = router({
         where: { id: input.workspaceId, ownerId: ctx.session.user.id }
       });
       if (!workspace) {
-        console.error('❌ Workspace not found', { workspaceId: input.workspaceId, userId: ctx.session.user.id });
+        logger.error('Workspace not found', { workspaceId: input.workspaceId, userId: ctx.session.user.id });
         throw new TRPCError({ code: 'NOT_FOUND' });
       }
 
@@ -462,43 +765,18 @@ export const workspace = router({
           data: { fileBeingAnalyzed: true },
         });
 
-        PusherService.emitAnalysisProgress(input.workspaceId, {
-          status: 'starting',
-          filename: primaryFile.name,
-          fileType,
-          startedAt: new Date().toISOString(),
-          steps: {
-            fileUpload: { order: 1, status: 'pending' },
-          },
-        });
+        const genConfig = { generateStudyGuide: input.generateStudyGuide, generateFlashcards: input.generateFlashcards };
+
+        PusherService.emitAnalysisProgress(input.workspaceId,
+          buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig)
+        );
 
         try {
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'starting',
-            filename: primaryFile.name,
-            fileType,
-            startedAt: new Date().toISOString(),
-            steps: {
-              fileUpload: {
-                order: 1,
-                status: 'pending',
-              },
-              fileAnalysis: {
-                order: 2,
-                status: 'pending',
-              },
-              studyGuide: {
-                order: 3,
-                status: input.generateStudyGuide ? 'pending' : 'skipped',
-              },
-              flashcards: {
-                order: 4,
-                status: input.generateFlashcards ? 'pending' : 'skipped',
-              },
-            }
-          });
+          await updateAnalysisProgress(ctx.db, input.workspaceId,
+            buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig)
+          );
         } catch (error) {
-          console.error('❌ Failed to update analysis progress:', error);
+          logger.error('Failed to update analysis progress:', error);
           await ctx.db.workspace.update({
             where: { id: input.workspaceId },
             data: { fileBeingAnalyzed: false },
@@ -507,30 +785,9 @@ export const workspace = router({
           throw error;
         }
 
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'uploading',
-          filename: primaryFile.name,
-          fileType,
-          startedAt: new Date().toISOString(),
-          steps: {
-            fileUpload: {
-              order: 1,
-              status: 'in_progress',
-            },
-            fileAnalysis: {
-              order: 2,
-              status: 'pending',
-            },
-            studyGuide: {
-              order: 3,
-              status: input.generateStudyGuide ? 'pending' : 'skipped',
-            },
-            flashcards: {
-              order: 4,
-              status: input.generateFlashcards ? 'pending' : 'skipped',
-            },
-          }
-        });
+        await updateAnalysisProgress(ctx.db, input.workspaceId,
+          buildProgress('uploading', primaryFile.name, fileType, 'fileUpload', 'in_progress', genConfig)
+        );
 
         // Process all files using the new process_file endpoint
         for (const file of files) {
@@ -550,7 +807,7 @@ export const workspace = router({
             });
             throw new TRPCError({
               code: 'INTERNAL_SERVER_ERROR',
-              message: `Failed to generate signed URL for file ${file.name}: ${signedUrlError.message}`
+              message: `Failed to upload file`
             });
           }
 
@@ -567,7 +824,7 @@ export const workspace = router({
             currentFileType,
             maxPages
           );
-          
+
           if (processResult.status === 'error') {
             logger.error(`Failed to process file ${file.name}:`, processResult.error);
             // Continue processing other files even if one fails
@@ -589,30 +846,9 @@ export const workspace = router({
           }
         }
 
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'analyzing',
-          filename: primaryFile.name,
-          fileType,
-          startedAt: new Date().toISOString(),
-          steps: {
-            fileUpload: {
-              order: 1,
-              status: 'completed',
-            },
-            fileAnalysis: {
-              order: 2,
-              status: 'in_progress',
-            },
-            studyGuide: {
-              order: 3,
-              status: input.generateStudyGuide ? 'pending' : 'skipped',
-            },
-            flashcards: {
-              order: 4,
-              status: input.generateFlashcards ? 'pending' : 'skipped',
-            },
-          }
-        });
+        await updateAnalysisProgress(ctx.db, input.workspaceId,
+          buildProgress('analyzing', primaryFile.name, fileType, 'fileAnalysis', 'in_progress', genConfig)
+        );
 
         try {
           // Analyze all files - use PDF analysis if any file is a PDF, otherwise use image analysis
@@ -626,57 +862,17 @@ export const workspace = router({
           //   }
           // }
 
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'generating_artifacts',
-            filename: primaryFile.name,
-            fileType,
-            startedAt: new Date().toISOString(),
-            steps: {
-              fileUpload: {
-                order: 1,
-                status: 'completed',
-              },
-              fileAnalysis: {
-                order: 2,
-                status: 'completed',
-              },
-              studyGuide: {
-                order: 3,
-                status: input.generateStudyGuide ? 'pending' : 'skipped',
-              },
-              flashcards: {
-                order: 4,
-                status: input.generateFlashcards ? 'pending' : 'skipped',
-              },
-            }
-          });
+          await updateAnalysisProgress(ctx.db, input.workspaceId,
+            buildProgress('generating_artifacts', primaryFile.name, fileType, 'studyGuide', 'pending', genConfig)
+          );
         } catch (error) {
-          console.error('❌ Failed to analyze files:', error);
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'error',
-            filename: primaryFile.name,
-            fileType,
-            error: `Failed to analyze ${fileType}: ${error}`,
-            startedAt: new Date().toISOString(),
-            steps: {
-              fileUpload: {
-                order: 1,
-                status: 'completed',
-              },
-              fileAnalysis: {
-                order: 2,
-                status: 'error',
-              },
-              studyGuide: {
-                order: 3,
-                status: 'skipped',
-              },
-              flashcards: {
-                order: 4,
-                status: 'skipped',
-              },
-            }
-          });
+          logger.error('Failed to analyze files:', error);
+          await updateAnalysisProgress(ctx.db, input.workspaceId,
+            buildProgress('error', primaryFile.name, fileType, 'fileAnalysis', 'error', genConfig, {
+              error: `Failed to analyze ${fileType}: ${error}`,
+              studyGuide: 'skipped', flashcards: 'skipped',
+            })
+          );
           await ctx.db.workspace.update({
             where: { id: input.workspaceId },
             data: { fileBeingAnalyzed: false },
@@ -700,142 +896,180 @@ export const workspace = router({
           }
         };
 
-        // Generate artifacts
+        // Ensure AI session is initialized before generating artifacts
+        try {
+          await aiSessionService.initSession(input.workspaceId, ctx.session.user.id);
+        } catch (initError) {
+          logger.error('Failed to init AI session (continuing with workspace context):', initError);
+        }
+
+        // Fetch current usage and limits to enforce plan restrictions for auto-generation
+        const [usage, limits] = await Promise.all([
+          getUserUsage(ctx.session.user.id),
+          getUserPlanLimits(ctx.session.user.id)
+        ]);
+
+        // Generate artifacts - each step is isolated so failures don't block subsequent steps
         if (input.generateStudyGuide) {
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'generating_study_guide',
-            filename: primaryFile.name,
-            fileType,
-            startedAt: new Date().toISOString(),
-            steps: {
-              fileUpload: {
-                order: 1,
-                status: 'completed',
-              },
-              fileAnalysis: {
-                order: 2,
-                status: 'completed',
-              },
-              studyGuide: {
-                order: 3,
-                status: 'in_progress',
-              },
-              flashcards: {
-                order: 4,
-                status: input.generateFlashcards ? 'pending' : 'skipped',
-              },
-            }
-          });
+          // Enforcement: Skip if limit reached
+          if (limits && usage.studyGuides >= limits.maxStudyGuides) {
+            await updateAnalysisProgress(ctx.db, input.workspaceId,
+              buildProgress('skipped', primaryFile.name, fileType, 'studyGuide', 'skipped', genConfig)
+            );
+            await PusherService.emitError(input.workspaceId, 'Study guide skipped: Limit reached.', 'study_guide');
+            await notifyArtifactFailed(ctx.db, {
+              userId: ctx.session.user.id,
+              workspaceId: input.workspaceId,
+              artifactType: ArtifactType.STUDY_GUIDE,
+              message: 'Study guide was skipped because your plan limit was reached.',
+            }).catch(() => {});
+          } else {
+            try {
+              await updateAnalysisProgress(ctx.db, input.workspaceId,
+                buildProgress('generating_study_guide', primaryFile.name, fileType, 'studyGuide', 'in_progress', genConfig)
+              );
 
-          const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
+              const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
 
-          let artifact = await ctx.db.artifact.findFirst({
-            where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
-          });
-          if (!artifact) {
-            const fileNames = files.map(f => f.name).join(', ');
-            artifact = await ctx.db.artifact.create({
-              data: {
-                workspaceId: input.workspaceId,
-                type: ArtifactType.STUDY_GUIDE,
-                title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
-                createdById: ctx.session.user.id,
-              },
-            });
-          }
+              let artifact = await ctx.db.artifact.findFirst({
+                where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
+              });
+              if (!artifact) {
+                artifact = await ctx.db.artifact.create({
+                  data: {
+                    workspaceId: input.workspaceId,
+                    type: ArtifactType.STUDY_GUIDE,
+                    title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
+                    createdById: ctx.session.user.id,
+                  },
+                });
+              }
 
-          const lastVersion = await ctx.db.artifactVersion.findFirst({
-            where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
-            orderBy: { version: 'desc' },
-          });
+              const lastVersion = await ctx.db.artifactVersion.findFirst({
+                where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
+                orderBy: { version: 'desc' },
+              });
 
-          await ctx.db.artifactVersion.create({
-            data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
-          });
+              await ctx.db.artifactVersion.create({
+                data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
+              });
 
-          results.artifacts.studyGuide = artifact;
+              results.artifacts.studyGuide = artifact;
+              await PusherService.emitStudyGuideComplete(input.workspaceId, artifact);
+              await notifyArtifactReady(ctx.db, {
+                userId: ctx.session.user.id,
+                workspaceId: input.workspaceId,
+                artifactId: artifact.id,
+                artifactType: ArtifactType.STUDY_GUIDE,
+                title: artifact.title,
+              }).catch(() => {});
+            } catch (sgError) {
+              logger.error('Study guide generation failed after retries:', sgError);
+              await PusherService.emitError(input.workspaceId, 'Study guide generation failed. Please try regenerating later.', 'study_guide');
+              await notifyArtifactFailed(ctx.db, {
+                userId: ctx.session.user.id,
+                workspaceId: input.workspaceId,
+                artifactType: ArtifactType.STUDY_GUIDE,
+                message: 'Study guide generation failed. Please try regenerating later.',
+              }).catch(() => {});
+              // Continue to flashcards - don't abort the whole pipeline
+            }
+          }
         }
 
         if (input.generateFlashcards) {
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'generating_flashcards',
-            filename: primaryFile.name,
-            fileType,
-            startedAt: new Date().toISOString(),
-            steps: {
-              fileUpload: {
-                order: 1,
-                status: 'completed',
-              },
-              fileAnalysis: {
-                order: 2,
-                status: 'completed',
-              },
-              studyGuide: {
-                order: 3,
-                status: input.generateStudyGuide ? 'completed' : 'skipped',
-              },
-              flashcards: {
-                order: 4,
-                status: 'in_progress',
-              },
-            }
-          });
-
-          const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
-
-          const artifact = await ctx.db.artifact.create({
-            data: {
+          // Enforcement: Skip if limit reached
+          if (limits && usage.flashcards >= limits.maxFlashcards) {
+            await updateAnalysisProgress(ctx.db, input.workspaceId,
+              buildProgress('skipped', primaryFile.name, fileType, 'flashcards', 'skipped', genConfig)
+            );
+            await PusherService.emitError(input.workspaceId, 'Flashcards skipped: Limit reached.', 'flashcards');
+            await notifyArtifactFailed(ctx.db, {
+              userId: ctx.session.user.id,
               workspaceId: input.workspaceId,
-              type: ArtifactType.FLASHCARD_SET,
-              title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
-              createdById: ctx.session.user.id,
-            },
-          });
-
-          // Parse JSON flashcard content
-          try {
-            const flashcardData: any = content;
+              artifactType: ArtifactType.FLASHCARD_SET,
+              message: 'Flashcards were skipped because your plan limit was reached.',
+            }).catch(() => {});
+          } else {
+            try {
+              const sgStatus = input.generateStudyGuide ? (results.artifacts.studyGuide ? 'completed' : 'error') : 'skipped';
+              await updateAnalysisProgress(ctx.db, input.workspaceId,
+                buildProgress('generating_flashcards', primaryFile.name, fileType, 'flashcards', 'in_progress', genConfig,
+                  { studyGuide: sgStatus } as any)
+              );
 
-            let createdCards = 0;
-            for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
-              const card = flashcardData[i];
-              const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
-              const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
+              const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
 
-              await ctx.db.flashcard.create({
+              const artifact = await ctx.db.artifact.create({
                 data: {
-                  artifactId: artifact.id,
-                  front: front,
-                  back: back,
-                  order: i,
-                  tags: ['ai-generated', 'medium'],
+                  workspaceId: input.workspaceId,
+                  type: ArtifactType.FLASHCARD_SET,
+                  title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
+                  createdById: ctx.session.user.id,
                 },
               });
-              createdCards++;
-            }
 
-          } catch (parseError) {
-            // Fallback to text parsing if JSON fails
-            const lines = content.split('\n').filter(line => line.trim());
-            for (let i = 0; i < Math.min(lines.length, 10); i++) {
-              const line = lines[i];
-              if (line.includes(' - ')) {
-                const [front, back] = line.split(' - ');
-                await ctx.db.flashcard.create({
-                  data: {
-                    artifactId: artifact.id,
-                    front: front.trim(),
-                    back: back.trim(),
-                    order: i,
-                    tags: ['ai-generated', 'medium'],
-                  },
-                });
+              // Parse JSON flashcard content
+              try {
+                const parsed = typeof content === 'string' ? JSON.parse(content) : content;
+                const flashcardData = Array.isArray(parsed) ? parsed : (parsed.flashcards || []);
+
+                for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
+                  const card = flashcardData[i];
+                  const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
+                  const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
+
+                  await ctx.db.flashcard.create({
+                    data: {
+                      artifactId: artifact.id,
+                      front: front,
+                      back: back,
+                      order: i,
+                      tags: ['ai-generated', 'medium'],
+                    },
+                  });
+                }
+              } catch (parseError) {
+                console.error("Failed to parse flashcard JSON or create cards in workspace router:", parseError);
+                // Fallback to text parsing if JSON fails
+                const lines = content.split('\n').filter((line: string) => line.trim());
+                for (let i = 0; i < Math.min(lines.length, 10); i++) {
+                  const line = lines[i];
+                  if (line.includes(' - ')) {
+                    const [front, back] = line.split(' - ');
+                    await ctx.db.flashcard.create({
+                      data: {
+                        artifactId: artifact.id,
+                        front: front.trim(),
+                        back: back.trim(),
+                        order: i,
+                        tags: ['ai-generated', 'medium'],
+                      },
+                    });
+                  }
+                }
               }
+
+              results.artifacts.flashcards = artifact;
+              await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
+              await notifyArtifactReady(ctx.db, {
+                userId: ctx.session.user.id,
+                workspaceId: input.workspaceId,
+                artifactId: artifact.id,
+                artifactType: ArtifactType.FLASHCARD_SET,
+                title: artifact.title,
+              }).catch(() => {});
+            } catch (fcError) {
+              logger.error('Flashcard generation failed after retries:', fcError);
+              await PusherService.emitError(input.workspaceId, 'Flashcard generation failed. Please try regenerating later.', 'flashcards');
+              await notifyArtifactFailed(ctx.db, {
+                userId: ctx.session.user.id,
+                workspaceId: input.workspaceId,
+                artifactType: ArtifactType.FLASHCARD_SET,
+                message: 'Flashcard generation failed. Please try regenerating later.',
+              }).catch(() => {});
             }
           }
-
-          results.artifacts.flashcards = artifact;
         }
 
         await ctx.db.workspace.update({
@@ -844,34 +1078,12 @@ export const workspace = router({
         });
 
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'completed',
-          filename: primaryFile.name,
-          fileType,
-          startedAt: new Date().toISOString(),
+          ...buildProgress('completed', primaryFile.name, fileType, 'flashcards', 'completed', genConfig),
           completedAt: new Date().toISOString(),
-          steps: {
-            fileUpload: {
-              order: 1,
-              status: 'completed',
-            },
-            fileAnalysis: {
-              order: 2,
-              status: 'completed',
-            },
-            studyGuide: {
-              order: 3,
-              status: input.generateStudyGuide ? 'completed' : 'skipped',
-            },
-            flashcards: {
-              order: 4,
-              status: input.generateFlashcards ? 'completed' : 'skipped',
-            },
-          }
-
         });
         return results;
       } catch (error) {
-        console.error('❌ Failed to update analysis progress:', error);
+        logger.error('Failed to update analysis progress:', error);
         await ctx.db.workspace.update({
           where: { id: input.workspaceId },
           data: { fileBeingAnalyzed: false },
@@ -883,51 +1095,49 @@ export const workspace = router({
   search: authedProcedure
     .input(z.object({
       query: z.string(),
+      color: z.string().optional(),
       limit: z.number().min(1).max(100).default(20),
     }))
     .query(async ({ ctx, input }) => {
-      const { query } = input;
+      const { query, color } = input;
+
+      // 1. Search Workspaces
       const workspaces = await ctx.db.workspace.findMany({
         where: {
           ownerId: ctx.session.user.id,
-          OR: [
-            {
-              title: {
-                contains: query,
-                mode: 'insensitive',
-              },
-            },
-            {
-              description: {
-                contains: query,
-                mode: 'insensitive',
-              },
-            },
-          ],
-        },
-        orderBy: {
-          updatedAt: 'desc',
+          markerColor: color || undefined,
+          ...(query ? {
+            OR: [
+              { title: { contains: query, mode: 'insensitive' } },
+              { description: { contains: query, mode: 'insensitive' } },
+            ],
+          } : {}),
         },
+        orderBy: { updatedAt: 'desc' },
         take: input.limit,
       });
 
-      // Update analysisProgress for each workspace with search metadata
-      const workspaceUpdates = workspaces.map(ws =>
-        ctx.db.workspace.update({
-          where: { id: ws.id },
-          data: {
-            analysisProgress: {
-              lastSearched: new Date().toISOString(),
-              searchQuery: query,
-              matchedIn: ws.title.toLowerCase().includes(query.toLowerCase()) ? 'title' : 'description',
-            }
-          }
-        })
-      );
+      // 2. Search Folders
+      const folders = await ctx.db.folder.findMany({
+        where: {
+          ownerId: ctx.session.user.id,
+          markerColor: color || undefined,
+          ...(query ? {
+            name: { contains: query, mode: 'insensitive' },
+          } : {}),
+        },
+        orderBy: { updatedAt: 'desc' },
+        take: input.limit,
+      });
 
-      await Promise.all(workspaceUpdates);
+      // Combined results with type discriminator
+      const results = [
+        ...workspaces.map((w: any) => ({ ...w, type: 'workspace' as const })),
+        ...folders.map((f: any) => ({ ...f, type: 'folder' as const, title: f.name })), // normalize name to title
+      ].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+        .slice(0, input.limit);
 
-      return workspaces;
+      return results;
     }),
 
   // Members sub-router