agent-tower 0.7.4-beta.0 → 0.7.4-beta.2

package/dist/services/task-display-state.js

@@ -0,0 +1,45 @@
+import prismaPkg from '@prisma/client';
+import { TaskStatus } from '@agent-tower/shared';
+const { Prisma } = prismaPkg;
+// Correlated to the outer `task` row. The supported hierarchy has three levels;
+// use the parentTaskId index, including children outside the requested page.
+// Keep project/status checks in the projection: putting them in WHERE makes
+// SQLite prefer the project/status index and scan the project for every task.
+function descendantCount(status) {
+    return Prisma.sql `(
+    SELECT COALESCE(SUM(CASE
+      WHEN descendant."projectId" = task."projectId" AND descendant."status" = ${status} THEN 1
+      ELSE 0
+    END), 0) FROM "Task" descendant
+    WHERE descendant."deletedAt" IS NULL
+      AND descendant."parentTaskId" IN (
+        SELECT task."id"
+        UNION ALL
+        SELECT CASE WHEN child."projectId" = task."projectId" THEN child."id" END FROM "Task" child
+        WHERE child."parentTaskId" = task."id"
+          AND child."deletedAt" IS NULL
+      )
+  )`;
+}
+const runningDescendantCount = descendantCount(TaskStatus.IN_PROGRESS);
+const reviewDescendantCount = descendantCount(TaskStatus.IN_REVIEW);
+// Keep the persisted status for writes and runtime lifecycle decisions.
+// Reads, filters and statistics share this display-only expression.
+export const taskDisplayStatusSql = Prisma.sql `CASE
+  WHEN task."status" = ${TaskStatus.IN_PROGRESS} OR ${runningDescendantCount} > 0 THEN ${TaskStatus.IN_PROGRESS}
+  WHEN task."status" = ${TaskStatus.IN_REVIEW} OR ${reviewDescendantCount} > 0 THEN ${TaskStatus.IN_REVIEW}
+  ELSE task."status"
+END`;
+export const taskDisplayColumnsSql = Prisma.sql `
+  ${taskDisplayStatusSql} AS "displayStatus",
+  ${runningDescendantCount} AS "runningDescendantCount",
+  ${reviewDescendantCount} AS "reviewDescendantCount"
+`;
+export function mapTaskDisplayState(row) {
+    return {
+        displayStatus: row.displayStatus,
+        runningDescendantCount: Number(row.runningDescendantCount),
+        reviewDescendantCount: Number(row.reviewDescendantCount),
+    };
+}
+//# sourceMappingURL=task-display-state.js.map

package/dist/services/task-display-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-display-state.js","sourceRoot":"","sources":["../../src/services/task-display-state.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,UAAU,EAAyB,MAAM,qBAAqB,CAAC;AAExE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;AAE7B,gFAAgF;AAChF,6EAA6E;AAC7E,4EAA4E;AAC5E,8EAA8E;AAC9E,SAAS,eAAe,CAAC,MAAkB;IACzC,OAAO,MAAM,CAAC,GAAG,CAAA;;iFAE8D,MAAM;;;;;;;;;;;IAWnF,CAAC;AACL,CAAC;AAED,MAAM,sBAAsB,GAAG,eAAe,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;AACvE,MAAM,qBAAqB,GAAG,eAAe,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;AAEpE,wEAAwE;AACxE,oEAAoE;AACpE,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAA;yBACrB,UAAU,CAAC,WAAW,OAAO,sBAAsB,aAAa,UAAU,CAAC,WAAW;yBACtF,UAAU,CAAC,SAAS,OAAO,qBAAqB,aAAa,UAAU,CAAC,SAAS;;IAEtG,CAAC;AAEL,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;IAC3C,oBAAoB;IACpB,sBAAsB;IACtB,qBAAqB;CACxB,CAAC;AAQF,MAAM,UAAU,mBAAmB,CAAC,GAAmB;IACrD,OAAO;QACL,aAAa,EAAE,GAAG,CAAC,aAAa;QAChC,sBAAsB,EAAE,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC;QAC1D,qBAAqB,EAAE,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC;KACzD,CAAC;AACJ,CAAC"}

package/dist/services/task.service.d.ts

