feat(开发任务): 状态流转接入单条工作流

apps/web/stores/useDevTaskStore.ts

@@ -1,37 +1,30 @@
 'use client';
 import { create } from 'zustand';
 import type { DevTask, DevTaskStatus } from '@/lib/dev-task';
-import { canTransition, generateTaskNo, isLegacyTask } from '@/lib/dev-task';
-import { findTasksToAutoStart, deriveActualStartAt } from '@/lib/dev-task-transitions';
+import { generateTaskNo, isLegacyTask } from '@/lib/dev-task';
+import { applyDevTaskTransition, normalizeDevTaskOnCreate } from '@/lib/dev-task-workflow';
+import { loadServerData, saveServerData } from '@/lib/server-data';
 
-const STORAGE_KEY = 'ftb_dev_tasks_v2';
-const LEGACY_KEY = 'ftb_dev_tasks_v1';
-
-function saveLocal(items: DevTask[]) {
-  try { localStorage.setItem(STORAGE_KEY, JSON.stringify(items)); } catch {}
+function saveStored(items: DevTask[]) {
+  saveServerData('dev-tasks', items).catch(() => {});
 }
 
-function loadLocal(): DevTask[] | null {
+async function loadStored(): Promise<DevTask[] | null> {
   try {
-    const raw = localStorage.getItem(STORAGE_KEY);
-    if (raw) {
-      const parsed = JSON.parse(raw);
+    const parsed = await loadServerData<DevTask[]>('dev-tasks');
+    if (parsed) {
       if (Array.isArray(parsed) && parsed.some(isLegacyTask)) {
-        localStorage.removeItem(STORAGE_KEY);
         return null;
       }
       return parsed;
     }
-    if (localStorage.getItem(LEGACY_KEY)) {
-      localStorage.removeItem(LEGACY_KEY);
-    }
   } catch {}
   return null;
 }
 
 interface DevTaskState {
   tasks: DevTask[];
-  fetchTasks: () => void;
+  fetchTasks: () => Promise<void>;
   createTask: (data: Omit<DevTask, 'id' | 'taskNo' | 'createdAt' | 'updatedAt' | 'isBlocked'>) => DevTask;
   updateTask: (id: string, data: Partial<DevTask>) => void;
   deleteTask: (id: string) => void;
@@ -45,72 +38,51 @@ interface DevTaskState {
 export const useDevTaskStore = create<DevTaskState>((set, get) => ({
   tasks: [],
 
-  fetchTasks: () => {
-    const cached = loadLocal();
-    const list = cached ?? [];
-    const now = new Date();
-    const autoStarts = findTasksToAutoStart(list, now);
-    if (autoStarts.length > 0) {
-      const map = new Map(autoStarts.map((a) => [a.taskId, a.actualStartAt]));
-      const updated = list.map((t) =>
-        map.has(t.id)
-          ? { ...t, status: 'in_progress' as DevTaskStatus, actualStartAt: map.get(t.id)!, updatedAt: now.toISOString() }
-          : t,
-      );
-      set({ tasks: updated });
-      saveLocal(updated);
-    } else {
-      set({ tasks: list });
-    }
+  fetchTasks: async () => {
+    const cached = await loadStored();
+    set({ tasks: cached ?? [] });
   },
 
   createTask: (data) => {
     const list = get().tasks;
     const now = new Date().toISOString();
-    const task: DevTask = {
+    const task: DevTask = normalizeDevTaskOnCreate({
       ...data,
       id: `task-${Date.now()}`,
       taskNo: generateTaskNo(list),
       isBlocked: false,
       createdAt: now,
       updatedAt: now,
-    };
+    } as DevTask);
     const updated = [...list, task];
     set({ tasks: updated });
-    saveLocal(updated);
+    saveStored(updated);
     return task;
   },
 
   updateTask: (id, data) => {
     const updated = get().tasks.map((t) =>
-      t.id === id ? { ...t, ...data, updatedAt: new Date().toISOString() } : t,
+      t.id === id ? { ...t, ...data, aiDraft: false, updatedAt: new Date().toISOString() } : t,
     );
     set({ tasks: updated });
-    saveLocal(updated);
+    saveStored(updated);
   },
 
   deleteTask: (id) => {
     const updated = get().tasks.filter((t) => t.id !== id);
     set({ tasks: updated });
-    saveLocal(updated);
+    saveStored(updated);
   },
 
   changeStatus: (id, to, opts) => {
     const task = get().tasks.find((t) => t.id === id);
     if (!task) return { ok: false, message: '任务不存在' };
-    if (!canTransition(task.status, to)) {
-      return { ok: false, message: `不允许从「${task.status}」流转到「${to}」` };
-    }
-    const now = new Date();
-    const patch: Partial<DevTask> = { status: to };
-    if (to === 'in_progress' && !task.actualStartAt) {
-      patch.actualStartAt = deriveActualStartAt(task, 'manual', now);
-      if (opts?.delayReason) patch.delayReason = opts.delayReason;
-    }
-    if (to === 'submitted') {
-      patch.actualEndAt = now.toISOString();
-    }
-    get().updateTask(id, patch);
+    const result = applyDevTaskTransition(task, to, {
+      now: new Date(),
+      delayReason: opts?.delayReason,
+    });
+    if (!result.ok || !result.patch) return { ok: false, message: result.message };
+    get().updateTask(id, result.patch);
     return { ok: true };
   },