agent-tower 0.4.16-beta.0 → 0.4.16-beta.4

package/dist/services/__tests__/team-reconciler.service.test.js

@@ -134,7 +134,7 @@ function createRouteSchedulerMock() {
         where: { id: workRequestId },
         data: { status: 'REJECTED' },
     }).then(asWorkRequest));
-    scheduler.cancelWorkRequest = vi.fn(async (workRequestId) => prisma.workRequest.update({
+    scheduler.cancelWorkRequest = vi.fn(async (workRequestId, _options) => prisma.workRequest.update({
         where: { id: workRequestId },
         data: { status: 'CANCELLED' },
     }).then(asWorkRequest));
@@ -188,12 +188,30 @@ async function createFixture(options = {}) {
                 workspacePolicy: 'shared',
                 triggerPolicy: options.triggerPolicies?.[index] ?? 'MENTION_ONLY',
                 sessionPolicy: 'new_per_request',
+                queueManagementPolicy: 'own_only',
                 avatar: null,
             },
         }));
     }
     return { project, task, workspace, teamRun, members };
 }
+async function createMemberPreset(options = {}) {
+    const name = options.name ?? 'Leader';
+    return prisma.memberPreset.create({
+        data: {
+            name,
+            aliases: stringifyJson([name.toLowerCase()]),
+            providerId: `provider-${name.toLowerCase()}`,
+            rolePrompt: `${name} role`,
+            capabilities: stringifyJson(capabilities),
+            workspacePolicy: 'shared',
+            triggerPolicy: options.triggerPolicy ?? 'USER_MESSAGES',
+            sessionPolicy: 'new_per_request',
+            queueManagementPolicy: 'own_only',
+            avatar: null,
+        },
+    });
+}
 async function createWorkRequest(options) {
     return prisma.workRequest.create({
         data: {
@@ -279,6 +297,9 @@ describe('TeamReconcilerService', () => {
         await prisma.roomMessage.deleteMany();
         await prisma.teamMember.deleteMany();
         await prisma.teamRun.deleteMany();
+        await prisma.teamTemplateMember.deleteMany();
+        await prisma.teamTemplate.deleteMany();
+        await prisma.memberPreset.deleteMany();
         await prisma.session.deleteMany();
         await prisma.workspace.deleteMany();
         await prisma.task.deleteMany();
@@ -588,16 +609,30 @@ describe('TeamReconcilerService', () => {
                 senderId: members[0].id,
                 senderInvocationId: invocation.id,
             });
-            await expect(prisma.workRequest.findFirst({
-                where: {
-                    teamRunId: teamRun.id,
-                    triggerMessageId: message.id,
-                    targetMemberId: members[1].id,
-                },
-            })).resolves.toMatchObject({
-                requesterType: 'agent',
-                requesterMemberId: members[0].id,
-                status: 'QUEUED',
+            let createdRequestId = '';
+            await vi.waitFor(async () => {
+                const createdRequest = await prisma.workRequest.findFirst({
+                    where: {
+                        teamRunId: teamRun.id,
+                        triggerMessageId: message.id,
+                        targetMemberId: members[1].id,
+                    },
+                });
+                expect(createdRequest).toMatchObject({
+                    requesterType: 'agent',
+                    requesterMemberId: members[0].id,
+                    status: 'STARTED',
+                });
+                createdRequestId = createdRequest.id;
+            });
+            await vi.waitFor(async () => {
+                await expect(prisma.agentInvocation.findFirst({
+                    where: { workRequestId: createdRequestId },
+                })).resolves.toMatchObject({
+                    memberId: members[1].id,
+                    sessionId: null,
+                    status: 'FAILED',
+                });
             });
         }
         finally {
@@ -693,16 +728,30 @@ describe('TeamReconcilerService', () => {
                 senderId: members[0].id,
                 senderInvocationId: invocation.id,
             });
-            await expect(prisma.workRequest.findFirst({
-                where: {
-                    teamRunId: teamRun.id,
-                    triggerMessageId: message.id,
-                    targetMemberId: members[1].id,
-                },
-            })).resolves.toMatchObject({
-                requesterType: 'agent',
-                requesterMemberId: members[0].id,
-                status: 'QUEUED',
+            let createdRequestId = '';
+            await vi.waitFor(async () => {
+                const createdRequest = await prisma.workRequest.findFirst({
+                    where: {
+                        teamRunId: teamRun.id,
+                        triggerMessageId: message.id,
+                        targetMemberId: members[1].id,
+                    },
+                });
+                expect(createdRequest).toMatchObject({
+                    requesterType: 'agent',
+                    requesterMemberId: members[0].id,
+                    status: 'STARTED',
+                });
+                createdRequestId = createdRequest.id;
+            });
+            await vi.waitFor(async () => {
+                await expect(prisma.agentInvocation.findFirst({
+                    where: { workRequestId: createdRequestId },
+                })).resolves.toMatchObject({
+                    memberId: members[1].id,
+                    sessionId: null,
+                    status: 'FAILED',
+                });
             });
         }
         finally {
@@ -736,7 +785,19 @@ describe('TeamReconcilerService', () => {
     it('lists TeamRun members through MCP without exposing role prompts', async () => {
         const previousTeamRunId = process.env.AGENT_TOWER_TEAM_RUN_ID;
         const previousMemberId = process.env.AGENT_TOWER_MEMBER_ID;
-        const { teamRun, members } = await createFixture({ memberCount: 2 });
+        const { workspace, teamRun, members } = await createFixture({ memberCount: 2 });
+        const runningRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'STARTED',
+        });
+        await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: runningRequest.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            status: 'RUNNING',
+        });
         const app = Fastify({ logger: false });
         try {
             process.env.AGENT_TOWER_TEAM_RUN_ID = teamRun.id;
@@ -771,7 +832,7 @@ describe('TeamReconcilerService', () => {
                 id: members[0].id,
                 name: 'Member 1',
                 aliases: ['member-1'],
-                status: 'IDLE',
+                status: 'RUNNING',
                 workspacePolicy: 'shared',
                 triggerPolicy: 'MENTION_ONLY',
                 sessionPolicy: 'new_per_request',
@@ -860,6 +921,12 @@ describe('TeamReconcilerService', () => {
                             team_run_id: other.teamRun.id,
                         },
                     },
+                    {
+                        name: 'list_member_work_requests',
+                        arguments: {
+                            team_run_id: other.teamRun.id,
+                        },
+                    },
                     {
                         name: 'stop_member_work',
                         arguments: {
@@ -868,6 +935,13 @@ describe('TeamReconcilerService', () => {
                             cancel_queued: true,
                         },
                     },
+                    {
+                        name: 'cancel_work_request',
+                        arguments: {
+                            team_run_id: other.teamRun.id,
+                            work_request_id: request.id,
+                        },
+                    },
                 ];
                 for (const toolCall of cases) {
                     const result = await client.callTool(toolCall);
@@ -887,6 +961,113 @@ describe('TeamReconcilerService', () => {
             await app.close();
         }
     });
+    it('lists and cancels current member queued WorkRequests through MCP', async () => {
+        const previousEnv = captureTeamRunEnv();
+        const { teamRun, members } = await createFixture({ memberCount: 2 });
+        const triggerMessage = await prisma.roomMessage.create({
+            data: {
+                teamRunId: teamRun.id,
+                senderType: 'user',
+                senderId: null,
+                senderInvocationId: null,
+                kind: 'chat',
+                content: 'Please handle this queued request',
+                mentions: '[]',
+                workRequestIds: '[]',
+                artifactRefs: '[]',
+                attachmentIds: '[]',
+            },
+        });
+        const ownRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'QUEUED',
+            instruction: 'Own queued request',
+        });
+        await prisma.workRequest.update({
+            where: { id: ownRequest.id },
+            data: { triggerMessageId: triggerMessage.id },
+        });
+        const otherRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+            status: 'QUEUED',
+            instruction: 'Other queued request',
+        });
+        const app = Fastify({ logger: false });
+        try {
+            setTeamRunEnv({
+                AGENT_TOWER_TEAM_RUN_ID: teamRun.id,
+                AGENT_TOWER_MEMBER_ID: members[0].id,
+                AGENT_TOWER_INVOCATION_ID: undefined,
+                AGENT_TOWER_SESSION_ID: undefined,
+            });
+            await app.register(teamRunRoutes, { prefix: '/api' });
+            await app.listen({ port: 0, host: '127.0.0.1' });
+            const address = app.server.address();
+            if (!address || typeof address === 'string') {
+                throw new Error('Failed to start test server');
+            }
+            const server = await createMcpServer(`http://127.0.0.1:${address.port}`);
+            const client = new Client({ name: 'team-run-queue-test-client', version: '0.1.0' });
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+            await server.connect(serverTransport);
+            await client.connect(clientTransport);
+            try {
+                const listResult = await client.callTool({
+                    name: 'list_member_work_requests',
+                    arguments: {},
+                });
+                expect(listResult.isError, getMcpToolText(listResult)).not.toBe(true);
+                const queue = JSON.parse(getMcpToolText(listResult));
+                expect(queue).toMatchObject({
+                    currentMemberId: members[0].id,
+                    queueManagementPolicy: 'own_only',
+                    canManageTeamRunQueue: false,
+                });
+                expect(queue.workRequests).toHaveLength(1);
+                expect(queue.workRequests[0]).toMatchObject({
+                    id: ownRequest.id,
+                    targetMemberId: members[0].id,
+                    targetMember: {
+                        id: members[0].id,
+                        name: members[0].name,
+                        label: members[0].name,
+                    },
+                    triggerMessage: { contentPreview: 'Please handle this queued request' },
+                });
+                const cancelResult = await client.callTool({
+                    name: 'cancel_work_request',
+                    arguments: { work_request_id: ownRequest.id },
+                });
+                expect(cancelResult.isError, getMcpToolText(cancelResult)).not.toBe(true);
+                expect(JSON.parse(getMcpToolText(cancelResult))).toMatchObject({
+                    id: ownRequest.id,
+                    status: 'CANCELLED',
+                });
+                const forbiddenCancel = await client.callTool({
+                    name: 'cancel_work_request',
+                    arguments: { work_request_id: otherRequest.id },
+                });
+                expect(forbiddenCancel.isError).toBe(true);
+                expect(getMcpToolText(forbiddenCancel)).toContain('FORBIDDEN');
+            }
+            finally {
+                await client.close();
+                await server.close();
+            }
+            await expect(prisma.workRequest.findUnique({ where: { id: ownRequest.id } })).resolves.toMatchObject({
+                status: 'CANCELLED',
+            });
+            await expect(prisma.workRequest.findUnique({ where: { id: otherRequest.id } })).resolves.toMatchObject({
+                status: 'QUEUED',
+            });
+        }
+        finally {
+            restoreTeamRunEnv(previousEnv);
+            await app.close();
+        }
+    });
     it('posts MCP room messages as user when bound TeamRun identity is partial', async () => {
         const previousEnv = captureTeamRunEnv();
         const { teamRun, members } = await createFixture({ memberCount: 2 });
@@ -941,6 +1122,78 @@ describe('TeamReconcilerService', () => {
             await app.close();
         }
     });
+    it('enforces requester member scope for REST WorkRequest cancellation', async () => {
+        const { teamRun, members } = await createFixture({ memberCount: 3 });
+        await prisma.teamMember.update({
+            where: { id: members[2].id },
+            data: { queueManagementPolicy: 'team_pending' },
+        });
+        const ownQueued = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'QUEUED',
+            instruction: 'Own queued request',
+        });
+        const otherQueued = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+            status: 'QUEUED',
+            instruction: 'Other queued request',
+        });
+        const managerQueued = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+            status: 'QUEUED',
+            instruction: 'Manager cancellable request',
+        });
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api' });
+            const anonymousCancel = await app.inject({
+                method: 'POST',
+                url: `/api/team-runs/work-requests/${ownQueued.id}/cancel`,
+                payload: {},
+            });
+            expect(anonymousCancel.statusCode).toBe(400);
+            expect(anonymousCancel.json()).toMatchObject({ code: 'VALIDATION_ERROR' });
+            const ownCancel = await app.inject({
+                method: 'POST',
+                url: `/api/team-runs/work-requests/${ownQueued.id}/cancel`,
+                payload: {
+                    teamRunId: teamRun.id,
+                    requesterMemberId: members[0].id,
+                },
+            });
+            expect(ownCancel.statusCode).toBe(200);
+            expect(ownCancel.json()).toMatchObject({ id: ownQueued.id, status: 'CANCELLED' });
+            const forbiddenCancel = await app.inject({
+                method: 'POST',
+                url: `/api/team-runs/work-requests/${otherQueued.id}/cancel`,
+                payload: {
+                    teamRunId: teamRun.id,
+                    requesterMemberId: members[0].id,
+                },
+            });
+            expect(forbiddenCancel.statusCode).toBe(403);
+            expect(forbiddenCancel.json()).toMatchObject({ code: 'FORBIDDEN' });
+            const managerCancel = await app.inject({
+                method: 'POST',
+                url: `/api/team-runs/work-requests/${managerQueued.id}/cancel`,
+                payload: {
+                    teamRunId: teamRun.id,
+                    requesterMemberId: members[2].id,
+                },
+            });
+            expect(managerCancel.statusCode).toBe(200);
+            expect(managerCancel.json()).toMatchObject({ id: managerQueued.id, status: 'CANCELLED' });
+            await expect(prisma.workRequest.findUnique({ where: { id: otherQueued.id } })).resolves.toMatchObject({
+                status: 'QUEUED',
+            });
+        }
+        finally {
+            await app.close();
+        }
+    });
     it('auto-starts USER_MESSAGES work when a user posts an unmentioned room message', async () => {
         const { teamRun, members } = await createFixture({
             memberCount: 2,
@@ -948,6 +1201,11 @@ describe('TeamReconcilerService', () => {
             triggerPolicies: ['USER_MESSAGES', 'MENTION_ONLY'],
         });
         const routeScheduler = createRouteSchedulerMock();
+        const startedTeamRunIds = [];
+        routeScheduler.startNextSessions = vi.fn(async (teamRunId) => {
+            startedTeamRunIds.push(teamRunId);
+            return await new Promise(() => { });
+        });
         const app = Fastify({ logger: false });
         try {
             await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
@@ -963,22 +1221,456 @@ describe('TeamReconcilerService', () => {
             const message = response.json();
             expect(message.mentions).toEqual([]);
             expect(message.workRequestIds).toHaveLength(1);
-            expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
-            expect(routeScheduler.startedTeamRunIds).toEqual([teamRun.id]);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
             await expect(prisma.workRequest.findUnique({ where: { id: message.workRequestIds[0] } })).resolves.toMatchObject({
                 targetMemberId: members[0].id,
                 instruction: '普通用户消息',
-                status: 'STARTED',
+                status: 'QUEUED',
             });
             await expect(prisma.agentInvocation.count({
                 where: {
                     teamRunId: teamRun.id,
                     memberId: members[0].id,
-                    status: 'RUNNING',
                 },
-            })).resolves.toBe(1);
+            })).resolves.toBe(0);
+            await vi.waitFor(() => {
+                expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+                expect(startedTeamRunIds).toEqual([teamRun.id]);
+            });
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('creates an initial Team Room message without WorkRequests for unmentioned MENTION_ONLY members', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Initial message project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Build CSV import',
+                description: 'Parse uploaded files and show validation errors.',
+                projectId: project.id,
+            },
+        });
+        const implementerPreset = await createMemberPreset({ name: 'Implementer', triggerPolicy: 'MENTION_ONLY' });
+        const reviewerPreset = await createMemberPreset({ name: 'Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [implementerPreset.id, reviewerPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            const initialContent = 'Build CSV import\n\nParse uploaded files and show validation errors.';
+            expect(teamRun.messages).toHaveLength(1);
+            expect(teamRun.messages[0]).toMatchObject({
+                senderType: 'user',
+                kind: 'chat',
+                content: initialContent,
+                mentions: [],
+                workRequestIds: [],
+            });
+            expect(teamRun.workRequests).toEqual([]);
+            const messagesResponse = await app.inject({
+                method: 'GET',
+                url: `/api/team-runs/${teamRun.id}/messages`,
+            });
+            expect(messagesResponse.statusCode).toBe(200);
+            const messages = messagesResponse.json();
+            expect(messages).toEqual([
+                expect.objectContaining({
+                    id: teamRun.messages[0].id,
+                    content: initialContent,
+                    mentions: [],
+                    workRequestIds: [],
+                }),
+            ]);
+            const workRequestsResponse = await app.inject({
+                method: 'GET',
+                url: `/api/team-runs/${teamRun.id}/work-requests`,
+            });
+            expect(workRequestsResponse.statusCode).toBe(200);
+            const workRequests = workRequestsResponse.json();
+            expect(workRequests).toEqual([]);
+            await expect(prisma.roomMessage.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(1);
+            await expect(prisma.workRequest.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+            await expect(prisma.agentInvocation.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('creates USER_MESSAGES WorkRequests from a title-only initial message and auto-starts it', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Title-only project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Investigate slow dashboard',
+                projectId: project.id,
+            },
+        });
+        const preset = await createMemberPreset({ name: 'Leader', triggerPolicy: 'USER_MESSAGES' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [preset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            expect(teamRun.messages).toHaveLength(1);
+            expect(teamRun.messages[0]).toMatchObject({
+                content: 'Investigate slow dashboard',
+                workRequestIds: [teamRun.workRequests[0].id],
+            });
+            expect(teamRun.workRequests[0]).toMatchObject({
+                instruction: 'Investigate slow dashboard',
+                status: 'QUEUED',
+            });
+            await vi.waitFor(() => {
+                expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+            });
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('creates an initial WorkRequest only for a mentioned MENTION_ONLY member', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Mentioned initial message project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Investigate import failures',
+                description: 'Please @Reviewer check the error handling.',
+                projectId: project.id,
+            },
+        });
+        const implementerPreset = await createMemberPreset({ name: 'Implementer', triggerPolicy: 'MENTION_ONLY' });
+        const reviewerPreset = await createMemberPreset({ name: 'Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [implementerPreset.id, reviewerPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            const reviewer = teamRun.members.find((member) => member.name === 'Reviewer');
+            const implementer = teamRun.members.find((member) => member.name === 'Implementer');
+            const initialContent = 'Investigate import failures\n\nPlease @Reviewer check the error handling.';
+            expect(reviewer).toBeDefined();
+            expect(implementer).toBeDefined();
+            expect(teamRun.messages).toHaveLength(1);
+            expect(teamRun.messages[0]).toMatchObject({
+                content: initialContent,
+                mentions: [{ memberId: reviewer.id, label: 'Reviewer' }],
+            });
+            expect(teamRun.workRequests).toEqual([
+                expect.objectContaining({
+                    id: teamRun.messages[0].workRequestIds[0],
+                    targetMemberId: reviewer.id,
+                    instruction: initialContent,
+                    status: 'QUEUED',
+                }),
+            ]);
+            expect(teamRun.workRequests[0].targetMemberId).not.toBe(implementer.id);
+            await vi.waitFor(() => {
+                expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+            });
+            await expect(prisma.agentInvocation.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(1);
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('matches initial @mention tokens exactly instead of matching name prefixes', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Mention prefix project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Route QA review',
+                description: 'Please @QA-Lead verify the release notes.',
+                projectId: project.id,
+            },
+        });
+        const qaPreset = await createMemberPreset({ name: 'QA', triggerPolicy: 'MENTION_ONLY' });
+        const qaLeadPreset = await createMemberPreset({ name: 'QA-Lead', triggerPolicy: 'MENTION_ONLY' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [qaPreset.id, qaLeadPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            const qa = teamRun.members.find((member) => member.name === 'QA');
+            const qaLead = teamRun.members.find((member) => member.name === 'QA-Lead');
+            expect(qa).toBeDefined();
+            expect(qaLead).toBeDefined();
+            expect(teamRun.messages[0].mentions).toEqual([{ memberId: qaLead.id, label: 'QA-Lead' }]);
+            expect(teamRun.workRequests).toEqual([
+                expect.objectContaining({
+                    id: teamRun.messages[0].workRequestIds[0],
+                    targetMemberId: qaLead.id,
+                }),
+            ]);
+            expect(teamRun.workRequests[0].targetMemberId).not.toBe(qa.id);
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('does not create initial WorkRequests for ambiguous @mention aliases', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Ambiguous mention project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Review ambiguous owner',
+                description: 'Please @reviewer check this.',
+                projectId: project.id,
+            },
+        });
+        const firstPreset = await createMemberPreset({ name: 'Frontend Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const secondPreset = await createMemberPreset({ name: 'Backend Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        await prisma.memberPreset.updateMany({
+            where: { id: { in: [firstPreset.id, secondPreset.id] } },
+            data: { aliases: stringifyJson(['reviewer']) },
+        });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [firstPreset.id, secondPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            expect(teamRun.messages[0]).toMatchObject({
+                mentions: [],
+                workRequestIds: [],
+            });
+            expect(teamRun.workRequests).toEqual([]);
+            await expect(prisma.workRequest.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('does not fall back to USER_MESSAGES when initial @mention aliases are ambiguous', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Mixed ambiguous mention project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Route ambiguous review',
+                description: 'Please @reviewer decide who owns this.',
+                projectId: project.id,
+            },
+        });
+        const firstPreset = await createMemberPreset({ name: 'Frontend Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const secondPreset = await createMemberPreset({ name: 'Backend Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const observerPreset = await createMemberPreset({ name: 'Observer', triggerPolicy: 'USER_MESSAGES' });
+        await prisma.memberPreset.updateMany({
+            where: { id: { in: [firstPreset.id, secondPreset.id] } },
+            data: { aliases: stringifyJson(['reviewer']) },
+        });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [firstPreset.id, secondPreset.id, observerPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            expect(teamRun.messages[0]).toMatchObject({
+                mentions: [],
+                workRequestIds: [],
+            });
+            expect(teamRun.workRequests).toEqual([]);
+            await expect(prisma.workRequest.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('rejects creating a TeamRun for a blank-title task before writing TeamRun data', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Blank title project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: '   ',
+                projectId: project.id,
+            },
+        });
+        const preset = await createMemberPreset({ name: 'Leader', triggerPolicy: 'USER_MESSAGES' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [preset.id],
+                },
+            });
+            expect(response.statusCode).toBe(400);
+            expect(response.json()).toMatchObject({ code: 'VALIDATION_ERROR' });
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+            await expect(prisma.teamRun.count({ where: { taskId: task.id } })).resolves.toBe(0);
+            await expect(prisma.roomMessage.count()).resolves.toBe(0);
+            await expect(prisma.workRequest.count()).resolves.toBe(0);
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('rolls back TeamRun creation when initial WorkRequest creation fails and allows retry', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Atomic TeamRun project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Start atomically',
+                projectId: project.id,
+            },
+        });
+        const preset = await createMemberPreset({ name: 'Implementer', triggerPolicy: 'USER_MESSAGES' });
+        const routeScheduler = createRouteSchedulerMock();
+        const originalTransaction = prisma.$transaction.bind(prisma);
+        const transactionSpy = vi.spyOn(prisma, '$transaction');
+        transactionSpy.mockImplementationOnce(async (arg, ...rest) => {
+            if (typeof arg !== 'function') {
+                return originalTransaction(arg, ...rest);
+            }
+            return originalTransaction(async (tx) => {
+                const failingTx = new Proxy(tx, {
+                    get(target, property, receiver) {
+                        if (property !== 'workRequest') {
+                            return Reflect.get(target, property, receiver);
+                        }
+                        const delegate = Reflect.get(target, property, receiver);
+                        return new Proxy(delegate, {
+                            get(delegateTarget, delegateProperty, delegateReceiver) {
+                                if (delegateProperty === 'create') {
+                                    return async () => {
+                                        throw new Error('injected initial WorkRequest failure');
+                                    };
+                                }
+                                return Reflect.get(delegateTarget, delegateProperty, delegateReceiver);
+                            },
+                        });
+                    },
+                });
+                return arg(failingTx);
+            }, ...rest);
+        });
+        const app = Fastify({ logger: false });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const failedResponse = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [preset.id],
+                },
+            });
+            expect(failedResponse.statusCode).toBe(500);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+            await expect(prisma.teamRun.count({ where: { taskId: task.id } })).resolves.toBe(0);
+            await expect(prisma.teamMember.count()).resolves.toBe(0);
+            await expect(prisma.roomMessage.count()).resolves.toBe(0);
+            await expect(prisma.workRequest.count()).resolves.toBe(0);
+            const retryResponse = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [preset.id],
+                },
+            });
+            expect(retryResponse.statusCode).toBe(201);
+            const teamRun = retryResponse.json();
+            expect(teamRun.messages[0].workRequestIds).toEqual([teamRun.workRequests[0].id]);
+            expect(teamRun.workRequests[0]).toMatchObject({ status: 'QUEUED' });
+            await vi.waitFor(() => {
+                expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+            });
         }
         finally {
+            consoleErrorSpy.mockRestore();
             await app.close();
         }
     });