agent-tower 0.7.3 → 0.7.4-beta.1

package/dist/services/task.service.js

@@ -3,14 +3,21 @@ export { buildTextPreview } from '../utils/text-preview.js';
 import { prisma } from '../utils/index.js';
 import { TaskStatus, SessionStatus, SessionPurpose, WorkspaceKind, WorkspaceStatus } from '../types/index.js';
 import { getWorkspaceWorkingDir } from './workspace-kind.js';
-import { NotFoundError, ValidationError, InvalidStateTransitionError, } from '../errors.js';
+import { NotFoundError, ServiceError, ValidationError, InvalidStateTransitionError, } from '../errors.js';
 import { defaultWorkspaceLifecycleBarrier } from './workspace-lifecycle-barrier.js';
 import { ensureProjectIsMutable, getStoredProjectGitCapability, detectProjectGitCapability } from './project-guards.js';
 import { requireLocalBaseBranch } from '../git/base-branch.js';
 import { defaultTeamLockService } from './team-lock.service.js';
-import { TaskPriority } from '@agent-tower/shared';
+import { TaskPriority, MAX_TASK_DEPTH } from '@agent-tower/shared';
 import prismaPkg from '@prisma/client';
 const { Prisma } = prismaPkg;
+const taskBoardColumns = Prisma.sql `
+  task."id", task."projectId", task."title", task."status", task."priority",
+  task."position", task."updatedAt", task."parentTaskId",
+  (SELECT parent."parentTaskId" FROM "Task" parent WHERE parent."id" = task."parentTaskId") AS "grandparentTaskId",
+  (SELECT COUNT(*) FROM "Task" child WHERE child."parentTaskId" = task."id" AND child."deletedAt" IS NULL) AS "subtaskCount",
+  (SELECT COUNT(*) FROM "Task" child WHERE child."parentTaskId" = task."id" AND child."deletedAt" IS NULL AND child."status" = 'IN_PROGRESS') AS "runningSubtaskCount"
+`;
 /**
  * 合法的状态流转规则
  * 看板拖拽场景下允许任意状态互转，状态变更无危险副作用
@@ -43,6 +50,19 @@ const visibleSessionSummary = {
         updatedAt: true,
     },
 };
+// The schema stores adjacency; these bounded reads cover the supported three levels.
+function subtreeWhere(id, projectId) {
+    return { deletedAt: null, ...(projectId ? { projectId } : {}), OR: [
+            { id }, { parentTaskId: id }, { parentTask: { parentTaskId: id, deletedAt: null } },
+        ] };
+}
+function ancestorIds(parentTaskId, grandparentTaskId) {
+    return [grandparentTaskId, parentTaskId].filter((id) => Boolean(id));
+}
+function withHierarchy(task) {
+    const { parentTask, ...metadata } = task;
+    return { ...metadata, ancestorIds: ancestorIds(task.parentTaskId, parentTask?.parentTaskId) };
+}
 function sliceAtCompleteCodePointBoundary(value, maxLength) {
     let end = 0;
     for (const character of value) {
@@ -211,13 +231,17 @@ function normalizeUpdateTaskInput(current, input) {
         ]),
     };
 }
+function withoutTaskHandoff(task) {
+    const { handoff: _handoff, ...metadata } = task;
+    return metadata;
+}
 function withTaskPreviews(task, options = {}) {
     const titlePreview = buildTextPreview(task.title, TASK_TITLE_MAX_LENGTH);
     const contentPreview = buildTextPreview(task.description);
     const isTruncated = task.title !== titlePreview
         || Boolean(task.description && task.description !== contentPreview);
     const base = {
-        ...task,
+        ...withoutTaskHandoff(task),
         title: titlePreview,
         titlePreview,
         contentPreview: contentPreview || undefined,
@@ -235,13 +259,15 @@ function withProjectGitMetadata(task) {
     return withProjectGitCapability(task, capability);
 }
 function withProjectGitCapability(task, capability) {
-    return {
+    const result = {
         ...task,
         project: {
             ...task.project,
             ...capability,
         },
     };
+    delete result.handoff;
+    return result;
 }
 function buildProjectGitMetadata(project) {
     return getStoredProjectGitCapability(project);
@@ -275,30 +301,28 @@ export class TaskService {
             deletedAt: null,
             project: { archivedAt: null },
             ...(params.projectId ? { projectId: params.projectId } : {}),
+            ...(params.parentTaskId ? { parentTaskId: params.parentTaskId } : {}),
             ...(params.status ? { status: params.status } : {}),
         };
         const projectFilter = params.projectId
             ? Prisma.sql `AND task."projectId" = ${params.projectId}`
             : Prisma.empty;
+        const parentFilter = params.parentTaskId
+            ? Prisma.sql `AND task."parentTaskId" = ${params.parentTaskId}`
+            : Prisma.empty;
         const statusFilter = params.status
             ? Prisma.sql `AND task."status" = ${params.status}`
             : Prisma.empty;
         const [tasks, total] = await Promise.all([
             prisma.$queryRaw(Prisma.sql `
-        SELECT
-          task."id" AS "id",
-          task."projectId" AS "projectId",
-          task."title" AS "title",
-          task."status" AS "status",
-          task."priority" AS "priority",
-          task."position" AS "position",
-          task."updatedAt" AS "updatedAt"
+        SELECT ${taskBoardColumns}
         FROM "Task" task
         INNER JOIN "Project" project ON project."id" = task."projectId"
         WHERE task."deletedAt" IS NULL
           AND project."archivedAt" IS NULL
           ${projectFilter}
           ${statusFilter}
+          ${parentFilter}
         ORDER BY
           CASE task."status"
             WHEN ${TaskStatus.IN_PROGRESS} THEN 0
@@ -315,7 +339,19 @@ export class TaskService {
       `),
             prisma.task.count({ where }),
         ]);
-        const taskIds = tasks.map((task) => task.id);
+        // Descendants can rank ahead of their ancestors or fall on another page.
+        // Return the complete compact path without changing the page count/limit.
+        const pageIds = new Set(tasks.map((task) => task.id));
+        const missingParentIds = [...new Set(tasks.flatMap((task) => ancestorIds(task.parentTaskId, task.grandparentTaskId).filter(id => !pageIds.has(id))))];
+        const parents = params.parentTaskId || missingParentIds.length === 0 ? []
+            : await prisma.$queryRaw(Prisma.sql `
+        SELECT ${taskBoardColumns} FROM "Task" task
+        INNER JOIN "Project" project ON project."id" = task."projectId"
+        WHERE task."id" IN (SELECT value FROM json_each(${JSON.stringify(missingParentIds)}))
+          AND task."deletedAt" IS NULL AND project."archivedAt" IS NULL
+      `);
+        const allTasks = [...tasks, ...parents];
+        const taskIds = allTasks.map((task) => task.id);
         const workspaceRows = taskIds.length === 0
             ? []
             : await prisma.$queryRaw(Prisma.sql `
@@ -363,7 +399,7 @@ export class TaskService {
             workspacesByTaskId.set(workspace.taskId, group);
         }
         const preferredWorkspaceByTaskId = new Map();
-        for (const task of tasks) {
+        for (const task of allTasks) {
             const candidates = workspacesByTaskId.get(task.id) ?? [];
             const preferred = candidates.find((workspace) => workspace.status === WorkspaceStatus.ACTIVE)
                 ?? candidates[0];
@@ -371,7 +407,7 @@ export class TaskService {
                 preferredWorkspaceByTaskId.set(task.id, preferred);
             }
         }
-        const data = tasks.map((task) => {
+        const data = allTasks.map((task) => {
             const titlePreview = buildTextPreview(task.title, TASK_TITLE_MAX_LENGTH);
             const preferredWorkspace = preferredWorkspaceByTaskId.get(task.id);
             const hasRunningSession = (workspacesByTaskId.get(task.id) ?? [])
@@ -382,6 +418,10 @@ export class TaskService {
             return {
                 id: task.id,
                 projectId: task.projectId,
+                parentTaskId: task.parentTaskId,
+                ancestorIds: ancestorIds(task.parentTaskId, task.grandparentTaskId),
+                subtaskCount: Number(task.subtaskCount),
+                runningSubtaskCount: Number(task.runningSubtaskCount),
                 title: titlePreview,
                 status: task.status,
                 priority: task.priority ?? TaskPriority.NORMAL,
@@ -401,7 +441,8 @@ export class TaskService {
             };
         });
         return {
-            data,
+            data: data.slice(0, tasks.length),
+            ...(parents.length ? { parents: data.slice(tasks.length) } : {}),
             total,
             page,
             limit,
@@ -443,6 +484,8 @@ export class TaskService {
                     projectId: true,
                     title: true,
                     baseBranch: true,
+                    parentTaskId: true,
+                    parentTask: { select: { parentTaskId: true } },
                     status: true,
                     priority: true,
                     position: true,
@@ -471,7 +514,7 @@ export class TaskService {
         });
         const projectGitCapability = getStoredProjectGitCapability(project);
         return {
-            data: data.map((task) => (withTaskPreviews(withProjectGitCapability(task, projectGitCapability), { omitDescription: true }))),
+            data: data.map((task) => (withTaskPreviews(withProjectGitCapability(withHierarchy(task), projectGitCapability), { omitDescription: true }))),
             total,
             page,
             limit,
@@ -490,6 +533,9 @@ export class TaskService {
                 project: true,
                 title: true,
                 baseBranch: true,
+                parentTaskId: true,
+                parentTask: { select: { parentTaskId: true } },
+                _count: { select: { subtasks: { where: { deletedAt: null } } } },
                 status: true,
                 priority: true,
                 position: true,
@@ -501,7 +547,14 @@ export class TaskService {
         if (!task) {
             throw new NotFoundError('Task', id);
         }
-        return withTaskPreviews(withProjectGitMetadata(task), { omitDescription: true });
+        const { _count, ...metadata } = task;
+        return withTaskPreviews(withProjectGitMetadata({ ...withHierarchy(metadata), subtaskCount: _count.subtasks }), { omitDescription: true });
+    }
+    async findSubtasks(id, params = {}) {
+        const parent = await prisma.task.findFirst({ where: { id, deletedAt: null } });
+        if (!parent)
+            throw new NotFoundError('Task', id);
+        return this.findBoard({ ...params, projectId: parent.projectId, parentTaskId: id });
     }
     async findBodyById(id) {
         const task = await prisma.task.findFirst({
@@ -554,37 +607,82 @@ export class TaskService {
             throw new NotFoundError('Project', projectId);
         }
         ensureProjectIsMutable(project, 'create tasks');
-        // Resolve at task creation so delayed starts and TeamRun main workspaces
-        // cannot silently follow a later project default change. Local tasks opt out.
-        let baseBranch = null;
-        if (input.baseBranch !== null) {
-            const requestedBranch = input.baseBranch ?? ((await detectProjectGitCapability(project.repoPath)).worktreeReady ? project.mainBranch : null);
-            if (requestedBranch !== null) {
-                baseBranch = await requireLocalBaseBranch(project.repoPath, requestedBranch);
-            }
-        }
-        // 自动计算 position
-        const maxPosition = await prisma.task.aggregate({
-            where: { projectId, status: TaskStatus.TODO, deletedAt: null },
-            _max: { position: true },
-        });
-        const created = await prisma.task.create({
-            data: {
-                title: normalizedInput.title,
-                description: normalizedInput.description,
-                priority: normalizedInput.priority ?? TaskPriority.NORMAL,
-                baseBranch,
-                position: (maxPosition._max.position ?? 0) + 1,
-                projectId,
-            },
+        const parent = input.parentTaskId ? await prisma.task.findFirst({
+            where: { id: input.parentTaskId, projectId, deletedAt: null },
+            include: { parentTask: { select: { parentTaskId: true } }, workspaces: {
+                    where: { parentWorkspaceId: null, ownerMemberId: null, status: { not: WorkspaceStatus.ABANDONED }, cleanedAt: null },
+                    orderBy: { createdAt: 'desc' },
+                } },
+        }) : null;
+        if (input.parentTaskId && !parent)
+            throw new NotFoundError('Parent task', input.parentTaskId);
+        if (parent?.parentTask?.parentTaskId)
+            throw new ValidationError('Tasks support at most three levels');
+        const parentWorkspace = parent?.workspaces.find((workspace) => workspace.status === WorkspaceStatus.ACTIVE)
+            ?? parent?.workspaces.find((workspace) => workspace.status === WorkspaceStatus.HIBERNATED)
+            ?? parent?.workspaces[0];
+        const parentBranch = parentWorkspace?.branchName || parent?.baseBranch;
+        // A grandchild may inherit an ancestor branch before its parent starts.
+        // Serialize validation/persistence with that branch owner's cleanup as well.
+        const requestedParentBranch = input.baseBranch ?? parentBranch;
+        const branchOwners = input.baseBranch === null || !requestedParentBranch ? [] : await prisma.workspace.findMany({
+            where: { task: { projectId, deletedAt: null }, branchName: requestedParentBranch },
+            select: { id: true },
         });
-        return {
-            ...created,
-            project: {
-                ...project,
-                ...buildProjectGitMetadata(project),
-            },
+        const createWithParentBranch = async () => {
+            // Resolve at task creation so delayed starts and TeamRun main workspaces
+            // cannot silently follow a later project default change. Local tasks opt out.
+            let baseBranch = null;
+            if (input.baseBranch !== null) {
+                const requestedBranch = input.baseBranch ?? parentBranch ?? ((await detectProjectGitCapability(project.repoPath)).worktreeReady ? project.mainBranch : null);
+                if (requestedBranch !== null) {
+                    baseBranch = await requireLocalBaseBranch(project.repoPath, requestedBranch);
+                }
+            }
+            // 自动计算 position
+            const maxPosition = await prisma.task.aggregate({
+                where: { projectId, status: TaskStatus.TODO, deletedAt: null },
+                _max: { position: true },
+            });
+            const created = await prisma.$transaction(async (tx) => {
+                // Recheck after Git validation, serialized with the deletion marker.
+                if (parent) {
+                    const liveParent = await tx.task.findFirst({
+                        where: { id: parent.id, projectId, deletedAt: null, project: { archivedAt: null } },
+                        include: { parentTask: { select: { parentTaskId: true } } },
+                    });
+                    if (!liveParent)
+                        throw new NotFoundError('Parent task', parent.id);
+                    if (liveParent.parentTask?.parentTaskId)
+                        throw new ValidationError('Tasks support at most three levels');
+                }
+                return tx.task.create({
+                    data: {
+                        title: normalizedInput.title,
+                        description: normalizedInput.description,
+                        priority: normalizedInput.priority ?? TaskPriority.NORMAL,
+                        baseBranch,
+                        parentTaskId: parent?.id,
+                        position: (maxPosition._max.position ?? 0) + 1,
+                        projectId,
+                    },
+                });
+            });
+            this.eventBus.emit('task:updated', { taskId: created.id, projectId, status: created.status });
+            if (parent)
+                this.eventBus.emit('task:updated', { taskId: parent.id, projectId, status: parent.status });
+            return {
+                ...created,
+                ancestorIds: parent ? ancestorIds(parent.id, parent.parentTaskId) : [],
+                project: {
+                    ...project,
+                    ...buildProjectGitMetadata(project),
+                },
+            };
         };
+        // Serialize branch validation and child persistence with parent workspace
+        // cleanup, so its reference becomes visible before that branch is reclaimed.
+        return defaultWorkspaceLifecycleBarrier.withWorkspaces([...branchOwners.map(workspace => workspace.id), ...(parentWorkspace ? [parentWorkspace.id] : [])], createWithParentBranch);
     }
     /**
      * 更新任务基本信息
@@ -607,7 +705,7 @@ export class TaskService {
             this.emitTaskUpdated(id, task.projectId, updated.status, updated.priority);
         }
         return {
-            ...updated,
+            ...withoutTaskHandoff(updated),
             project: {
                 ...task.project,
                 ...buildProjectGitMetadata(task.project),
@@ -652,7 +750,7 @@ export class TaskService {
         // 通知前端
         this.emitTaskUpdated(id, task.projectId, status);
         return {
-            ...updated,
+            ...withoutTaskHandoff(updated),
             project: {
                 ...task.project,
                 ...buildProjectGitMetadata(task.project),
@@ -689,7 +787,7 @@ export class TaskService {
             this.emitTaskUpdated(id, task.projectId, status);
         }
         return {
-            ...updated,
+            ...withoutTaskHandoff(updated),
             project: {
                 ...task.project,
                 ...buildProjectGitMetadata(task.project),
@@ -699,149 +797,139 @@ export class TaskService {
     /**
      * 快速删除任务
      *
-     * 1. 原子标记 Task 为 deletedAt，使普通列表立即隐藏
-     * 2. 保存后台清理快照
+     * 1. 在同一事务中标记父子 Task 为 deletedAt，并保存清理快照
+     * 2. 普通读取立即隐藏已删除的任务
      * 3. 通过 EventBus 通知前端实时删除
      * 4. 后台 worker 再停止 Session、删除 worktree/branch，并最终硬删除 Task
      */
