fix: scheduled task storage and indexeddb optimization

- Add scheduledTaskId field to task creation for proper linking
- Implement debounce mechanism (300ms) for IndexedDB saves during task execution
- Save immediately when task ends (done/error/abort status)
- Fix detail panel reset when continuing conversation from history
- Bump version to 0.0.11

Author: lsustc

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-browser",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "DeepFundAI Browser - AI-Powered Intelligent Browser",
   "author": "Shuai Liu <lsustc@mail.ustc.edu.cn>",
   "private": true,

src/hooks/useMessageHandlers.ts

@@ -8,13 +8,16 @@ import { detectFileType } from '@/utils/fileDetection';
 
 interface UseMessageHandlersOptions {
   isHistoryMode: boolean;
+  isTaskDetailMode: boolean;
+  scheduledTaskId?: string;
   taskIdRef: React.RefObject<string>;
   messageProcessorRef: React.RefObject<MessageProcessor>;
   currentTaskId: string;
   tasks: Task[];
   showDetailAgents: string[];
   toolHistory: any[];
   updateTask: (taskId: string, updates: Partial<Task>) => void;
+  createTask: (taskId: string, initialData: Partial<Task>) => void;
   replaceTaskId: (oldTaskId: string, newTaskId: string) => void;
   setCurrentTaskId: (taskId: string) => void;
   setCurrentTool: (tool: { toolName: string; operation: string; status: 'running' | 'completed' | 'error' } | null) => void;
@@ -28,13 +31,16 @@ interface UseMessageHandlersOptions {
  */
 export const useMessageHandlers = ({
   isHistoryMode,
+  isTaskDetailMode,
+  scheduledTaskId,
   taskIdRef,
   messageProcessorRef,
   currentTaskId,
   tasks,
   showDetailAgents,
   toolHistory,
   updateTask,
+  createTask,
   replaceTaskId,
   setCurrentTaskId,
   setCurrentTool,
@@ -175,22 +181,44 @@ export const useMessageHandlers = ({
     if (message.taskId && !currentTaskId && !message.taskId.startsWith('temp-')) {
       setCurrentTaskId(message.taskId);
     }
+
     const taskIdToUpdate = message.taskId || taskIdRef.current;
     if (taskIdToUpdate) {
-      const updates: Partial<Task> = {
-        messages: updatedMessages
-      };
+      const existingTask = tasks.find(task => task.id === taskIdToUpdate);
 
-      if (message.type === 'workflow' && message.workflow?.name) {
-        updates.name = message.workflow.name;
-        updates.workflow = message.workflow;
-      }
+      if (existingTask) {
+        const updates: Partial<Task> = {
+          messages: updatedMessages
+        };
 
-      if (message.type === 'error') {
-        updates.status = 'error';
-      }
+        if (message.type === 'workflow' && message.workflow?.name) {
+          updates.name = message.workflow.name;
+          updates.workflow = message.workflow;
+        }
+
+        if (message.type === 'error') {
+          updates.status = 'error';
+        }
 
-      updateTask(taskIdToUpdate, updates);
+        updateTask(taskIdToUpdate, updates);
+      } else {
+        // Task doesn't exist, create it
+        const initialData: Partial<Task> = {
+          name: (message.type === 'workflow' && message.workflow?.name)
+            ? message.workflow.name
+            : `Task ${taskIdToUpdate.slice(0, 8)}`,
+          workflow: (message.type === 'workflow' && message.workflow) ? message.workflow : undefined,
+          messages: updatedMessages,
+          status: 'running',
+          taskType: isTaskDetailMode ? 'scheduled' : 'normal',
+          scheduledTaskId: isTaskDetailMode ? scheduledTaskId : undefined,
+          startTime: new Date(),
+        };
+
+        taskIdRef.current = taskIdToUpdate;
+        setCurrentTaskId(taskIdToUpdate);
+        createTask(taskIdToUpdate, initialData);
+      }
     }
 
     if (message.type.includes('tool')) {

src/hooks/useTaskManager.ts

@@ -1,4 +1,4 @@
-import { useState, useCallback } from 'react';
+import { useState, useCallback, useRef } from 'react';
 import { Task, DisplayMessage } from '@/models';
 import { taskStorage } from '@/services/task-storage';
 
@@ -30,14 +30,39 @@ export const useTaskManager = (): UseTaskManagerReturn => {
   const [currentTaskId, setCurrentTaskId] = useState<string>('');
   const [isHistoryMode, setIsHistoryMode] = useState<boolean>(false);
 
+  // Debounce timers for each task
+  const saveTaskTimers = useRef<Map<string, NodeJS.Timeout>>(new Map());
+
   // Computed properties
   const currentTask = tasks.find(task => task.id === currentTaskId);
   const messages = currentTask?.messages || [];
 
-  // Automatically save tasks to IndexedDB
-  const saveTask = useCallback(async (task: Task) => {
+  // Save task with debounce optimization
+  const saveTask = useCallback(async (task: Task, immediate = false) => {
     try {
-      await taskStorage.saveTask(task);
+      if (immediate) {
+        // Immediate save (when task ends)
+        const timer = saveTaskTimers.current.get(task.id);
+        if (timer) {
+          clearTimeout(timer);
+          saveTaskTimers.current.delete(task.id);
+        }
+        await taskStorage.saveTask(task);
+        return;
+      }
+
+      // Debounced save (during task execution)
+      const existingTimer = saveTaskTimers.current.get(task.id);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+
+      const timer = setTimeout(async () => {
+        await taskStorage.saveTask(task);
+        saveTaskTimers.current.delete(task.id);
+      }, 300); // 300ms debounce
+
+      saveTaskTimers.current.set(task.id, timer);
     } catch (error) {
       console.error('Failed to save task:', error);
     }
@@ -60,8 +85,11 @@ export const useTaskManager = (): UseTaskManagerReturn => {
         };
         updatedTasks[existingTaskIndex] = updatedTask;
 
-        // Asynchronous save
-        saveTask(updatedTask);
+        // Check if task has ended (status changed to done/error/abort)
+        const isTaskEnded = updates.status && ['done', 'error', 'abort'].includes(updates.status);
+
+        // Save immediately if task ended, otherwise use debounce
+        saveTask(updatedTask, isTaskEnded);
 
         return updatedTasks;
       }

src/pages/main.tsx

@@ -151,13 +151,16 @@ export default function main() {
         getToolStatus,
     } = useMessageHandlers({
         isHistoryMode,
+        isTaskDetailMode,
+        scheduledTaskId: scheduledTaskIdFromUrl,
         taskIdRef,
         messageProcessorRef,
         currentTaskId,
         tasks,
         showDetailAgents,
         toolHistory,
         updateTask,
+        createTask,
         replaceTaskId,
         setCurrentTaskId,
         setCurrentTool,
@@ -219,57 +222,59 @@ export default function main() {
             return;
         }
 
-        try {
-            // Stop playback before continuing conversation
-            playback.stop();
+        // Stop playback before continuing conversation
+        playback.stop();
 
-            // Check if task has workflow
-            if (!currentTask.workflow) {
-                antdMessage.error(t('task_missing_context'));
-                console.error('Task missing workflow:', currentTask);
-                return;
-            }
+        // Check if task has workflow
+        if (!currentTask.workflow) {
+            antdMessage.error(t('task_missing_context'));
+            console.error('Task missing workflow:', currentTask);
+            return;
+        }
 
-            // Restore task context
-            const result = await (window.api as any).ekoRestoreTask(
-                currentTask.workflow,
-                currentTask.contextParams || {},
-                currentTask.chainPlanRequest,
-                currentTask.chainPlanResult
-            );
+        // Restore task context
+        const result = await (window.api as any).ekoRestoreTask(
+            currentTask.workflow,
+            currentTask.contextParams || {},
+            currentTask.chainPlanRequest,
+            currentTask.chainPlanResult
+        );
 
-            if (!result || !result.success) {
-                throw new Error('Failed to restore task context');
-            }
+        if (!result?.success) {
+            antdMessage.error(t('continue_conversation_failed'));
+            return;
+        }
 
-            // Call base handler (exits history mode, generates execution ID)
-            await handleContinueConversationBase(currentTask);
+        // Call base handler (exits history mode, generates execution ID)
+        await handleContinueConversationBase(currentTask);
 
-            // Update UI states
-            setIsViewingAttachment(false);
-            setCurrentTaskId(currentTask.id);
-            taskIdRef.current = currentTask.id;
+        // Update UI states
+        setIsViewingAttachment(false);
+        setCurrentTaskId(currentTask.id);
+        taskIdRef.current = currentTask.id;
 
-            // Restore lastUrl if available (but don't auto-expand detail panel)
-            if (currentTask.lastUrl) {
-                setCurrentUrl(currentTask.lastUrl);
-            }
+        // Reset detail panel: hide playback screenshot
+        setCurrentHistoryIndex(-1);
+        await (window.api as any).hideHistoryView?.();
 
-            // Restore tool history
-            setToolHistory(currentTask.toolHistory || []);
+        // Restore lastUrl and navigate detail view to initial address
+        if (currentTask.lastUrl) {
+            setCurrentUrl(currentTask.lastUrl);
+            await (window.api as any).setDetailViewVisible?.(true);
+            await (window.api as any).navigateDetailView?.(currentTask.lastUrl);
+        }
 
-            // Restore historical messages to MessageProcessor
-            if (currentTask.messages && currentTask.messages.length > 0) {
-                messageProcessorRef.current.setMessages(currentTask.messages);
-            }
+        // Restore tool history
+        setToolHistory(currentTask.toolHistory || []);
 
-            antdMessage.success(t('conversation_continued'));
-        } catch (error) {
-            console.error('Failed to continue conversation:', error);
-            antdMessage.error(t('continue_conversation_failed'));
+        // Restore historical messages to MessageProcessor
+        if (currentTask.messages && currentTask.messages.length > 0) {
+            messageProcessorRef.current.setMessages(currentTask.messages);
         }
+
+        antdMessage.success(t('conversation_continued'));
     }, [currentTask, playback, handleContinueConversationBase, antdMessage, t, setIsViewingAttachment,
-        setCurrentTaskId, taskIdRef, setCurrentUrl, setShowDetail, setToolHistory, messageProcessorRef]);
+        setCurrentTaskId, taskIdRef, setCurrentUrl, setShowDetail, setToolHistory, setCurrentHistoryIndex, messageProcessorRef]);
 
     // Synchronize taskIdRef
     useEffect(() => {