feat(v2.4): 切换计划与开发任务主写

apps/web/lib/domain-api.ts

@@ -1,6 +1,9 @@
 import { api } from './api';
+import type { DevTask, DevTaskStatus, Reference } from './dev-task';
 import type { Priority } from './derive';
 import type { Requirement, RequirementStatus, SourceType } from './requirement';
+import type { VersionPlan, VersionPlanLog, VersionPlanRequirementCoverage } from './version-plan';
+import type { WorkActivity, WorkActivityCategory, WorkActivitySourceType } from './work-activity';
 
 export interface RootProject {
   id: string;
@@ -147,6 +150,157 @@ export async function deleteRequirementByProductId(productId: string, requiremen
   await api.delete(`/products/${productId}/requirements/${requirementId}`);
 }
 
+interface DomainVersionPlanRow {
+  id: string;
+  versionId: string;
+  type: string;
+  title: string;
+  status?: string | null;
+  ownerId?: string | null;
+  expectedStartAt?: string | Date | null;
+  expectedEndAt?: string | Date | null;
+  actualStartAt?: string | Date | null;
+  completedAt?: string | Date | null;
+  resultUrl?: string | null;
+  requirementCoverage?: unknown;
+  logs?: unknown;
+  createdAt?: string | Date | null;
+}
+
+interface DomainDevTaskRow {
+  id: string;
+  versionId: string;
+  requirementId?: string | null;
+  categoryId?: string | null;
+  code: string;
+  title: string;
+  description?: string | null;
+  status?: string | null;
+  priority?: string | number | null;
+  assigneeId?: string | null;
+  creatorId?: string | null;
+  isBlocked?: boolean | null;
+  blockReason?: string | null;
+  expectedStartAt?: string | Date | null;
+  expectedEndAt?: string | Date | null;
+  startDate?: string | Date | null;
+  completedAt?: string | Date | null;
+  estimateHours?: number | null;
+  aiEstimateHours?: number | null;
+  references?: unknown;
+  aiDraft?: boolean | null;
+  aiDraftAt?: string | Date | null;
+  createdAt?: string | Date | null;
+  updatedAt?: string | Date | null;
+}
+
+interface DomainWorkActivityRow {
+  id: string;
+  actorId?: string | null;
+  actorName?: string | null;
+  sourceType: string;
+  sourceId: string;
+  action: string;
+  title: string;
+  metadata?: unknown;
+  occurredAt?: string | Date | null;
+}
+
+interface DomainMutationResponse<T> {
+  item: T;
+  activities?: DomainWorkActivityRow[];
+}
+
+export async function listVersionPlansByVersionId(versionId: string): Promise<VersionPlan[]> {
+  const rows = await api.get<DomainVersionPlanRow[]>(`/versions/${versionId}/plans`);
+  return rows.map(normalizeVersionPlan);
+}
+
+export async function createVersionPlanByVersionId(
+  versionId: string,
+  data: Partial<VersionPlan>,
+) {
+  return normalizeMutation(
+    await api.post<DomainMutationResponse<DomainVersionPlanRow>>(`/versions/${versionId}/plans`, toVersionPlanPayload(data)),
+    normalizeVersionPlan,
+  );
+}
+
+export async function updateVersionPlanByVersionId(
+  versionId: string,
+  planId: string,
+  data: Partial<VersionPlan>,
+) {
+  return normalizeMutation(
+    await api.patch<DomainMutationResponse<DomainVersionPlanRow>>(`/versions/${versionId}/plans/${planId}`, toVersionPlanPayload(data)),
+    normalizeVersionPlan,
+  );
+}
+
+export async function completeVersionPlanByVersionId(
+  versionId: string,
+  planId: string,
+  data: Partial<VersionPlan>,
+) {
+  return normalizeMutation(
+    await api.patch<DomainMutationResponse<DomainVersionPlanRow>>(`/versions/${versionId}/plans/${planId}/complete`, toVersionPlanPayload(data)),
+    normalizeVersionPlan,
+  );
+}
+
+export async function deleteVersionPlanByVersionId(versionId: string, planId: string): Promise<void> {
+  await api.delete(`/versions/${versionId}/plans/${planId}`);
+}
+
+export async function listDevTasksByVersionId(versionId: string): Promise<DevTask[]> {
+  const rows = await api.get<DomainDevTaskRow[]>(`/versions/${versionId}/dev-tasks`);
+  return rows.map(normalizeDevTask);
+}
+
+export async function createDevTaskByVersionId(versionId: string, data: Partial<DevTask>) {
+  return normalizeMutation(
+    await api.post<DomainMutationResponse<DomainDevTaskRow>>(`/versions/${versionId}/dev-tasks`, toDevTaskPayload(data)),
+    normalizeDevTask,
+  );
+}
+
+export async function updateDevTaskByVersionId(versionId: string, taskId: string, data: Partial<DevTask>) {
+  return normalizeMutation(
+    await api.patch<DomainMutationResponse<DomainDevTaskRow>>(`/versions/${versionId}/dev-tasks/${taskId}`, toDevTaskPayload(data)),
+    normalizeDevTask,
+  );
+}
+
+export async function updateDevTaskStatusByVersionId(versionId: string, taskId: string, status: DevTaskStatus) {
+  return normalizeMutation(
+    await api.patch<DomainMutationResponse<DomainDevTaskRow>>(`/versions/${versionId}/dev-tasks/${taskId}/status`, { status }),
+    normalizeDevTask,
+  );
+}
+
+export async function setDevTaskBlockedByVersionId(
+  versionId: string,
+  taskId: string,
+  blocked: boolean,
+  reason?: string,
+) {
+  return normalizeMutation(
+    await api.patch<DomainMutationResponse<DomainDevTaskRow>>(`/versions/${versionId}/dev-tasks/${taskId}/block`, { blocked, reason }),
+    normalizeDevTask,
+  );
+}
+
+export async function transferDevTaskByVersionId(versionId: string, taskId: string, assigneeId: string) {
+  return normalizeMutation(
+    await api.patch<DomainMutationResponse<DomainDevTaskRow>>(`/versions/${versionId}/dev-tasks/${taskId}/transfer`, { assigneeId }),
+    normalizeDevTask,
+  );
+}
+
+export async function deleteDevTaskByVersionId(versionId: string, taskId: string): Promise<void> {
+  await api.delete(`/versions/${versionId}/dev-tasks/${taskId}`);
+}
+
 function normalizeProductRoot(product: RootProduct): RootProduct {
   return {
     ...product,
@@ -237,3 +391,164 @@ function isoString(value: string | Date | null | undefined): string {
   const time = new Date(value).getTime();
   return Number.isFinite(time) ? new Date(time).toISOString() : new Date().toISOString();
 }
+
+function optionalIso(value: string | Date | null | undefined): string | undefined {
+  if (!value) return undefined;
+  return isoString(value);
+}
+
+function toVersionPlanPayload(data: Partial<VersionPlan>) {
+  return {
+    ...(data.type !== undefined && { type: data.type }),
+    ...(data.title !== undefined && { title: data.title }),
+    ...(data.status !== undefined && { status: data.status }),
+    ...(data.owner !== undefined && { owner: data.owner }),
+    ...(data.startTime !== undefined && { startTime: data.startTime }),
+    ...(data.endTime !== undefined && { endTime: data.endTime }),
+    ...(data.actualStartAt !== undefined && { actualStartAt: data.actualStartAt }),
+    ...(data.completedAt !== undefined && { completedAt: data.completedAt }),
+    ...(data.resultUrl !== undefined && { resultUrl: data.resultUrl }),
+    ...(data.linkedRequirementIds !== undefined && { linkedRequirementIds: data.linkedRequirementIds }),
+    ...(data.requirementCoverage !== undefined && { requirementCoverage: data.requirementCoverage }),
+    ...(data.logs !== undefined && { logs: data.logs }),
+  };
+}
+
+function normalizeVersionPlan(row: DomainVersionPlanRow): VersionPlan {
+  const requirementCoverage = asArray<VersionPlanRequirementCoverage>(row.requirementCoverage);
+  return {
+    id: row.id,
+    versionId: row.versionId,
+    type: toPlanType(row.type),
+    title: row.title,
+    owner: row.ownerId ?? '',
+    startTime: isoString(row.expectedStartAt),
+    endTime: isoString(row.expectedEndAt),
+    status: toPlanStatus(row.status),
+    tasks: [],
+    completedRequirementIds: requirementCoverage
+      .filter((item) => item?.status === 'completed')
+      .map((item) => item.requirementId)
+      .filter(Boolean),
+    linkedRequirementIds: requirementCoverage.map((item) => item?.requirementId).filter(Boolean),
+    requirementCoverage,
+    logs: asArray<VersionPlanLog>(row.logs),
+    resultUrl: row.resultUrl ?? undefined,
+    actualStartAt: optionalIso(row.actualStartAt),
+    createdAt: isoString(row.createdAt),
+    completedAt: optionalIso(row.completedAt),
+    addedBy: row.ownerId ?? '',
+  };
+}
+
+function toPlanType(value: string): VersionPlan['type'] {
+  return value === 'research' || value === 'ui' ? value : 'product';
+}
+
+function toPlanStatus(value: string | null | undefined): VersionPlan['status'] {
+  return value === 'in_progress' || value === 'completed' ? value : 'pending';
+}
+
+function toDevTaskPayload(data: Partial<DevTask>) {
+  return {
+    ...(data.versionId !== undefined && { versionId: data.versionId }),
+    ...(data.requirementId !== undefined && { requirementId: data.requirementId }),
+    ...(data.categoryId !== undefined && { categoryId: data.categoryId }),
+    ...(data.taskNo !== undefined && { taskNo: data.taskNo }),
+    ...(data.title !== undefined && { title: data.title }),
+    ...(data.description !== undefined && { description: data.description }),
+    ...(data.status !== undefined && { status: data.status }),
+    ...(data.priority !== undefined && { priority: priorityToNumber(data.priority) }),
+    ...(data.assigneeId !== undefined && { assigneeId: data.assigneeId }),
+    ...(data.createdBy !== undefined && { createdBy: data.createdBy }),
+    ...(data.isBlocked !== undefined && { isBlocked: data.isBlocked }),
+    ...(data.blockReason !== undefined && { blockReason: data.blockReason }),
+    ...(data.expectedStartAt !== undefined && { expectedStartAt: data.expectedStartAt }),
+    ...(data.expectedEndAt !== undefined && { expectedEndAt: data.expectedEndAt }),
+    ...(data.actualStartAt !== undefined && { actualStartAt: data.actualStartAt }),
+    ...(data.actualEndAt !== undefined && { actualEndAt: data.actualEndAt }),
+    ...(data.estimateHours !== undefined && { estimateHours: data.estimateHours }),
+    ...(data.aiEstimateHours !== undefined && { aiEstimateHours: data.aiEstimateHours }),
+    ...(data.references !== undefined && { references: data.references }),
+    ...(data.aiDraft !== undefined && { aiDraft: data.aiDraft }),
+    ...(data.aiDraftAt !== undefined && { aiDraftAt: data.aiDraftAt }),
+  };
+}
+
+function normalizeDevTask(row: DomainDevTaskRow): DevTask {
+  return {
+    id: row.id,
+    taskNo: row.code,
+    versionId: row.versionId,
+    requirementId: row.requirementId ?? '',
+    title: row.title,
+    description: row.description ?? '',
+    categoryId: row.categoryId ?? '',
+    assigneeId: row.assigneeId ?? '',
+    priority: toPriority(row.priority),
+    expectedStartAt: isoString(row.expectedStartAt),
+    expectedEndAt: isoString(row.expectedEndAt),
+    estimateHours: row.estimateHours ?? undefined,
+    aiEstimateHours: row.aiEstimateHours ?? undefined,
+    actualStartAt: optionalIso(row.startDate),
+    actualEndAt: optionalIso(row.completedAt),
+    status: toDevTaskStatus(row.status),
+    isBlocked: Boolean(row.isBlocked),
+    blockReason: row.blockReason ?? undefined,
+    references: asArray<Reference>(row.references),
+    aiDraft: Boolean(row.aiDraft),
+    aiDraftAt: optionalIso(row.aiDraftAt),
+    createdBy: row.creatorId ?? '',
+    createdAt: isoString(row.createdAt),
+    updatedAt: isoString(row.updatedAt),
+  };
+}
+
+function toDevTaskStatus(value: string | null | undefined): DevTaskStatus {
+  return value === 'in_progress' || value === 'testing' || value === 'submitted' ? value : 'todo';
+}
+
+function normalizeMutation<Row, Item>(
+  response: DomainMutationResponse<Row>,
+  mapper: (row: Row) => Item,
+): { item: Item; activities: WorkActivity[] } {
+  return {
+    item: mapper(response.item),
+    activities: (response.activities ?? []).map(normalizeWorkActivity),
+  };
+}
+
+function normalizeWorkActivity(row: DomainWorkActivityRow): WorkActivity {
+  const metadata = isRecord(row.metadata) ? row.metadata : {};
+  return {
+    id: row.id,
+    actorId: row.actorId ?? row.actorName ?? '',
+    date: isoString(row.occurredAt).slice(0, 10),
+    occurredAt: isoString(row.occurredAt),
+    sourceType: toWorkActivitySourceType(row.sourceType),
+    sourceId: row.sourceId,
+    action: row.action as WorkActivity['action'],
+    category: toWorkActivityCategory(metadata.category),
+    title: row.title,
+    summary: typeof metadata.summary === 'string' ? metadata.summary : row.title,
+    metadata,
+  };
+}
+
+function toWorkActivitySourceType(value: string): WorkActivitySourceType {
+  if (value === 'version_plan' || value === 'dev_task' || value === 'test_case' || value === 'bug') return value;
+  return 'manual';
+}
+
+function toWorkActivityCategory(value: unknown): WorkActivityCategory {
+  if (value === 'delivery' || value === 'progress' || value === 'creation' || value === 'risk') return value;
+  return 'note';
+}
+
+function asArray<T>(value: unknown): T[] {
+  return Array.isArray(value) ? value as T[] : [];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

apps/web/lib/version-plan-dev-task-domain-source.test.ts

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import test from 'node:test';
+
+const planStore = () => readFileSync(join(process.cwd(), 'stores/useVersionPlanStore.ts'), 'utf8');
+const taskStore = () => readFileSync(join(process.cwd(), 'stores/useDevTaskStore.ts'), 'utf8');
+
+function storeMethodBody(text: string, name: string) {
+  const implementationStart = text.indexOf('export const');
+  assert.notEqual(implementationStart, -1, 'missing store implementation');
+  const start = text.indexOf(`  ${name}:`, implementationStart);
+  assert.notEqual(start, -1, `missing store method ${name}`);
+
+  let depth = 0;
+  let sawFirstBrace = false;
+  for (let i = start; i < text.length; i += 1) {
+    const char = text[i];
+    if (char === '{') {
+      depth += 1;
+      sawFirstBrace = true;
+    }
+    if (char === '}') {
+      depth -= 1;
+      if (sawFirstBrace && depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  throw new Error(`could not extract store method ${name}`);
+}
+
+test('version plan store uses domain APIs for version-scoped writes', () => {
+  const text = planStore();
+
+  assert.match(text, /from '@\/lib\/domain-api'/);
+  assert.match(storeMethodBody(text, 'createPlan'), /createVersionPlanByVersionId\(plan\.versionId,/);
+  assert.match(storeMethodBody(text, 'updatePlan'), /updateVersionPlanByVersionId\(versionId, id,/);
+  assert.match(storeMethodBody(text, 'completePlan'), /completeVersionPlanByVersionId\(versionId, id,/);
+  assert.doesNotMatch(storeMethodBody(text, 'createPlan'), /saveServerData\('version-plans'/);
+  assert.doesNotMatch(storeMethodBody(text, 'updatePlan'), /saveServerData\('version-plans'/);
+});
+
+test('dev task store uses domain APIs for version-scoped writes', () => {
+  const text = taskStore();
+
+  assert.match(text, /from '@\/lib\/domain-api'/);
+  assert.match(storeMethodBody(text, 'createTask'), /createDevTaskByVersionId\(task\.versionId,/);
+  assert.match(storeMethodBody(text, 'updateTask'), /updateDevTaskByVersionId\(versionId, id,/);
+  assert.match(storeMethodBody(text, 'changeStatus'), /updateDevTaskStatusByVersionId\(task\.versionId,/);
+  assert.match(storeMethodBody(text, 'setBlocked'), /setDevTaskBlockedByVersionId\(task\.versionId,/);
+  assert.doesNotMatch(storeMethodBody(text, 'createTask'), /saveServerData\('dev-tasks'/);
+  assert.doesNotMatch(storeMethodBody(text, 'updateTask'), /saveServerData\('dev-tasks'/);
+});

apps/web/stores/useDevTaskStore.ts

@@ -3,9 +3,18 @@ import { create } from 'zustand';
 import type { DevTask, DevTaskStatus } from '@/lib/dev-task';
 import { generateTaskNo, isLegacyTask } from '@/lib/dev-task';
 import { applyDevTaskTransition, normalizeDevTaskOnCreate } from '@/lib/dev-task-workflow';
+import {
+  createDevTaskByVersionId,
+  deleteDevTaskByVersionId,
+  listDevTasksByVersionId,
+  setDevTaskBlockedByVersionId,
+  updateDevTaskByVersionId,
+  updateDevTaskStatusByVersionId,
+} from '@/lib/domain-api';
 import { createEntityId, dedupeEntityIds } from '@/lib/entity-id';
 import { scheduleSaveWithOptimisticRollback } from '@/lib/optimistic-persistence';
 import { loadServerData, saveServerData, SERVER_DATA_CACHE_MS } from '@/lib/server-data';
+import type { WorkActivity } from '@/lib/work-activity';
 import {
   makeDevTaskBlockedActivity,
   makeDevTaskCreatedActivity,
@@ -38,7 +47,7 @@ async function loadStored(): Promise<DevTask[] | null> {
 interface DevTaskState {
   tasks: DevTask[];
   loaded: boolean;
-  fetchTasks: (options?: { force?: boolean }) => Promise<void>;
+  fetchTasks: (options?: { force?: boolean; versionId?: string }) => Promise<void>;
   createTask: (data: Omit<DevTask, 'id' | 'taskNo' | 'createdAt' | 'updatedAt' | 'isBlocked'>) => DevTask;
   updateTask: (id: string, data: Partial<DevTask>) => void;
   deleteTask: (id: string) => void;
@@ -55,7 +64,9 @@ export const useDevTaskStore = create<DevTaskState>((set, get) => ({
 
   fetchTasks: async (options) => {
     if (!options?.force && get().loaded && Date.now() - lastTasksFetchAt < SERVER_DATA_CACHE_MS) return;
-    const cached = await loadStored();
+    const cached = options?.versionId
+      ? await listDevTasksByVersionId(options.versionId).catch(loadStored)
+      : await loadStored();
     if (!options?.force && get().loaded && Date.now() - lastTasksFetchAt < SERVER_DATA_CACHE_MS) return;
     lastTasksFetchAt = Date.now();
     set({ tasks: cached ?? [], loaded: true });
@@ -75,12 +86,24 @@ export const useDevTaskStore = create<DevTaskState>((set, get) => ({
     const updated = [...list, task];
     set({ tasks: updated, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('dev-tasks', updated),
+      save: async () => {
+        try {
+          if (!task.versionId) throw new Error('missing versionId');
+          const result = await createDevTaskByVersionId(task.versionId, task);
+          set({
+            tasks: get().tasks.map((item) => (item.id === task.id ? { ...task, ...result.item } : item)),
+            loaded: true,
+          });
+          appendDomainActivities(result.activities);
+        } catch {
+          await saveDevTasksFallback(updated);
+          useWorkActivityStore.getState().addActivity(makeDevTaskCreatedActivity(task, task.createdBy || task.assigneeId));
+        }
+      },
       expected: updated,
       getCurrent: () => get().tasks,
       rollback: () => set({ tasks: list, loaded: true }),
     });
-    useWorkActivityStore.getState().addActivity(makeDevTaskCreatedActivity(task, task.createdBy || task.assigneeId));
     return task;
   },
 
@@ -91,7 +114,16 @@ export const useDevTaskStore = create<DevTaskState>((set, get) => ({
     );
     set({ tasks: updated, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('dev-tasks', updated),
+      save: async () => {
+        try {
+          const versionId = previous.find((task) => task.id === id)?.versionId;
+          if (!versionId) throw new Error('missing versionId');
+          const result = await updateDevTaskByVersionId(versionId, id, data);
+          appendDomainActivities(result.activities);
+        } catch {
+          await saveDevTasksFallback(updated);
+        }
+      },
       expected: updated,
       getCurrent: () => get().tasks,
       rollback: () => set({ tasks: previous, loaded: true }),
@@ -103,7 +135,15 @@ export const useDevTaskStore = create<DevTaskState>((set, get) => ({
     const updated = previous.filter((t) => t.id !== id);
     set({ tasks: updated, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('dev-tasks', updated),
+      save: async () => {
+        try {
+          const versionId = previous.find((task) => task.id === id)?.versionId;
+          if (!versionId) throw new Error('missing versionId');
+          await deleteDevTaskByVersionId(versionId, id);
+        } catch {
+          await saveDevTasksFallback(updated);
+        }
+      },
       expected: updated,
       getCurrent: () => get().tasks,
       rollback: () => set({ tasks: previous, loaded: true }),
@@ -118,24 +158,63 @@ export const useDevTaskStore = create<DevTaskState>((set, get) => ({
       delayReason: opts?.delayReason,
     });
     if (!result.ok || !result.patch) return { ok: false, message: result.message };
-    get().updateTask(id, result.patch);
+    const previous = get().tasks;
+    const updated = previous.map((t) =>
+      t.id === id ? { ...t, ...result.patch, aiDraft: false, updatedAt: new Date().toISOString() } : t,
+    );
+    set({ tasks: updated, loaded: true });
     const activity = makeDevTaskStatusActivity(task, task.status, to, task.assigneeId);
-    if (activity) useWorkActivityStore.getState().addActivity(activity);
+    scheduleSaveWithOptimisticRollback({
+      save: async () => {
+        try {
+          if (!task.versionId) throw new Error('missing versionId');
+          const result = await updateDevTaskStatusByVersionId(task.versionId, id, to);
+          appendDomainActivities(result.activities);
+          if (result.activities.length === 0 && activity) useWorkActivityStore.getState().addActivity(activity);
+        } catch {
+          await saveDevTasksFallback(updated);
+          if (activity) useWorkActivityStore.getState().addActivity(activity);
+        }
+      },
+      expected: updated,
+      getCurrent: () => get().tasks,
+      rollback: () => set({ tasks: previous, loaded: true }),
+    });
     return { ok: true };
   },
 
   setBlocked: (id, blocked, reason, blockedById) => {
     const task = get().tasks.find((t) => t.id === id);
     if (!task) return;
-    get().updateTask(id, {
+    const previous = get().tasks;
+    const patch = {
       isBlocked: blocked,
       blockReason: blocked ? reason : undefined,
       blockedById: blocked ? blockedById : undefined,
-    });
+    };
+    const updated = previous.map((item) =>
+      item.id === id ? { ...item, ...patch, aiDraft: false, updatedAt: new Date().toISOString() } : item,
+    );
+    set({ tasks: updated, loaded: true });
     const activity = blocked
       ? makeDevTaskBlockedActivity(task, task.assigneeId, reason, blockedById)
       : makeDevTaskUnblockedActivity(task, task.assigneeId);
-    useWorkActivityStore.getState().addActivity(activity);
+    scheduleSaveWithOptimisticRollback({
+      save: async () => {
+        try {
+          if (!task.versionId) throw new Error('missing versionId');
+          const result = await setDevTaskBlockedByVersionId(task.versionId, id, blocked, reason);
+          appendDomainActivities(result.activities);
+          if (result.activities.length === 0) useWorkActivityStore.getState().addActivity(activity);
+        } catch {
+          await saveDevTasksFallback(updated);
+          useWorkActivityStore.getState().addActivity(activity);
+        }
+      },
+      expected: updated,
+      getCurrent: () => get().tasks,
+      rollback: () => set({ tasks: previous, loaded: true }),
+    });
   },
 
   getByRequirement: (requirementId) => {
@@ -151,3 +230,15 @@ export const useDevTaskStore = create<DevTaskState>((set, get) => ({
     return get().tasks.filter((t) => t.assigneeId === assigneeId);
   },
 }));
+
+async function saveDevTasksFallback(tasks: DevTask[]) {
+  await saveServerData('dev-tasks', tasks);
+}
+
+function appendDomainActivities(activities: WorkActivity[]) {
+  if (activities.length === 0) return;
+  useWorkActivityStore.setState((state) => ({
+    activities: [...state.activities, ...activities],
+    loaded: true,
+  }));
+}

apps/web/stores/useVersionPlanStore.ts

@@ -1,6 +1,13 @@
 'use client';
 import { create } from 'zustand';
 import type { VersionPlan, PlanType } from '@/lib/version-plan';
+import {
+  completeVersionPlanByVersionId,
+  createVersionPlanByVersionId,
+  deleteVersionPlanByVersionId,
+  listVersionPlansByVersionId,
+  updateVersionPlanByVersionId,
+} from '@/lib/domain-api';
 import { scheduleSaveWithOptimisticRollback } from '@/lib/optimistic-persistence';
 import { loadServerData, saveServerData, SERVER_DATA_CACHE_MS } from '@/lib/server-data';
 import { getPlanCompletionState } from '@/lib/version-plan-workflow';
@@ -13,6 +20,7 @@ import {
   makeVersionPlanStartedActivity,
 } from '@/lib/work-activity-factory';
 import type { WorkActivityDraft } from '@/lib/work-activity';
+import type { WorkActivity } from '@/lib/work-activity';
 import { useWorkActivityStore } from './useWorkActivityStore';
 
 const MOCK_PLANS: VersionPlan[] = [];
@@ -28,7 +36,7 @@ async function loadStored(): Promise<VersionPlan[] | null> {
 interface VersionPlanState {
   plans: VersionPlan[];
   loaded: boolean;
-  fetchPlans: (options?: { force?: boolean }) => Promise<void>;
+  fetchPlans: (options?: { force?: boolean; versionId?: string }) => Promise<void>;
   createPlan: (data: Omit<VersionPlan, 'id' | 'createdAt'>) => void;
   updatePlan: (id: string, data: Partial<VersionPlan>) => void;
   completePlan: (id: string, result: PlanResultPayload) => { ok: boolean; message?: string };
@@ -41,7 +49,9 @@ export const useVersionPlanStore = create<VersionPlanState>((set, get) => ({
 
   fetchPlans: async (options) => {
     if (!options?.force && get().loaded && Date.now() - lastPlansFetchAt < SERVER_DATA_CACHE_MS) return;
-    const cached = await loadStored();
+    const cached = options?.versionId
+      ? await listVersionPlansByVersionId(options.versionId).catch(loadStored)
+      : await loadStored();
     if (!options?.force && get().loaded && Date.now() - lastPlansFetchAt < SERVER_DATA_CACHE_MS) return;
     lastPlansFetchAt = Date.now();
     set({ plans: cached ?? MOCK_PLANS, loaded: true });
@@ -53,12 +63,25 @@ export const useVersionPlanStore = create<VersionPlanState>((set, get) => ({
     const plans = [...previous, plan];
     set({ plans, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('version-plans', plans),
+      save: async () => {
+        try {
+          const result = await createVersionPlanByVersionId(plan.versionId, plan);
+          set({
+            plans: get().plans.map((item) => (
+              item.id === plan.id ? { ...plan, ...result.item, tasks: plan.tasks } : item
+            )),
+            loaded: true,
+          });
+          appendDomainActivities(result.activities);
+        } catch {
+          await saveVersionPlansFallback(plans);
+          useWorkActivityStore.getState().addActivity(makeVersionPlanCreatedActivity(plan, plan.addedBy || plan.owner));
+        }
+      },
       expected: plans,
       getCurrent: () => get().plans,
       rollback: () => set({ plans: previous, loaded: true }),
     });
-    useWorkActivityStore.getState().addActivity(makeVersionPlanCreatedActivity(plan, plan.addedBy || plan.owner));
   },
 
   updatePlan: (id, data) => {
@@ -93,12 +116,24 @@ export const useVersionPlanStore = create<VersionPlanState>((set, get) => ({
     });
     set({ plans, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('version-plans', plans),
+      save: async () => {
+        try {
+          const versionId = previous.find((plan) => plan.id === id)?.versionId;
+          if (!versionId) throw new Error('missing versionId');
+          const result = await updateVersionPlanByVersionId(versionId, id, data);
+          appendDomainActivities(result.activities);
+          if (result.activities.length === 0) {
+            activities.forEach((activity) => useWorkActivityStore.getState().addActivity(activity));
+          }
+        } catch {
+          await saveVersionPlansFallback(plans);
+          activities.forEach((activity) => useWorkActivityStore.getState().addActivity(activity));
+        }
+      },
       expected: plans,
       getCurrent: () => get().plans,
       rollback: () => set({ plans: previous, loaded: true }),
     });
-    activities.forEach((activity) => useWorkActivityStore.getState().addActivity(activity));
   },
 
   completePlan: (id, result) => {
@@ -118,7 +153,16 @@ export const useVersionPlanStore = create<VersionPlanState>((set, get) => ({
     });
     set({ plans, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('version-plans', plans),
+      save: async () => {
+        try {
+          const versionId = previous.find((plan) => plan.id === id)?.versionId;
+          if (!versionId) throw new Error('missing versionId');
+          const apiResult = await completeVersionPlanByVersionId(versionId, id, result);
+          appendDomainActivities(apiResult.activities);
+        } catch {
+          await saveVersionPlansFallback(plans);
+        }
+      },
       expected: plans,
       getCurrent: () => get().plans,
       rollback: () => set({ plans: previous, loaded: true }),
@@ -131,10 +175,30 @@ export const useVersionPlanStore = create<VersionPlanState>((set, get) => ({
     const plans = previous.filter((p) => p.id !== id);
     set({ plans, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('version-plans', plans),
+      save: async () => {
+        try {
+          const versionId = previous.find((plan) => plan.id === id)?.versionId;
+          if (!versionId) throw new Error('missing versionId');
+          await deleteVersionPlanByVersionId(versionId, id);
+        } catch {
+          await saveVersionPlansFallback(plans);
+        }
+      },
       expected: plans,
       getCurrent: () => get().plans,
       rollback: () => set({ plans: previous, loaded: true }),
     });
   },
 }));
+
+async function saveVersionPlansFallback(plans: VersionPlan[]) {
+  await saveServerData('version-plans', plans);
+}
+
+function appendDomainActivities(activities: WorkActivity[]) {
+  if (activities.length === 0) return;
+  useWorkActivityStore.setState((state) => ({
+    activities: [...state.activities, ...activities],
+    loaded: true,
+  }));
+}