@goscribe/server 1.2.0 → 1.3.1

package/dist/routers/workspace.js

@@ -1,12 +1,15 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
-import { router, authedProcedure } from '../trpc.js';
+import { router, 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 { 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(db, workspaceId, progress) {
     await db.workspace.update({
@@ -15,6 +18,48 @@ async function updateAnalysisProgress(db, workspaceId, progress) {
     });
     await PusherService.emitAnalysisProgress(workspaceId, progress);
 }
+const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'];
+function buildProgressSteps(currentStep, currentStatus, config, overrides) {
+    const stepIndex = PIPELINE_STEPS.indexOf(currentStep);
+    const steps = {};
+    for (let i = 0; i < PIPELINE_STEPS.length; i++) {
+        const step = PIPELINE_STEPS[i];
+        let status;
+        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, filename, fileType, currentStep, currentStepStatus, config, extra) {
+    return {
+        status,
+        filename,
+        fileType,
+        startedAt: new Date().toISOString(),
+        steps: buildProgressSteps(currentStep, currentStepStatus, config, extra),
+        ...extra,
+    };
+}
 // Helper function to calculate search relevance score
 function calculateRelevance(query, ...texts) {
     const queryLower = query.toLowerCase();
@@ -71,6 +116,38 @@ 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),
@@ -98,7 +175,10 @@ 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
@@ -116,16 +196,24 @@ 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
@@ -134,6 +222,7 @@ 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
@@ -166,15 +255,111 @@ export const workspace = router({
             orderBy: { updatedAt: 'desc' },
         });
         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) => 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();
+        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 = [];
+        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
@@ -182,7 +367,7 @@ export const workspace = router({
         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 }) => {
@@ -196,10 +381,12 @@ 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
@@ -207,11 +394,37 @@ 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
@@ -243,9 +456,11 @@ export const workspace = router({
         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: {
+        const invitations = await ctx.db.workspaceInvitation.findMany({
+            where: { email: user.email, acceptedAt: null }, include: {
                 workspace: true,
-            } });
+            }
+        });
         return { shared: sharedWith, invitations };
     }),
     uploadFiles: authedProcedure
@@ -262,6 +477,23 @@ export const workspace = router({
         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) => 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) {
             // 1. Insert into DB
@@ -277,19 +509,19 @@ 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`
                 });
             }
             // 3. Update record with bucket info
             await ctx.db.fileAsset.update({
                 where: { id: record.id },
                 data: {
-                    bucket: 'files',
+                    bucket: 'media',
                     objectKey: objectKey,
                 },
             });
@@ -321,7 +553,7 @@ export const workspace = router({
                     .from(file.bucket)
                     .remove([file.objectKey])
                     .catch((err) => {
-                    console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+                    logger.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
                 });
             }
         }
@@ -342,6 +574,22 @@ 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) => 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: {
@@ -356,9 +604,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({
             where: { id: input.workspaceId },
@@ -369,7 +618,7 @@ export const workspace = router({
             uploadUrl: signedUrlData.signedUrl,
         };
     }),
-    uploadAndAnalyzeMedia: authedProcedure
+    uploadAndAnalyzeMedia: verifiedProcedure
         .input(z.object({
         workspaceId: z.string(),
         files: z.array(z.object({
@@ -385,7 +634,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' });
         }
         // Check if analysis is already in progress
@@ -427,43 +676,13 @@ export const workspace = router({
                 where: { id: input.workspaceId },
                 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 },
@@ -471,30 +690,7 @@ export const workspace = router({
                 await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
                 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) {
                 // TypeScript: We already validated bucket and objectKey exist above
@@ -511,7 +707,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`
                     });
                 }
                 const fileUrl = signedUrlData.signedUrl;
@@ -539,30 +735,7 @@ 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
                 // const hasPDF = files.some(f => !f.mimeType.startsWith('image/'));
@@ -574,58 +747,14 @@ export const workspace = router({
                 //     await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id, file.id);
                 //   }
                 // }
-                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,
+                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}`,
-                    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',
-                        },
-                    }
-                });
+                    studyGuide: 'skipped', flashcards: 'skipped',
+                }));
                 await ctx.db.workspace.update({
                     where: { id: input.workspaceId },
                     data: { fileBeingAnalyzed: false },
@@ -640,164 +769,176 @@ export const workspace = router({
                     worksheet: null,
                 }
             };
-            // 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);
+                        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' },
+                        });
+                        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;
+                        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(() => { });
                     }
-                });
-                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: {
+                    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,
-                            type: ArtifactType.STUDY_GUIDE,
-                            title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
-                            createdById: ctx.session.user.id,
-                        },
-                    });
+                            artifactType: ArtifactType.STUDY_GUIDE,
+                            message: 'Study guide generation failed. Please try regenerating later.',
+                        }).catch(() => { });
+                        // Continue to flashcards - don't abort the whole pipeline
+                    }
                 }
-                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 },
-                });
-                results.artifacts.studyGuide = artifact;
             }
             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 = content;
-                    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}`;
-                        await ctx.db.flashcard.create({
+                        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 }));
+                        const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
+                        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) => 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({
                 where: { id: input.workspaceId },
                 data: { fileBeingAnalyzed: false },
             });
             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 },
@@ -809,46 +950,45 @@ 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',
-                        },
-                    },
-                ],
+                markerColor: color || undefined,
+                ...(query ? {
+                    OR: [
+                        { title: { contains: query, mode: 'insensitive' } },
+                        { description: { contains: query, mode: 'insensitive' } },
+                    ],
+                } : {}),
             },
-            orderBy: {
-                updatedAt: 'desc',
+            orderBy: { updatedAt: 'desc' },
+            take: input.limit,
+        });
+        // 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,
         });
-        // 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',
-                }
-            }
-        }));
-        await Promise.all(workspaceUpdates);
-        return workspaces;
+        // Combined results with type discriminator
+        const results = [
+            ...workspaces.map((w) => ({ ...w, type: 'workspace' })),
+            ...folders.map((f) => ({ ...f, type: 'folder', title: f.name })), // normalize name to title
+        ].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+            .slice(0, input.limit);
+        return results;
     }),
     // Members sub-router
     members,