-    async delete(id) {
-        const deletedAt = new Date();
-        const taskForGuard = await prisma.task.findUnique({
-            where: { id },
-            include: { project: true },
-        });
-        if (!taskForGuard || taskForGuard.deletedAt) {
+    async delete(id, expectedSubtaskCount) {
+        const taskForGuard = await prisma.task.findUnique({ where: { id }, include: { project: true } });
+        if (!taskForGuard || taskForGuard.deletedAt)
             throw new NotFoundError('Task', id);
-        }
         ensureProjectIsMutable(taskForGuard.project, 'delete tasks');
+        const familyWhere = subtreeWhere(id, taskForGuard.projectId);
+        if (expectedSubtaskCount !== undefined && expectedSubtaskCount !== (await prisma.task.count({
+            where: familyWhere,
+        })) - 1) {
+            throw new ServiceError('Subtasks changed. Review the deletion confirmation again.', 'TASK_DELETE_SCOPE_CHANGED', 409);
+        }
         const workspaceIds = await prisma.workspace.findMany({
-            where: { taskId: id },
+            where: { task: familyWhere },
             select: { id: true },
         });
-        let marked;
-        await defaultWorkspaceLifecycleBarrier.withWorkspaces(workspaceIds.map((workspace) => workspace.id), async () => {
-            for (const workspace of workspaceIds) {
+        const result = await defaultWorkspaceLifecycleBarrier.withWorkspaces(workspaceIds.map((workspace) => workspace.id), async () => {
+            for (const workspace of workspaceIds)
                 await this.backgroundService?.stopAllForWorkspace(workspace.id);
-            }
-            marked = await prisma.task.updateMany({
-                where: {
-                    id,
-                    deletedAt: null,
-                    project: { archivedAt: null },
-                },
-                data: { deletedAt },
-            });
-        });
-        if (marked.count === 0) {
-            const current = await prisma.task.findUnique({
-                where: { id },
-                include: { project: true },
-            });
-            if (!current || current.deletedAt) {
-                throw new NotFoundError('Task', id);
-            }
-            ensureProjectIsMutable(current.project, 'delete tasks');
-            throw new NotFoundError('Task', id);
-        }
-        let deleteResult;
-        let cleanupJobCreated = false;
-        try {
-            const taskForCleanup = await prisma.task.findUnique({
-                where: { id },
-                include: {
-                    project: true,
-                    teamRun: {
-                        include: {
-                            invocations: {
-                                where: { status: { in: CANCELLABLE_DELETE_INVOCATION_STATUSES } },
-                                select: { id: true },
-                            },
-                        },
-                    },
-                    workspaces: {
-                        include: { sessions: true },
+            // Mark the complete family and persist its recovery snapshot together.
+            // Child creation rechecks the parent inside its own transaction.
+            return prisma.$transaction(async (tx) => {
+                const parent = await tx.task.findFirst({ where: { id, deletedAt: null }, include: { project: true } });
+                if (!parent)
+                    throw new NotFoundError('Task', id);
+                ensureProjectIsMutable(parent.project, 'delete tasks');
+                const family = await tx.task.findMany({
+                    where: familyWhere,
+                    select: { id: true, parentTaskId: true },
+                });
+                if (expectedSubtaskCount !== undefined && expectedSubtaskCount !== family.length - 1) {
+                    throw new ServiceError('Subtasks changed. Review the deletion confirmation again.', 'TASK_DELETE_SCOPE_CHANGED', 409);
+                }
+                const byId = new Map(family.map(task => [task.id, task]));
+                const depth = (task) => {
+                    let current = task;
+                    let value = 0;
+                    while (current.parentTaskId && byId.has(current.parentTaskId) && value < MAX_TASK_DEPTH) {
+                        current = byId.get(current.parentTaskId);
+                        value++;
+                    }
+                    return value;
+                };
+                const taskIds = family.sort((a, b) => depth(b) - depth(a) || a.id.localeCompare(b.id)).map(task => task.id);
+                await tx.task.updateMany({ where: { id: { in: taskIds } }, data: { deletedAt: new Date() } });
+                const tasks = await tx.task.findMany({
+                    where: { id: { in: taskIds } },
+                    include: {
+                        workspaces: { include: { sessions: true } },
+                        teamRun: { include: { invocations: {
+                                    where: { status: { in: CANCELLABLE_DELETE_INVOCATION_STATUSES } }, select: { id: true },
+                                } } },
                     },
-                },
-            });
-            if (!taskForCleanup) {
-                throw new NotFoundError('Task', id);
-            }
-            ensureProjectIsMutable(taskForCleanup.project, 'delete tasks');
-            const snapshot = {
-                taskId: taskForCleanup.id,
-                projectId: taskForCleanup.projectId,
-                project: {
-                    repoPath: taskForCleanup.project.repoPath,
-                    mainBranch: taskForCleanup.project.mainBranch,
-                },
-                workspaces: taskForCleanup.workspaces.map((workspace) => ({
-                    id: workspace.id,
-                    worktreePath: workspace.worktreePath,
-                    workingDir: getWorkspaceWorkingDir(workspace),
-                    workspaceKind: workspace.workspaceKind,
-                    branchName: workspace.branchName,
-                    baseBranch: workspace.baseBranch,
-                    // Logical completion does not close a reusable ACP adapter.
-                    sessions: workspace.sessions.map((session) => ({ id: session.id })),
-                })),
-            };
-            const teamRunId = taskForCleanup.teamRun?.id;
-            const cancelledInvocationIds = taskForCleanup.teamRun?.invocations.map((invocation) => invocation.id) ?? [];
-            await prisma.$transaction(async (tx) => {
+                });
+                const tasksById = new Map(tasks.map((task) => [task.id, task]));
+                const orderedTasks = taskIds.map((taskId) => tasksById.get(taskId));
+                const snapshot = {
+                    taskId: id, taskIds, projectId: parent.projectId,
+                    project: { repoPath: parent.project.repoPath, mainBranch: parent.project.mainBranch },
+                    workspaces: orderedTasks.flatMap((task) => task.workspaces.map((workspace) => ({
+                        id: workspace.id,
+                        worktreePath: workspace.worktreePath,
+                        resourcesCleaned: workspace.cleanedAt != null,
+                        workingDir: getWorkspaceWorkingDir(workspace),
+                        workspaceKind: workspace.workspaceKind,
+                        branchName: workspace.branchName,
+                        baseBranch: workspace.baseBranch,
+                        sessions: workspace.sessions.map((session) => ({ id: session.id })),
+                    }))),
+                };
                 await tx.taskCleanupJob.create({
-                    data: {
-                        taskId: taskForCleanup.id,
-                        projectId: taskForCleanup.projectId,
-                        payload: JSON.stringify(snapshot),
-                    },
+                    data: { taskId: id, projectId: parent.projectId, payload: JSON.stringify(snapshot) },
                 });
-                if (teamRunId) {
+                const teamRunIds = tasks.flatMap((task) => task.teamRun ? [task.teamRun.id] : []);
+                if (teamRunIds.length) {
                     await tx.workRequest.updateMany({
-                        where: {
-                            teamRunId,
-                            status: { in: CANCELLABLE_DELETE_WORK_REQUEST_STATUSES },
-                        },
+                        where: { teamRunId: { in: teamRunIds }, status: { in: CANCELLABLE_DELETE_WORK_REQUEST_STATUSES } },
                         data: { status: 'CANCELLED' },
                     });
                     await tx.agentInvocation.updateMany({
-                        where: {
-                            teamRunId,
-                            status: { in: CANCELLABLE_DELETE_INVOCATION_STATUSES },
-                        },
-                        data: {
-                            status: 'CANCELLED',
-                            nextRoomReplyReminderAt: null,
-                        },
+                        where: { teamRunId: { in: teamRunIds }, status: { in: CANCELLABLE_DELETE_INVOCATION_STATUSES } },
+                        data: { status: 'CANCELLED', nextRoomReplyReminderAt: null },
                     });
                 }
+                return {
+                    taskIds, projectId: parent.projectId,
+                    invocationIds: tasks.flatMap((task) => task.teamRun?.invocations.map((invocation) => invocation.id) ?? []),
+                };
             });
-            cleanupJobCreated = true;
-            deleteResult = {
-                projectId: taskForCleanup.projectId,
-                cancelledInvocationIds,
-            };
-        }
-        catch (error) {
-            if (!cleanupJobCreated) {
-                await prisma.task.updateMany({
-                    where: { id, deletedAt },
-                    data: { deletedAt: null },
-                }).catch(() => {
-                    // If rollback fails, leave the task hidden rather than masking the original error.
-                });
-            }
-            throw error;
-        }
-        for (const invocationId of deleteResult.cancelledInvocationIds) {
-            defaultTeamLockService.releaseByOwner(invocationId);
-        }
-        this.eventBus.emit('task:deleted', {
-            taskId: id,
-            projectId: deleteResult.projectId,
         });
+        for (const invocationId of result.invocationIds)
+            defaultTeamLockService.releaseByOwner(invocationId);
+        for (const taskId of result.taskIds)
+            this.eventBus.emit('task:deleted', { taskId, projectId: result.projectId });
         this.cleanupService?.trigger();
         return true;
     }
+    async getDeletionScope(id) {
+        return prisma.$transaction(async (tx) => {
+            const task = await tx.task.findFirst({ where: { id, deletedAt: null }, select: { projectId: true } });
+            if (!task)
+                throw new NotFoundError('Task', id);
+            return { descendantCount: (await tx.task.count({ where: subtreeWhere(id, task.projectId) })) - 1 };
+        });
+    }
+    async getCleanupStatus(taskId) {
+        const job = await prisma.taskCleanupJob.findFirst({
+            where: { taskId }, orderBy: { createdAt: 'desc' },
+            select: { taskId: true, status: true, lastError: true, nextRetryAt: true },
+        });
+        if (!job)
+            throw new NotFoundError('Task cleanup', taskId);
+        return job;
+    }
+    async retryCleanup(taskId) {
+        const job = await prisma.taskCleanupJob.findFirst({ where: { taskId }, orderBy: { createdAt: 'desc' } });
+        if (!job)
+            throw new NotFoundError('Task cleanup', taskId);
+        const project = await prisma.project.findUnique({ where: { id: job.projectId } });
+        if (!project)
+            throw new NotFoundError('Project', job.projectId);
+        ensureProjectIsMutable(project, 'retry task cleanup');
+        await prisma.taskCleanupJob.updateMany({
+            where: { id: job.id, status: 'FAILED' },
+            data: { status: 'PENDING', attempts: 0, lastError: null, nextRetryAt: null },
+        });
+        this.cleanupService?.trigger();
+        return this.getCleanupStatus(taskId);
+    }
     /**
      * 获取项目的任务统计
      */