@goscribe/server 1.2.0 → 1.3.1

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(
@@ -145,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),
@@ -173,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
@@ -191,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
@@ -209,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
@@ -241,16 +304,18 @@ 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,
       };
     }),
 
@@ -364,7 +429,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 }) => {
@@ -377,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
@@ -388,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
@@ -425,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 };
     }),
@@ -446,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) {
@@ -463,7 +583,7 @@ 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) {
@@ -477,7 +597,7 @@ export const workspace = router({
         await ctx.db.fileAsset.update({
           where: { id: record.id },
           data: {
-            bucket: 'files',
+            bucket: 'media',
             objectKey: objectKey,
           },
         });
@@ -534,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: {
@@ -548,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 upload file` });
+        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({
@@ -563,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({
@@ -686,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
@@ -758,108 +896,179 @@ export const workspace = router({
           }
         };
 
+        // 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) {
-          try {
+          // Enforcement: Skip if limit reached
+          if (limits && usage.studyGuides >= limits.maxStudyGuides) {
             await updateAnalysisProgress(ctx.db, input.workspaceId,
-              buildProgress('generating_study_guide', primaryFile.name, fileType, 'studyGuide', 'in_progress', genConfig)
+              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) {
-              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;
-          } 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');
-            // Continue to flashcards - don't abort the whole pipeline
+              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) {
-          try {
-            const sgStatus = input.generateStudyGuide ? (results.artifacts.studyGuide ? 'completed' : 'error') : 'skipped';
+          // Enforcement: Skip if limit reached
+          if (limits && usage.flashcards >= limits.maxFlashcards) {
             await updateAnalysisProgress(ctx.db, input.workspaceId,
-              buildProgress('generating_flashcards', primaryFile.name, fileType, 'flashcards', 'in_progress', genConfig,
-                { studyGuide: sgStatus } as any)
+              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,
+              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)
+              );
 
-            const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
+              const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
 
-            const artifact = await ctx.db.artifact.create({
-              data: {
-                workspaceId: input.workspaceId,
-                type: ArtifactType.FLASHCARD_SET,
-                title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
-                createdById: ctx.session.user.id,
-              },
-            });
+              const artifact = await ctx.db.artifact.create({
+                data: {
+                  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;
+              // 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}`;
+                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) {
-              // 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(),
+                      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;
-          } catch (fcError) {
-            logger.error('Flashcard generation failed after retries:', fcError);
-            await PusherService.emitError(input.workspaceId, 'Flashcard generation failed. Please try regenerating later.', 'flashcards');
+              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(() => {});
+            }
           }
         }
 
@@ -886,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