@@ -5,6 +5,7 @@ import type { SessionManager } from './session-manager.js';
 import type { TaskCleanupService } from './task-cleanup.service.js';
 import type { WorkspaceBackgroundService } from './workspace-background-service.service.js';
 import type { CreateTaskInput, TaskBoardResponse } from '@agent-tower/shared';
+import { type TaskDeletionScope } from '@agent-tower/shared';
 interface UpdateTaskInput {
     title?: string;
     description?: string;
@@ -27,6 +28,8 @@ export declare class TaskService {
     private readonly cleanupService;
     private readonly backgroundService?;
     constructor(eventBus: EventBus, sessionManager: SessionManager, cleanupService?: Pick<TaskCleanupService, 'trigger'> | undefined, backgroundService?: Pick<WorkspaceBackgroundService, "stopAllForWorkspace"> | undefined);
+    /** Page and count using the same display status, before loading associations. */
+    private findPage;
     /**
      * Compact board read model. Query count remains fixed as project/task counts grow.
      */
@@ -36,9 +39,13 @@ export declare class TaskService {
      */
     findByProjectId(projectId: string, params?: FindTasksParams): Promise<{
         data: (Omit<Omit<{
+            subtaskCount: number;
+            displayStatus: import("@agent-tower/shared").TaskStatus;
+            runningDescendantCount: number;
+            reviewDescendantCount: number;
+            status: TaskStatus;
             id: string;
             createdAt: Date;
-            status: string;
             priority: number;
             updatedAt: Date;
             project: {
@@ -96,7 +103,9 @@ export declare class TaskService {
                 commitMessage: string | null;
                 previewTarget: string | null;
                 hibernatedAt: Date | null;
+                cleanedAt: Date | null;
             })[];
+            ancestorIds: string[];
         }, "project" | "handoff"> & {
             project: {
                 name: string;
@@ -193,7 +202,9 @@ export declare class TaskService {
             commitMessage: string | null;
             previewTarget: string | null;
             hibernatedAt: Date | null;
+            cleanedAt: Date | null;
         })[];
+        ancestorIds: string[];
     }, "project" | "handoff"> & {
         project: {
             name: string;
@@ -219,6 +230,11 @@ export declare class TaskService {
         titlePreview: string;
         contentPreview: string | undefined;
         isTruncated: boolean;
+    } & {
+        displayStatus: import("@agent-tower/shared").TaskStatus;
+        runningDescendantCount: number;
+        reviewDescendantCount: number;
+        status: TaskStatus;
     }>;
     findSubtasks(id: string, params?: FindTasksParams): Promise<TaskBoardResponse>;
     findBodyById(id: string): Promise<{
@@ -236,6 +252,7 @@ export declare class TaskService {
      * - 自动计算 position（同状态下最大 position + 1）
      */
     create(projectId: string, input: CreateTaskInput): Promise<{
+        ancestorIds: string[];
         project: {
             isGitRepo: boolean;
             worktreeReady: boolean;
@@ -413,6 +430,7 @@ export declare class TaskService {
      * 4. 后台 worker 再停止 Session、删除 worktree/branch，并最终硬删除 Task
      */
     delete(id: string, expectedSubtaskCount?: number): Promise<boolean>;
+    getDeletionScope(id: string): Promise<TaskDeletionScope>;
     getCleanupStatus(taskId: string): Promise<{
         status: string;
         lastError: string | null;
@@ -482,6 +500,7 @@ export declare class TaskService {
         projectId: string;
         parentTaskId: string | null;
     }>;
+    private withDisplayState;
     /**
      * 发射 task:updated 事件，通知 SocketGateway 转发到前端
      */

package/dist/services/task.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task.service.d.ts","sourceRoot":"","sources":["../../src/services/task.service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"task.service.d.ts","sourceRoot":"","sources":["../../src/services/task.service.ts"],"names":[],"mappings":"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"}

package/dist/services/task.service.js

@@ -8,12 +8,15 @@ import { defaultWorkspaceLifecycleBarrier } from './workspace-lifecycle-barrier.
 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';
+import { taskDisplayColumnsSql, taskDisplayStatusSql, mapTaskDisplayState } from './task-display-state.js';
 const { Prisma } = prismaPkg;
 const taskBoardColumns = Prisma.sql `
   task."id", task."projectId", task."title", task."status", task."priority",
   task."position", task."updatedAt", task."parentTaskId",
+  ${taskDisplayColumnsSql},
+  (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"
 `;
@@ -49,6 +52,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) {
@@ -276,20 +292,11 @@ export class TaskService {
         this.cleanupService = cleanupService;
         this.backgroundService = backgroundService;
     }
-    /**
-     * Compact board read model. Query count remains fixed as project/task counts grow.
-     */
-    async findBoard(params = {}) {
+    /** Page and count using the same display status, before loading associations. */
+    async findPage(params, includeArchived = false) {
         const page = Math.max(1, params.page || 1);
         const limit = Math.min(1000, Math.max(1, params.limit || 1000));
         const skip = (page - 1) * limit;
-        const where = {
-            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;
@@ -297,20 +304,21 @@ export class TaskService {
             ? Prisma.sql `AND task."parentTaskId" = ${params.parentTaskId}`
             : Prisma.empty;
         const statusFilter = params.status
-            ? Prisma.sql `AND task."status" = ${params.status}`
+            ? Prisma.sql `AND (${taskDisplayStatusSql}) = ${params.status}`
             : Prisma.empty;
-        const [tasks, total] = await Promise.all([
+        const fromWhere = Prisma.sql `
+      FROM "Task" task
+      INNER JOIN "Project" project ON project."id" = task."projectId"
+      WHERE task."deletedAt" IS NULL
+        ${includeArchived ? Prisma.empty : Prisma.sql `AND project."archivedAt" IS NULL`}
+        ${projectFilter} ${statusFilter} ${parentFilter}
+    `;
+        const [tasks, counts] = await Promise.all([
             prisma.$queryRaw(Prisma.sql `
         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}
+        ${fromWhere}
         ORDER BY
-          CASE task."status"
+          CASE "displayStatus"
             WHEN ${TaskStatus.IN_PROGRESS} THEN 0
             WHEN ${TaskStatus.IN_REVIEW} THEN 1
             WHEN ${TaskStatus.TODO} THEN 2
@@ -318,22 +326,29 @@ export class TaskService {
             WHEN ${TaskStatus.CANCELLED} THEN 4
             ELSE 99
           END ASC,
-          CASE WHEN task."status" = ${TaskStatus.IN_REVIEW} THEN task."priority" ELSE 0 END DESC,
+          CASE WHEN "displayStatus" = ${TaskStatus.IN_REVIEW} THEN task."priority" ELSE 0 END DESC,
           task."position" ASC,
           task."id" ASC
         LIMIT ${limit} OFFSET ${skip}
       `),
-            prisma.task.count({ where }),
+            prisma.$queryRaw(Prisma.sql `SELECT COUNT(*) AS total ${fromWhere}`),
         ]);
-        // A child can rank ahead of its completed parent or fall on another page.
-        // Return compact parent context without changing the page's count/limit.
+        return { tasks, total: Number(counts[0].total), page, limit };
+    }
+    /**
+     * Compact board read model. Query count remains fixed as project/task counts grow.
+     */
+    async findBoard(params = {}) {
+        const { tasks, total, page, limit } = await this.findPage(params);
+        // 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) => task.parentTaskId && !pageIds.has(task.parentTaskId) ? [task.parentTaskId] : []))];
+        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 (${Prisma.join(missingParentIds)})
+        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];
@@ -405,10 +420,12 @@ export class TaskService {
                 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,
+                ...mapTaskDisplayState(task),
                 priority: task.priority ?? TaskPriority.NORMAL,
                 ...(preferredWorkspace ? {
                     preferredWorkspace: {
@@ -445,60 +462,37 @@ export class TaskService {
         if (!project) {
             throw new NotFoundError('Project', projectId);
         }
-        const page = Math.max(1, params.page || 1);
-        const limit = Math.min(1000, Math.max(1, params.limit || 200));
-        const skip = (page - 1) * limit;
-        const where = { projectId, deletedAt: null };
-        if (params.status) {
-            where.status = params.status;
-        }
-        // Active tasks first (IN_PROGRESS → IN_REVIEW → TODO), then completed (DONE → CANCELLED).
-        // Raw SQL CASE needed because Prisma orderBy doesn't support custom sort functions.
-        const statusOrder = {
-            [TaskStatus.IN_PROGRESS]: 0,
-            [TaskStatus.IN_REVIEW]: 1,
-            [TaskStatus.TODO]: 2,
-            [TaskStatus.DONE]: 3,
-            [TaskStatus.CANCELLED]: 4,
-        };
-        const [data, total] = await Promise.all([
-            prisma.task.findMany({
-                where,
-                select: {
-                    id: true,
-                    projectId: true,
-                    title: true,
-                    baseBranch: true,
-                    parentTaskId: true,
-                    status: true,
-                    priority: true,
-                    position: true,
-                    createdAt: true,
-                    updatedAt: true,
-                    workspaces: { include: { sessions: visibleSessionSummary } },
-                    project: true,
-                },
-                orderBy: [{ updatedAt: 'desc' }],
-                skip,
-                take: limit,
-            }),
-            prisma.task.count({ where }),
-        ]);
-        data.sort((a, b) => {
-            const sa = statusOrder[a.status] ?? 99;
-            const sb = statusOrder[b.status] ?? 99;
-            if (sa !== sb)
-                return sa - sb;
-            if (a.status === TaskStatus.IN_REVIEW) {
-                const priorityDelta = (b.priority ?? TaskPriority.NORMAL) - (a.priority ?? TaskPriority.NORMAL);
-                if (priorityDelta !== 0)
-                    return priorityDelta;
-            }
-            return (a.position ?? 0) - (b.position ?? 0) || a.id.localeCompare(b.id);
+        const { tasks, total, page, limit } = await this.findPage({
+            ...params, projectId, limit: params.limit || 200,
+        }, true);
+        const data = await prisma.task.findMany({
+            where: { id: { in: tasks.map(task => task.id) }, deletedAt: null },
+            select: {
+                id: true,
+                projectId: true,
+                title: true,
+                baseBranch: true,
+                parentTaskId: true,
+                parentTask: { select: { parentTaskId: true } },
+                status: true,
+                priority: true,
+                position: true,
+                createdAt: true,
+                updatedAt: true,
+                workspaces: { include: { sessions: visibleSessionSummary } },
+                project: true,
+            },
         });
+        const byId = new Map(data.map(task => [task.id, task]));
         const projectGitCapability = getStoredProjectGitCapability(project);
         return {
-            data: data.map((task) => (withTaskPreviews(withProjectGitCapability(task, projectGitCapability), { omitDescription: true }))),
+            data: tasks.flatMap(row => {
+                const task = byId.get(row.id);
+                return task ? [withTaskPreviews(withProjectGitCapability({
+                        ...withHierarchy(task), status: row.status, ...mapTaskDisplayState(row),
+                        subtaskCount: Number(row.subtaskCount),
+                    }, projectGitCapability), { omitDescription: true })] : [];
+            }),
             total,
             page,
             limit,
@@ -518,6 +512,7 @@ export class TaskService {
                 title: true,
                 baseBranch: true,
                 parentTaskId: true,
+                parentTask: { select: { parentTaskId: true } },
                 _count: { select: { subtasks: { where: { deletedAt: null } } } },
                 status: true,
                 priority: true,
@@ -531,7 +526,7 @@ export class TaskService {
             throw new NotFoundError('Task', id);
         }
         const { _count, ...metadata } = task;
-        return withTaskPreviews(withProjectGitMetadata({ ...metadata, subtaskCount: _count.subtasks }), { omitDescription: true });
+        return this.withDisplayState(withTaskPreviews(withProjectGitMetadata({ ...withHierarchy(metadata), subtaskCount: _count.subtasks }), { omitDescription: true }));
     }
     async findSubtasks(id, params = {}) {
         const parent = await prisma.task.findFirst({ where: { id, deletedAt: null } });
@@ -592,19 +587,26 @@ export class TaskService {
         ensureProjectIsMutable(project, 'create tasks');
         const parent = input.parentTaskId ? await prisma.task.findFirst({
             where: { id: input.parentTaskId, projectId, deletedAt: null },
-            include: { workspaces: {
-                    where: { parentWorkspaceId: null, ownerMemberId: null, status: { not: WorkspaceStatus.ABANDONED } },
+            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?.parentTaskId)
-            throw new ValidationError('Subtasks cannot have their own subtasks');
+        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 },
+        });
         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.
@@ -625,9 +627,12 @@ export class TaskService {
                 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: {
@@ -646,6 +651,7 @@ export class TaskService {
                 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),
@@ -654,9 +660,7 @@ export class TaskService {
         };
         // Serialize branch validation and child persistence with parent workspace
         // cleanup, so its reference becomes visible before that branch is reclaimed.
-        return parentWorkspace
-            ? defaultWorkspaceLifecycleBarrier.withWorkspace(parentWorkspace.id, createWithParentBranch)
-            : createWithParentBranch();
+        return defaultWorkspaceLifecycleBarrier.withWorkspaces([...branchOwners.map(workspace => workspace.id), ...(parentWorkspace ? [parentWorkspace.id] : [])], createWithParentBranch);
     }
     /**
      * 更新任务基本信息
@@ -781,13 +785,14 @@ export class TaskService {
         if (!taskForGuard || taskForGuard.deletedAt)
             throw new NotFoundError('Task', id);
         ensureProjectIsMutable(taskForGuard.project, 'delete tasks');
-        if (expectedSubtaskCount !== undefined && expectedSubtaskCount !== await prisma.task.count({
-            where: { parentTaskId: id, deletedAt: null },
-        })) {
+        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: { task: { OR: [{ id }, { parentTaskId: id }], deletedAt: null } },
+            where: { task: familyWhere },
             select: { id: true },
         });
         const result = await defaultWorkspaceLifecycleBarrier.withWorkspaces(workspaceIds.map((workspace) => workspace.id), async () => {
@@ -801,13 +806,23 @@ export class TaskService {
                     throw new NotFoundError('Task', id);
                 ensureProjectIsMutable(parent.project, 'delete tasks');
                 const family = await tx.task.findMany({
-                    where: { OR: [{ id }, { parentTaskId: id }], deletedAt: null },
-                    select: { id: true },
+                    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 taskIds = [...family.filter((task) => task.id !== id).map((task) => task.id), id];
+                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 } },
@@ -826,6 +841,7 @@ export class TaskService {
                     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,
@@ -860,6 +876,14 @@ export class TaskService {
         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' },
@@ -894,11 +918,11 @@ export class TaskService {
         if (!project) {
             throw new NotFoundError('Project', projectId);
         }
-        const counts = await prisma.task.groupBy({
-            by: ['status'],
-            where: { projectId, deletedAt: null },
-            _count: { id: true },
-        });
+        const counts = await prisma.$queryRaw(Prisma.sql `
+      SELECT ${taskDisplayStatusSql} AS "displayStatus", COUNT(*) AS count
+      FROM "Task" task WHERE task."projectId" = ${projectId} AND task."deletedAt" IS NULL
+      GROUP BY "displayStatus"
+    `);
         const stats = {
             total: 0,
             todo: 0,
@@ -908,9 +932,9 @@ export class TaskService {
             cancelled: 0,
         };
         for (const row of counts) {
-            const count = row._count.id;
+            const count = Number(row.count);
             stats.total += count;
-            switch (row.status) {
+            switch (row.displayStatus) {
                 case TaskStatus.TODO:
                     stats.todo = count;
                     break;
@@ -985,6 +1009,15 @@ export class TaskService {
         };
     }
     // ── 内部方法 ────────────────────────────────────────────────────────────────
+    async withDisplayState(task) {
+        const [state] = await prisma.$queryRaw(Prisma.sql `
+      SELECT task."status", ${taskDisplayColumnsSql} FROM "Task" task
+      WHERE task."id" = ${task.id} AND task."deletedAt" IS NULL
+    `);
+        if (!state)
+            throw new NotFoundError('Task', task.id);
+        return { ...task, status: state.status, ...mapTaskDisplayState(state) };
+    }
     /**
      * 发射 task:updated 事件，通知 SocketGateway 转发到前端
      */