crewly 1.5.18 → 1.5.20

package/dist/backend/backend/src/controllers/task-management/task-management.controller.js

@@ -13,6 +13,83 @@ import { TASK_OUTPUT_CONSTANTS } from '../../types/task-output.types.js';
 const logger = LoggerService.getInstance().createComponentLogger('TaskManagementController');
 /** Module-level reference to EventBusService for auto-cleanup on task completion */
 let eventBusService = null;
+// ---------------------------------------------------------------------------
+// V3.1 Projection Hooks — fire-and-forget wrappers injected into legacy routes
+// ---------------------------------------------------------------------------
+/**
+ * Projects a legacy task-management accept into a TaskRecord (fire-and-forget).
+ * Called when an agent successfully calls /task-management/take-next.
+ *
+ * @param taskTitle - Task title parsed from the .md file
+ * @param taskPath - Absolute path to the task file (used as stable key in title)
+ * @param sessionName - Agent session that accepted the task
+ */
+function projectTaskAccepted(taskTitle, taskPath, sessionName) {
+    setImmediate(async () => {
+        try {
+            const { TaskProjectionService } = await import('../../services/v3/task-projection.service.js');
+            const proj = TaskProjectionService.getInstance();
+            const record = await proj.createRecord({
+                title: taskTitle || basename(taskPath, '.md'),
+                type: 'self_execution',
+                ownerAgent: sessionName,
+            });
+            await proj.markStarted(record.id, sessionName);
+        }
+        catch {
+            // Non-critical
+        }
+    });
+}
+/**
+ * Projects a legacy task completion into the most recent running TaskRecord for this agent.
+ * Called when /task-management/complete succeeds.
+ *
+ * @param sessionName - Agent session that completed the task
+ * @param taskTitle - Task title (for matching)
+ */
+function projectTaskCompleted(sessionName, taskTitle) {
+    setImmediate(async () => {
+        try {
+            const { TaskProjectionService } = await import('../../services/v3/task-projection.service.js');
+            const proj = TaskProjectionService.getInstance();
+            // Find the most recent running TaskRecord for this agent
+            const records = proj.listRecords({ ownerAgent: sessionName, status: 'running' });
+            // Prefer an exact title match, fall back to most recent
+            const match = records.find(r => r.title === taskTitle) || records[records.length - 1];
+            if (match) {
+                await proj.markDone(match.id, sessionName);
+            }
+        }
+        catch {
+            // Non-critical
+        }
+    });
+}
+/**
+ * Projects a legacy task block into the most recent running TaskRecord for this agent.
+ * Called when /task-management/block succeeds.
+ *
+ * @param sessionName - Agent session that blocked the task
+ * @param reason - Block reason
+ * @param taskTitle - Task title (for matching)
+ */
+function projectTaskBlocked(sessionName, reason, taskTitle) {
+    setImmediate(async () => {
+        try {
+            const { TaskProjectionService } = await import('../../services/v3/task-projection.service.js');
+            const proj = TaskProjectionService.getInstance();
+            const records = proj.listRecords({ ownerAgent: sessionName, status: 'running' });
+            const match = records.find(r => r.title === taskTitle) || records[records.length - 1];
+            if (match) {
+                await proj.markBlocked(match.id, sessionName, reason);
+            }
+        }
+        catch {
+            // Non-critical
+        }
+    });
+}
 /**
  * Publish a task:completed event to the EventBus (#137) and send a Slack
  * notification to the user (#202). Both are fire-and-forget — errors are
@@ -102,7 +179,7 @@ export async function createTask(req, res) {
         }
     }, async (span) => {
         try {
-            const { projectPath, task, priority = 'medium', sessionName, milestone = 'delegated', outputSchema, } = req.body;
+            const { projectPath, task, priority = 'medium', sessionName, milestone = 'delegated', outputSchema, requestId, } = req.body;
             if (!projectPath) {
                 res.status(400).json({ success: false, error: 'projectPath is required' });
                 return;
@@ -154,33 +231,35 @@ export async function createTask(req, res) {
                     });
                 }
             }
-            // If assigned, track via TaskTrackingService
+            // trackedTaskId derived from V3 hook below (legacy TaskTrackingService removed)
             let trackedTaskId;
-            if (sessionName) {
+            // V3 Hook: emit v3:task_delegated for automatic WorkItem creation.
+            // Uses explicit requestId only — no time-window fallback — to avoid
+            // mis-association in high-concurrency scenarios.
+            if (sessionName && eventBusService) {
                 try {
-                    const projects = await this.storageService.getProjects();
-                    const project = projects.find(p => projectPath.startsWith(p.path));
-                    if (project) {
-                        const teams = await this.storageService.getTeams();
-                        let teamId = '';
-                        let memberId = '';
-                        for (const team of teams) {
-                            const member = team.members.find(m => m.sessionName === sessionName);
-                            if (member) {
-                                teamId = team.id;
-                                memberId = member.id;
-                                break;
-                            }
-                        }
-                        if (teamId) {
-                            const trackedTask = await this.taskTrackingService.assignTask(project.id, teamId, taskPath, task, 'delegated', memberId, sessionName);
-                            trackedTaskId = trackedTask?.id;
-                        }
-                    }
+                    const taskIdForEvent = trackedTaskId || `${sanitizedName}_${timestamp}`;
+                    eventBusService.emit('v3:task_delegated', {
+                        taskId: taskIdForEvent,
+                        title: task,
+                        description: task,
+                        assignedTo: sessionName,
+                        priority,
+                        projectPath,
+                        milestone,
+                        requestId: requestId || undefined,
+                        timestamp: new Date().toISOString(),
+                    });
+                    logger.debug('Emitted v3:task_delegated', {
+                        taskId: taskIdForEvent,
+                        assignedTo: sessionName,
+                        requestId: requestId || undefined,
+                    });
                 }
-                catch (trackingError) {
-                    logger.warn('Failed to track task assignment', { error: trackingError instanceof Error ? trackingError.message : String(trackingError) });
-                    // Non-fatal - the file was still created
+                catch (err) {
+                    logger.warn('Failed to emit v3:task_delegated (non-fatal)', {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
                 }
             }
             res.json({
@@ -296,8 +375,7 @@ export async function assignTask(req, res) {
             const updatedContent = addTaskAssignmentInfo(taskContent, memberId, sessionName);
             await writeFile(targetPath, updatedContent, 'utf-8');
             await unlinkFile(taskPath);
-            // Add to task tracking
-            await this.taskTrackingService.assignTask(project.id, teamId, targetPath, taskInfo.title || taskInfo.fileName, taskInfo.targetRole || 'unknown', memberId, sessionName);
+            // Legacy TaskTrackingService removed — V3 WorkItems handle tracking
             res.json({
                 success: true,
                 message: `Task ${fileName} assigned to member ${sessionName}`,
@@ -470,20 +548,19 @@ export async function completeTask(req, res) {
                 const updatedContent = addTaskCompletionInfo(taskContent);
                 await writeFile(doneTargetPath, updatedContent, 'utf-8');
                 await unlinkFile(taskPath);
-                // Remove from task tracking and clean up monitoring
-                const allTasksWithSchema = await this.taskTrackingService.getAllInProgressTasks();
-                const taskToRemoveWithSchema = allTasksWithSchema.find(t => t.taskFilePath === taskPath);
+                // Remove from task tracking and clean up monitoring via TaskPool
                 let cleanupResultSchema = { cancelledSchedules: 0, unsubscribedEvents: 0 };
-                if (taskToRemoveWithSchema) {
-                    // #174: Store quality score on task before completing
-                    if (typeof qualityScore === 'number' && qualityScore >= 0 && qualityScore <= 100) {
-                        taskToRemoveWithSchema.qualityScore = qualityScore;
-                        taskToRemoveWithSchema.scoredAt = new Date().toISOString();
-                        taskToRemoveWithSchema.scoredBy = sessionName;
+                try {
+                    const { TaskPoolService } = await import('../../services/task-pool/task-pool.service.js');
+                    const pool = TaskPoolService.getInstance();
+                    const allItems = await pool.getAllItems();
+                    const matchingItem = allItems.find(wi => wi.target === sessionName && wi.status === 'running');
+                    if (matchingItem) {
+                        await pool.completeItem(matchingItem.id, { completedAt: new Date().toISOString() });
                     }
-                    publishTaskCompletedEvent(taskToRemoveWithSchema, sessionName);
-                    cleanupResultSchema = await cleanupTaskMonitoring(this, taskToRemoveWithSchema);
-                    await this.taskTrackingService.removeTask(taskToRemoveWithSchema.id);
+                }
+                catch (poolErr) {
+                    logger.debug('TaskPool cleanup skipped (non-fatal)', { error: poolErr instanceof Error ? poolErr.message : String(poolErr) });
                 }
                 res.json({
                     success: true,
@@ -495,6 +572,9 @@ export async function completeTask(req, res) {
                     completedAt: new Date().toISOString(),
                     monitoringCleanup: cleanupResultSchema,
                 });
+                // V3.1 Projection (fire-and-forget)
+                if (sessionName)
+                    projectTaskCompleted(sessionName, basename(taskPath, '.md'));
                 return;
             }
             // No schema - original behavior (backward compatible)
@@ -507,20 +587,19 @@ export async function completeTask(req, res) {
             const updatedContent = addTaskCompletionInfo(taskContent);
             await writeFile(targetPath, updatedContent, 'utf-8');
             await unlinkFile(taskPath);
-            // Remove from task tracking and clean up monitoring
-            const allTasks = await this.taskTrackingService.getAllInProgressTasks();
-            const taskToRemove = allTasks.find(t => t.taskFilePath === taskPath);
+            // Remove from task tracking and clean up monitoring via TaskPool
             let cleanupResult = { cancelledSchedules: 0, unsubscribedEvents: 0 };
-            if (taskToRemove) {
-                // #174: Store quality score on task before completing
-                if (typeof qualityScore === 'number' && qualityScore >= 0 && qualityScore <= 100) {
-                    taskToRemove.qualityScore = qualityScore;
-                    taskToRemove.scoredAt = new Date().toISOString();
-                    taskToRemove.scoredBy = sessionName;
+            try {
+                const { TaskPoolService } = await import('../../services/task-pool/task-pool.service.js');
+                const pool = TaskPoolService.getInstance();
+                const allItems = await pool.getAllItems();
+                const matchingItem = allItems.find(wi => wi.target === sessionName && wi.status === 'running');
+                if (matchingItem) {
+                    await pool.completeItem(matchingItem.id, { completedAt: new Date().toISOString() });
                 }
-                publishTaskCompletedEvent(taskToRemove, sessionName);
-                cleanupResult = await cleanupTaskMonitoring(this, taskToRemove);
-                await this.taskTrackingService.removeTask(taskToRemove.id);
+            }
+            catch (poolErr) {
+                logger.debug('TaskPool cleanup skipped (non-fatal)', { error: poolErr instanceof Error ? poolErr.message : String(poolErr) });
             }
             res.json({
                 success: true,
@@ -531,6 +610,9 @@ export async function completeTask(req, res) {
                 completedAt: new Date().toISOString(),
                 monitoringCleanup: cleanupResult,
             });
+            // V3.1 Projection (fire-and-forget)
+            if (sessionName)
+                projectTaskCompleted(sessionName, basename(taskPath, '.md'));
         }
         catch (error) {
             logger.error('Error completing task', { error: error instanceof Error ? error.message : String(error) });
@@ -595,6 +677,10 @@ export async function blockTask(req, res) {
             blockReason: blockReason || 'No reason provided',
             blockedAt: new Date().toISOString(),
         });
+        // V3.1 Projection (fire-and-forget)
+        const { sessionName: blockSession } = req.body;
+        if (blockSession)
+            projectTaskBlocked(blockSession, blockReason || 'unspecified', basename(taskPath, '.md'));
     }
     catch (error) {
         logger.error('Error blocking task', { error: error instanceof Error ? error.message : String(error) });
@@ -711,6 +797,11 @@ export async function takeNextTask(req, res) {
             totalAvailable: taskFiles.length,
             openTasksPath,
         });
+        // V3.1 Projection: record that this agent accepted a task (fire-and-forget)
+        const { sessionName: sn } = req.body;
+        if (sn) {
+            projectTaskAccepted(taskInfo.title || nextTaskFile, taskPath, sn);
+        }
     }
     catch (error) {
         logger.error('Error getting next task', { error: error instanceof Error ? error.message : String(error) });
@@ -951,30 +1042,8 @@ export async function startTaskExecution(req, res) {
  * @param res - Response with recovery report
  */
 export async function recoverAbandonedTasks(req, res) {
-    try {
-        logger.info('Starting abandoned task recovery');
-        // Function to get current team status from storage
-        const getTeamStatus = async () => {
-            const teams = await this.storageService.getTeams();
-            return teams;
-        };
-        // Run recovery
-        const report = await this.taskTrackingService.recoverAbandonedTasks(getTeamStatus);
-        logger.info('Recovery completed', { report });
-        res.json({
-            success: true,
-            message: `Task recovery completed. Recovered: ${report.recovered}, Skipped: ${report.skipped}`,
-            data: report
-        });
-    }
-    catch (error) {
-        logger.error('Recovery failed', { error: error instanceof Error ? error.message : String(error) });
-        res.status(500).json({
-            success: false,
-            error: 'Failed to recover abandoned tasks',
-            details: error instanceof Error ? error.message : String(error)
-        });
-    }
+    // Legacy — no-op, will be rebuilt on V3 WorkItem system
+    res.json({ success: true, message: 'Deprecated — use TaskPool API', data: { recovered: 0, skipped: 0, total: 0 } });
 }
 export async function createTasksFromConfig(req, res) {
     try {
@@ -1199,17 +1268,21 @@ function parseTaskInfo(content, fileName) {
     if (titleMatch) {
         info.title = titleMatch.substring(2).trim();
     }
-    // Extract target role from task information section
-    const targetRoleMatch = lines.find((line) => line.includes('**Target Role**:'));
-    if (targetRoleMatch) {
-        info.targetRole = targetRoleMatch.split('**Target Role**:')[1]?.trim();
-    }
-    // Extract estimated delay
-    const delayMatch = lines.find((line) => line.includes('**Estimated Delay**:'));
-    if (delayMatch) {
-        const delayText = delayMatch.split('**Estimated Delay**:')[1]?.trim();
-        info.estimatedDelay = delayText;
-    }
+    // Extract metadata from the task information section (lines starting with - **Key**: Value)
+    lines.forEach(line => {
+        const match = line.match(/^- \*\*([^*]+)\*\*: (.*)$/);
+        if (match) {
+            const key = match[1].trim().toLowerCase().replace(/ /g, '');
+            const value = match[2].trim();
+            // Map specific keys if needed, otherwise use the lowercased key
+            if (key === 'targetrole')
+                info.targetRole = value;
+            else if (key === 'estimateddelay')
+                info.estimatedDelay = value;
+            else
+                info[key] = value;
+        }
+    });
     return info;
 }
 /**
@@ -1248,11 +1321,15 @@ export async function readTask(req, res) {
         }
         // Read file content
         const content = await readFile(taskPath, 'utf-8');
+        const metadata = parseTaskInfo(content, basename(taskPath));
         res.json({
             success: true,
-            content: content,
-            taskPath: taskPath,
-            fileSize: content.length,
+            data: {
+                content: content,
+                metadata: metadata,
+                taskPath: taskPath,
+                fileSize: content.length,
+            }
         });
     }
     catch (error) {
@@ -1388,62 +1465,13 @@ async function cleanupTaskMonitoring(controller, task) {
     }
     return { cancelledSchedules, unsubscribedEvents };
 }
-/**
- * Adds monitoring IDs (schedule and subscription IDs) to tasks for a given agent session.
- * Called by delegate-task after setting up auto-monitoring to link monitoring resources
- * to the task for auto-cleanup on completion.
- *
- * @param req - Request containing sessionName, scheduleIds, subscriptionIds
- * @param res - Response with success status
- */
 export async function addMonitoring(req, res) {
-    try {
-        const { sessionName, scheduleIds = [], subscriptionIds = [] } = req.body;
-        if (!sessionName) {
-            res.status(400).json({ success: false, error: 'sessionName is required' });
-            return;
-        }
-        if (scheduleIds.length === 0 && subscriptionIds.length === 0) {
-            res.status(400).json({ success: false, error: 'At least one scheduleId or subscriptionId is required' });
-            return;
-        }
-        // Find the most recent task assigned to this session
-        const tasks = await this.taskTrackingService.getTasksBySessionName(sessionName);
-        if (tasks.length === 0) {
-            // No tracked task found — store IDs anyway by finding any in_progress_tasks entry
-            logger.warn('No tracked tasks found for session, storing monitoring IDs for session-level cleanup', { sessionName });
-            res.json({
-                success: true,
-                message: 'No tracked task found for session; monitoring IDs noted but not linked to a task',
-                sessionName,
-                scheduleIds,
-                subscriptionIds,
-            });
-            return;
-        }
-        // Link to the most recently assigned task
-        const latestTask = tasks.sort((a, b) => new Date(b.assignedAt).getTime() - new Date(a.assignedAt).getTime())[0];
-        await this.taskTrackingService.addMonitoringIds(latestTask.id, scheduleIds, subscriptionIds);
-        res.json({
-            success: true,
-            message: 'Monitoring IDs linked to task',
-            taskId: latestTask.id,
-            taskName: latestTask.taskName,
-            scheduleIds,
-            subscriptionIds,
-        });
-    }
-    catch (error) {
-        logger.error('Error adding monitoring IDs', { error: error instanceof Error ? error.message : String(error) });
-        res.status(500).json({ success: false, error: 'Failed to add monitoring IDs' });
-    }
+    // Legacy — no-op, will be rebuilt on V3 WorkItem system
+    res.json({ success: true, message: 'Deprecated — use TaskPool API' });
 }
 /**
  * Completes all tasks assigned to a given agent session.
- *
- * Called by the report-status skill when an agent reports status=done.
- * Finds all in-progress/assigned tasks for the session, marks them as
- * completed in task tracking, and cleans up monitoring resources.
+ * Finds running WorkItems for the session in the TaskPool and marks them done.
  *
  * @param req - Request containing sessionName
  * @param res - Response with list of completed tasks
@@ -1455,9 +1483,11 @@ export async function completeTasksBySession(req, res) {
             res.status(400).json({ success: false, error: 'sessionName is required' });
             return;
         }
-        const tasks = await this.taskTrackingService.getTasksBySessionName(sessionName);
-        const activeTasks = tasks.filter(t => t.status === 'assigned' || t.status === 'active');
-        if (activeTasks.length === 0) {
+        const { TaskPoolService } = await import('../../services/task-pool/task-pool.service.js');
+        const pool = TaskPoolService.getInstance();
+        const allItems = await pool.getAllItems();
+        const activeItems = allItems.filter(wi => wi.target === sessionName && (wi.status === 'running' || wi.status === 'queued'));
+        if (activeItems.length === 0) {
             res.json({
                 success: true,
                 message: 'No active tasks found for session',
@@ -1468,51 +1498,35 @@ export async function completeTasksBySession(req, res) {
             return;
         }
         const completedTasks = [];
-        let totalCancelledSchedules = 0;
-        let totalUnsubscribedEvents = 0;
-        for (const task of activeTasks) {
+        for (const item of activeItems) {
             try {
-                // Move task file from in_progress/ to done/ if it exists
-                if (task.taskFilePath && task.taskFilePath.includes('/in_progress/') && existsSync(task.taskFilePath)) {
+                // Move task file from in_progress/ to done/ if applicable
+                // (WorkItems may not always have a file path, but we handle it gracefully)
+                await pool.completeItem(item.id, { completedAt: new Date().toISOString() });
+                completedTasks.push(item.title);
+                logger.info('Auto-completed WorkItem for session', {
+                    workItemId: item.id,
+                    title: item.title,
+                    sessionName,
+                });
+                // V3 Hook: emit v3:task_completed
+                if (eventBusService) {
                     try {
-                        const targetPath = task.taskFilePath.replace('/in_progress/', '/done/');
-                        const targetDir = dirname(targetPath);
-                        await ensureDirectoryExists(targetDir);
-                        const taskContent = await readFile(task.taskFilePath, 'utf-8');
-                        const updatedContent = addTaskCompletionInfo(taskContent);
-                        await writeFile(targetPath, updatedContent, 'utf-8');
-                        await unlink(task.taskFilePath);
-                        logger.debug('Moved task file to done', {
-                            taskId: task.id,
-                            from: task.taskFilePath,
-                            to: targetPath,
+                        eventBusService.emit('v3:task_completed', {
+                            taskId: item.id,
+                            sessionName,
+                            timestamp: new Date().toISOString(),
                         });
                     }
-                    catch (fileError) {
-                        logger.warn('Failed to move task file to done (continuing with tracking cleanup)', {
-                            taskId: task.id,
-                            taskFilePath: task.taskFilePath,
-                            error: fileError instanceof Error ? fileError.message : String(fileError),
-                        });
+                    catch {
+                        // non-fatal
                     }
                 }
-                // Clean up monitoring resources
-                const cleanup = await cleanupTaskMonitoring(this, task);
-                totalCancelledSchedules += cleanup.cancelledSchedules;
-                totalUnsubscribedEvents += cleanup.unsubscribedEvents;
-                // Remove from tracking
-                await this.taskTrackingService.removeTask(task.id);
-                completedTasks.push(task.taskName);
-                logger.info('Auto-completed task for session', {
-                    taskId: task.id,
-                    taskName: task.taskName,
-                    sessionName,
-                });
             }
             catch (error) {
-                logger.warn('Failed to auto-complete task', {
-                    taskId: task.id,
-                    taskName: task.taskName,
+                logger.warn('Failed to auto-complete WorkItem', {
+                    workItemId: item.id,
+                    title: item.title,
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
@@ -1523,10 +1537,6 @@ export async function completeTasksBySession(req, res) {
             sessionName,
             completedCount: completedTasks.length,
             completedTasks,
-            monitoringCleanup: {
-                cancelledSchedules: totalCancelledSchedules,
-                unsubscribedEvents: totalUnsubscribedEvents,
-            },
         });
     }
     catch (error) {
@@ -1544,79 +1554,15 @@ export async function completeTasksBySession(req, res) {
  * @param res - Response with { success, tasks }
  */
 /**
- * Detect and optionally clean up orphan tasks — tasks stuck in progress
- * assigned to agents that no longer exist or have been inactive too long.
- *
- * POST /api/task-management/cleanup
- * Body:
- *   - action: 'detect' (default, dry run) | 'cancel' | 'reopen'
- *   - staleThresholdHours: number (default 24)
- *   - taskIds: string[] (optional, specific tasks to clean; if omitted, cleans all detected orphans)
+ * Detect and optionally clean up orphan tasks.
+ * Legacy — no-op, will be rebuilt on V3 WorkItem system.
  *
  * @param req - Request with cleanup parameters
- * @param res - Response with orphan detection/cleanup report
- * @see https://github.com/stevehuang0115/crewly/issues/168
+ * @param res - Response with deprecation notice
  */
 export async function cleanupOrphanTasks(req, res) {
-    try {
-        const { action = 'detect', staleThresholdHours = 24, taskIds, } = req.body;
-        const staleThresholdMs = staleThresholdHours * 60 * 60 * 1000;
-        const getTeamStatus = async () => {
-            return await this.storageService.getTeams();
-        };
-        // Step 1: Detect orphan tasks
-        const orphans = await this.taskTrackingService.detectOrphanTasks(getTeamStatus, staleThresholdMs);
-        if (action === 'detect') {
-            res.json({
-                success: true,
-                message: `Found ${orphans.length} orphan task(s)`,
-                data: {
-                    orphanCount: orphans.length,
-                    orphans: orphans.map(t => ({
-                        id: t.id,
-                        taskName: t.taskName,
-                        assignedSessionName: t.assignedSessionName,
-                        assignedTeamMemberId: t.assignedTeamMemberId,
-                        status: t.status,
-                        assignedAt: t.assignedAt,
-                        staleSinceHours: Math.round(t.staleSinceMs / (60 * 60 * 1000) * 10) / 10,
-                        taskFilePath: t.taskFilePath,
-                    })),
-                },
-            });
-            return;
-        }
-        // Step 2: Clean up
-        const idsToClean = taskIds || orphans.map(t => t.id);
-        if (idsToClean.length === 0) {
-            res.json({ success: true, message: 'No orphan tasks to clean up', data: { cleaned: 0 } });
-            return;
-        }
-        const cleanupAction = action === 'reopen' ? 'reopen' : 'cancel';
-        const report = await this.taskTrackingService.cleanupOrphanTasks(idsToClean, cleanupAction);
-        logger.info('Orphan task cleanup completed', {
-            action: cleanupAction,
-            cleaned: report.cleaned,
-            errors: report.errors.length,
-        });
-        res.json({
-            success: true,
-            message: `Cleaned ${report.cleaned} orphan task(s) (action: ${cleanupAction})`,
-            data: {
-                cleaned: report.cleaned,
-                errors: report.errors,
-                totalOrphansDetected: orphans.length,
-            },
-        });
-    }
-    catch (error) {
-        logger.error('Orphan task cleanup failed', { error: error instanceof Error ? error.message : String(error) });
-        res.status(500).json({
-            success: false,
-            error: 'Failed to clean up orphan tasks',
-            details: error instanceof Error ? error.message : String(error),
-        });
-    }
+    // Legacy — no-op, will be rebuilt on V3 WorkItem system
+    res.json({ success: true, message: 'Deprecated — use TaskPool API', data: { orphanCount: 0, orphans: [], cleaned: 0 } });
 }
 export async function listTasks(req, res) {
     try {
@@ -1671,14 +1617,6 @@ export async function listTasks(req, res) {
         res.status(500).json({ success: false, error: 'Failed to list tasks' });
     }
 }
-/**
- * Score a completed task's quality (#174).
- * Called by the auditor's score-task skill after task:completed events.
- * Updates the task's qualityScore in the tracking data.
- *
- * @param req - Request containing taskId, qualityScore, and optional scoredBy
- * @param res - Response with success status
- */
 export async function scoreTask(req, res) {
     try {
         const { taskId, qualityScore, scoredBy } = req.body;
@@ -1690,40 +1628,15 @@ export async function scoreTask(req, res) {
             res.status(400).json({ success: false, error: 'qualityScore must be a number between 0 and 100' });
             return;
         }
-        // Load task data directly for in-place update
-        const taskData = await this.taskTrackingService.loadTaskData();
-        const task = taskData.tasks.find(t => t.id === taskId);
-        if (task) {
-            // Task still in tracking — update in place and persist
-            task.qualityScore = qualityScore;
-            task.scoredAt = new Date().toISOString();
-            task.scoredBy = scoredBy || 'auditor';
-            await this.taskTrackingService.saveTaskData(taskData);
-            logger.info('Task scored', { taskId, qualityScore, scoredBy: scoredBy || 'auditor' });
-            res.json({ success: true, message: 'Task scored successfully', taskId, qualityScore });
-        }
-        else {
-            // Task already removed from tracking — score acknowledged
-            logger.warn('Task not found in tracking (may already be completed)', { taskId });
-            res.json({ success: true, message: 'Score acknowledged but task already completed', taskId, qualityScore });
-        }
+        // Legacy TaskTrackingService removed — score acknowledged but not persisted in legacy store
+        logger.info('Task scored (legacy store removed, score acknowledged)', { taskId, qualityScore, scoredBy: scoredBy || 'auditor' });
+        res.json({ success: true, message: 'Score acknowledged (legacy tracking removed)', taskId, qualityScore });
     }
     catch (error) {
         logger.error('Error scoring task', { error: error instanceof Error ? error.message : String(error) });
         res.status(500).json({ success: false, error: 'Failed to score task' });
     }
 }
-/**
- * Record a task handoff from one agent to another (F12).
- *
- * POST /api/task-management/handoff
- * Body: { from, to, taskPath?, reason, progress?, projectPath? }
- *
- * Updates the task tracking data to reflect the handoff and logs the event.
- *
- * @param req - Request with handoff parameters
- * @param res - Response with handoff record
- */
 export async function recordHandoff(req, res) {
     try {
         const { from, to, taskPath, reason, progress, projectPath } = req.body;
@@ -1731,35 +1644,15 @@ export async function recordHandoff(req, res) {
             res.status(400).json({ success: false, error: 'from, to, and reason are required' });
             return;
         }
-        // Find the task being handed off (by assignedSessionName)
-        const tasks = await this.taskTrackingService.getTasksBySessionName(from);
-        const activeTask = tasks.find(t => t.status === 'assigned' || t.status === 'active' || t.status === 'working');
-        if (activeTask) {
-            // Update task assignment to new agent
-            const data = await this.taskTrackingService.loadTaskData();
-            const task = data.tasks.find(t => t.id === activeTask.id);
-            if (task) {
-                task.assignedSessionName = to;
-                task.status = 'assigned';
-                task.statusHistory = task.statusHistory || [];
-                task.statusHistory.push({
-                    timestamp: new Date().toISOString(),
-                    fromStatus: activeTask.status,
-                    toStatus: 'assigned',
-                    message: `Handed off from ${from} to ${to}: ${reason}`,
-                    reportedBy: from,
-                });
-                await this.taskTrackingService.saveTaskData(data);
-            }
-        }
-        logger.info('Task handoff recorded', { from, to, reason, taskId: activeTask?.id });
+        // Legacy TaskTrackingService removed — log handoff, return acknowledgement
+        logger.info('Task handoff recorded (legacy store removed)', { from, to, reason });
         res.json({
             success: true,
             handoff: {
                 from,
                 to,
                 reason,
-                taskId: activeTask?.id || null,
+                taskId: null,
                 taskPath: taskPath || null,
                 progress: progress || null,
                 timestamp: new Date().toISOString(),
@@ -1771,111 +1664,116 @@ export async function recordHandoff(req, res) {
         res.status(500).json({ success: false, error: 'Failed to record handoff' });
     }
 }
+export async function acceptTask(req, res) {
+    // Legacy — no-op, will be rebuilt on V3 WorkItem system
+    res.json({ success: true, message: 'Deprecated — use TaskPool API' });
+}
+export async function requestClarification(req, res) {
+    // Legacy — no-op, will be rebuilt on V3 WorkItem system
+    res.json({ success: true, message: 'Deprecated — use TaskPool API' });
+}
+export async function saveWorkingNotes(req, res) {
+    // Legacy — no-op, will be rebuilt on V3 WorkItem system
+    res.json({ success: true, message: 'Deprecated — use TaskPool API' });
+}
+// ---------------------------------------------------------------------------
+// Checklist Management — TL acceptance checklist alignment
+// ---------------------------------------------------------------------------
 /**
- * Accept a task — agent acknowledges the task with a structured understanding.
- * Transitions task from 'assigned' to 'accepted'.
+ * POST /task-management/:taskId/checklist
+ * Submit or update a checklist for a task. Called by the TL's design-checklist skill.
  *
- * @param req - Request containing taskId, sessionName, and understanding
- * @param res - Response with the updated task or error
+ * @param req.params.taskId - Task ID
+ * @param req.body - Checklist JSON (items, objective, etc.)
  */
-export async function acceptTask(req, res) {
+export async function submitChecklist(req, res) {
     try {
-        const { taskId, sessionName, understanding } = req.body;
-        if (!taskId) {
-            res.status(400).json({ success: false, error: 'taskId is required' });
+        const { taskId } = req.params;
+        const checklist = req.body;
+        if (!taskId || !checklist?.items || !Array.isArray(checklist.items)) {
+            res.status(400).json({ success: false, error: 'taskId and items[] are required' });
             return;
         }
-        if (!sessionName) {
-            res.status(400).json({ success: false, error: 'sessionName is required' });
-            return;
-        }
-        if (!understanding) {
-            res.status(400).json({ success: false, error: 'understanding is required — provide your interpretation of the task scope and deliverables' });
-            return;
-        }
-        const task = await this.taskTrackingService.acceptTask(taskId, sessionName, understanding);
-        logger.info('Task accepted', { taskId, sessionName, understanding: understanding.substring(0, 100) });
-        res.json({
+        // Store checklist in project's .crewly/tasks/ directory
+        const projectPath = checklist.projectPath || process.cwd();
+        const checklistDir = join(projectPath, '.crewly', 'tasks');
+        await mkdir(checklistDir, { recursive: true });
+        const checklistPath = join(checklistDir, `checklist-${taskId}.json`);
+        const checklistData = {
+            ...checklist,
+            taskId,
+            status: 'pending_approval',
+            submittedAt: new Date().toISOString(),
+        };
+        await writeFile(checklistPath, JSON.stringify(checklistData, null, 2));
+        logger.info('Checklist submitted for approval', { taskId, itemCount: checklist.items.length });
+        res.status(201).json({
             success: true,
-            message: `Task '${task.taskName}' accepted`,
-            task,
+            data: { taskId, checklistPath, status: 'pending_approval', itemCount: checklist.items.length },
         });
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        logger.error('Error accepting task', { error: msg });
-        res.status(400).json({ success: false, error: msg });
+        logger.error('Error submitting checklist', { error: msg });
+        res.status(500).json({ success: false, error: msg });
     }
 }
 /**
- * Request clarification on a task — agent signals that the task description is unclear.
- * Transitions task from 'assigned' or 'accepted' to 'needs_clarification'.
+ * POST /task-management/:taskId/checklist/approve
+ * Approve (or adjust) a pending checklist. Called by Orchestrator or user.
  *
- * @param req - Request containing taskId, sessionName, and question
- * @param res - Response with the updated task or error
+ * @param req.params.taskId - Task ID
+ * @param req.body.adjustments - Optional adjustments to checklist items
  */
-export async function requestClarification(req, res) {
+export async function approveChecklist(req, res) {
     try {
-        const { taskId, sessionName, question } = req.body;
-        if (!taskId) {
-            res.status(400).json({ success: false, error: 'taskId is required' });
-            return;
+        const { taskId } = req.params;
+        const { adjustments, projectPath: reqProjectPath } = req.body;
+        const projectPath = reqProjectPath || process.cwd();
+        const checklistPath = join(projectPath, '.crewly', 'tasks', `checklist-${taskId}.json`);
+        let checklist;
+        try {
+            const raw = await readFile(checklistPath, 'utf-8');
+            checklist = JSON.parse(raw);
         }
-        if (!sessionName) {
-            res.status(400).json({ success: false, error: 'sessionName is required' });
+        catch {
+            res.status(404).json({ success: false, error: `Checklist not found for task ${taskId}` });
             return;
         }
-        if (!question) {
-            res.status(400).json({ success: false, error: 'question is required — describe what you need clarified' });
-            return;
+        // Apply adjustments if provided
+        if (adjustments && Array.isArray(adjustments)) {
+            checklist.items = adjustments;
         }
-        const task = await this.taskTrackingService.requestClarification(taskId, sessionName, question);
-        logger.info('Task clarification requested', { taskId, sessionName, question: question.substring(0, 100) });
+        checklist.status = 'approved';
+        checklist.approvedAt = new Date().toISOString();
+        checklist.approvedBy = req.body.approvedBy || 'orchestrator';
+        await writeFile(checklistPath, JSON.stringify(checklist, null, 2));
+        logger.info('Checklist approved', { taskId, approvedBy: checklist.approvedBy });
         res.json({
             success: true,
-            message: `Clarification requested for task '${task.taskName}'`,
-            task,
+            data: { taskId, status: 'approved', itemCount: checklist.items.length },
         });
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        logger.error('Error requesting clarification', { error: msg });
-        res.status(400).json({ success: false, error: msg });
+        logger.error('Error approving checklist', { error: msg });
+        res.status(500).json({ success: false, error: msg });
     }
 }
 /**
- * Save working notes for a task — persists agent's current working state
- * across session restarts.
- *
- * @param req - Request containing taskId, sessionName, and notes
- * @param res - Response with success status
+ * GET /task-management/:taskId/checklist
+ * Get the current checklist for a task.
  */
-export async function saveWorkingNotes(req, res) {
+export async function getChecklist(req, res) {
     try {
-        const { taskId, sessionName, notes } = req.body;
-        if (!taskId) {
-            res.status(400).json({ success: false, error: 'taskId is required' });
-            return;
-        }
-        if (!sessionName) {
-            res.status(400).json({ success: false, error: 'sessionName is required' });
-            return;
-        }
-        if (notes === undefined || notes === null) {
-            res.status(400).json({ success: false, error: 'notes is required' });
-            return;
-        }
-        await this.taskTrackingService.updateWorkingNotes(taskId, sessionName, notes);
-        logger.info('Working notes saved', { taskId, sessionName, notesLength: notes.length });
-        res.json({
-            success: true,
-            message: 'Working notes saved',
-        });
+        const { taskId } = req.params;
+        const projectPath = req.query.projectPath || process.cwd();
+        const checklistPath = join(projectPath, '.crewly', 'tasks', `checklist-${taskId}.json`);
+        const raw = await readFile(checklistPath, 'utf-8');
+        res.json({ success: true, data: JSON.parse(raw) });
     }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        logger.error('Error saving working notes', { error: msg });
-        res.status(400).json({ success: false, error: msg });
+    catch {
+        res.status(404).json({ success: false, error: 'Checklist not found' });
     }
 }
 //# sourceMappingURL=task-management.controller.js.map