agent-tower 0.4.15 → 0.4.16-beta.3

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

@@ -0,0 +1,1536 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Fastify from 'fastify';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { TaskStatus } from '../../types/index.js';
+import { EventBus } from '../../core/event-bus.js';
+import { TeamLockService } from '../team-lock.service.js';
+const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-tower-team-reconciler-'));
+const dbPath = path.join(testDir, 'test.db');
+process.env.AGENT_TOWER_DATABASE_URL = `file:${dbPath}`;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const serverRoot = path.resolve(__dirname, '../../..');
+const schemaPath = path.join(serverRoot, 'prisma/schema.prisma');
+let prisma;
+let TeamReconcilerService;
+let SessionManager;
+let TEAM_ROOM_REPLY_REMINDER;
+let createMcpServer;
+let teamRunRoutes;
+let workRequestSequence = 0;
+const TEAM_RUN_MISMATCH_ERROR = 'team_run_id does not match the current TeamRun session.';
+const TEAM_RUN_ENV_KEYS = [
+    'AGENT_TOWER_TEAM_RUN_ID',
+    'AGENT_TOWER_MEMBER_ID',
+    'AGENT_TOWER_INVOCATION_ID',
+    'AGENT_TOWER_SESSION_ID',
+];
+const capabilities = {
+    readRoom: true,
+    postRoomMessage: true,
+    mentionMembers: true,
+    stopMemberWork: false,
+    markReadyForReview: false,
+    readFiles: true,
+    writeFiles: true,
+    runCommands: false,
+    readDiff: true,
+    mergeWorkspace: false,
+};
+function stringifyJson(value) {
+    return JSON.stringify(value);
+}
+function captureTeamRunEnv() {
+    return TEAM_RUN_ENV_KEYS.reduce((snapshot, key) => ({
+        ...snapshot,
+        [key]: process.env[key],
+    }), {});
+}
+function setTeamRunEnv(values) {
+    for (const key of TEAM_RUN_ENV_KEYS) {
+        if (!(key in values)) {
+            continue;
+        }
+        const value = values[key];
+        if (value === undefined) {
+            delete process.env[key];
+        }
+        else {
+            process.env[key] = value;
+        }
+    }
+}
+function restoreTeamRunEnv(snapshot) {
+    setTeamRunEnv(snapshot);
+}
+function getMcpToolText(result) {
+    const content = result.content;
+    return content?.[0]?.type === 'text' ? content[0].text ?? '' : '';
+}
+function createSchedulerMock(lockService) {
+    return {
+        releaseInvocationLocks: vi.fn((invocationId) => {
+            lockService.releaseByOwner(invocationId);
+        }),
+        startNextSessions: vi.fn(async () => []),
+    };
+}
+function createMessengerMock() {
+    return {
+        sendMessage: vi.fn(async () => null),
+    };
+}
+function asWorkRequest(value) {
+    return value;
+}
+function asAgentInvocations(value) {
+    return value;
+}
+function createRouteSchedulerMock() {
+    const startedTeamRunIds = [];
+    const scheduler = {
+        startedTeamRunIds,
+    };
+    scheduler.startNextSessions = vi.fn(async (teamRunId) => {
+        startedTeamRunIds.push(teamRunId);
+        const workRequests = await prisma.workRequest.findMany({
+            where: { teamRunId, status: 'QUEUED' },
+            orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
+        });
+        const invocations = [];
+        for (const workRequest of workRequests) {
+            await prisma.workRequest.update({
+                where: { id: workRequest.id },
+                data: { status: 'STARTED' },
+            });
+            invocations.push(await prisma.agentInvocation.create({
+                data: {
+                    teamRunId,
+                    workRequestId: workRequest.id,
+                    memberId: workRequest.targetMemberId,
+                    workspaceId: null,
+                    sessionId: null,
+                    status: 'RUNNING',
+                },
+            }));
+        }
+        return asAgentInvocations(invocations);
+    });
+    scheduler.approveWorkRequestAndStartNext = vi.fn(async (workRequestId) => {
+        const workRequest = await prisma.workRequest.update({
+            where: { id: workRequestId },
+            data: { status: 'QUEUED' },
+        });
+        const startedInvocations = await scheduler.startNextSessions(workRequest.teamRunId);
+        return { workRequest: asWorkRequest(workRequest), startedInvocations };
+    });
+    scheduler.rejectWorkRequest = vi.fn(async (workRequestId) => prisma.workRequest.update({
+        where: { id: workRequestId },
+        data: { status: 'REJECTED' },
+    }).then(asWorkRequest));
+    scheduler.cancelWorkRequest = vi.fn(async (workRequestId) => prisma.workRequest.update({
+        where: { id: workRequestId },
+        data: { status: 'CANCELLED' },
+    }).then(asWorkRequest));
+    scheduler.stopMemberWork = vi.fn(async () => ({
+        stoppedSessionIds: [],
+        cancelledInvocationIds: [],
+        cancelledWorkRequestIds: [],
+        startedInvocations: [],
+    }));
+    return scheduler;
+}
+async function createFixture(options = {}) {
+    const project = await prisma.project.create({
+        data: {
+            name: 'Team reconciler project',
+            repoPath: testDir,
+        },
+    });
+    const task = await prisma.task.create({
+        data: {
+            title: 'Team reconciler task',
+            status: options.taskStatus ?? TaskStatus.IN_PROGRESS,
+            projectId: project.id,
+        },
+    });
+    const workspace = await prisma.workspace.create({
+        data: {
+            taskId: task.id,
+            branchName: 'team-shared',
+            worktreePath: testDir,
+            status: 'ACTIVE',
+        },
+    });
+    const teamRun = await prisma.teamRun.create({
+        data: {
+            taskId: task.id,
+            mode: options.teamRunMode ?? 'AUTO',
+        },
+    });
+    const members = [];
+    for (let index = 0; index < (options.memberCount ?? 1); index += 1) {
+        members.push(await prisma.teamMember.create({
+            data: {
+                teamRunId: teamRun.id,
+                presetId: null,
+                name: `Member ${index + 1}`,
+                aliases: stringifyJson([`member-${index + 1}`]),
+                providerId: `provider-${index + 1}`,
+                rolePrompt: `Role ${index + 1}`,
+                capabilities: stringifyJson(capabilities),
+                workspacePolicy: 'shared',
+                triggerPolicy: options.triggerPolicies?.[index] ?? 'MENTION_ONLY',
+                sessionPolicy: 'new_per_request',
+                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',
+            avatar: null,
+        },
+    });
+}
+async function createWorkRequest(options) {
+    return prisma.workRequest.create({
+        data: {
+            teamRunId: options.teamRunId,
+            requesterMemberId: null,
+            requesterType: 'user',
+            targetMemberId: options.targetMemberId,
+            triggerMessageId: `message-${Math.random().toString(16).slice(2)}`,
+            instruction: options.instruction ?? 'Please do the work',
+            ifBusy: 'queue',
+            cancelQueued: false,
+            status: options.status ?? 'STARTED',
+            createdAt: new Date(Date.UTC(2026, 0, 1, 0, 0, workRequestSequence++)),
+        },
+    });
+}
+async function createRunningInvocation(options) {
+    const session = options.sessionId
+        ? await prisma.session.findUniqueOrThrow({ where: { id: options.sessionId } })
+        : await prisma.session.create({
+            data: {
+                workspaceId: options.workspaceId,
+                agentType: 'CODEX',
+                providerId: 'provider-1',
+                prompt: 'Do the work',
+                status: 'COMPLETED',
+            },
+        });
+    return prisma.agentInvocation.create({
+        data: {
+            teamRunId: options.teamRunId,
+            workRequestId: options.workRequestId,
+            memberId: options.memberId,
+            workspaceId: options.workspaceId ?? session.workspaceId,
+            sessionId: session.id,
+            status: options.status ?? 'RUNNING',
+            roomReplyReminderCount: options.roomReplyReminderCount ?? 0,
+        },
+    });
+}
+describe('TeamReconcilerService', () => {
+    let lockService;
+    let scheduler;
+    let messenger;
+    let eventBus;
+    let service;
+    beforeAll(async () => {
+        execFileSync('pnpm', ['exec', 'prisma', 'db', 'push', '--skip-generate', `--schema=${schemaPath}`], {
+            cwd: serverRoot,
+            env: { ...process.env, AGENT_TOWER_DATABASE_URL: `file:${dbPath}` },
+            stdio: 'pipe',
+        });
+        const utilsModule = await import('../../utils/index.js');
+        const reconcilerModule = await import('../team-reconciler.service.js');
+        const sessionManagerModule = await import('../session-manager.js');
+        const mcpServerModule = await import('../../mcp/server.js');
+        const teamRunRoutesModule = await import('../../routes/team-runs.js');
+        prisma = utilsModule.prisma;
+        TeamReconcilerService = reconcilerModule.TeamReconcilerService;
+        SessionManager = sessionManagerModule.SessionManager;
+        TEAM_ROOM_REPLY_REMINDER = reconcilerModule.TEAM_ROOM_REPLY_REMINDER;
+        createMcpServer = mcpServerModule.createMcpServer;
+        teamRunRoutes = teamRunRoutesModule.teamRunRoutes;
+    });
+    beforeEach(async () => {
+        vi.restoreAllMocks();
+        workRequestSequence = 0;
+        lockService = new TeamLockService();
+        scheduler = createSchedulerMock(lockService);
+        messenger = createMessengerMock();
+        eventBus = new EventBus();
+        service = new TeamReconcilerService({
+            scheduler,
+            sessionMessenger: messenger,
+            eventBus,
+            now: () => new Date(Date.UTC(2026, 0, 1, 0, 0, 0)),
+            reminderDelaysMs: [1_000, 2_000, 4_000],
+            maxRoomReplyReminders: 3,
+            scheduleReminders: false,
+        });
+        await prisma.agentInvocation.deleteMany();
+        await prisma.workRequest.deleteMany();
+        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();
+        await prisma.project.deleteMany();
+    });
+    afterAll(async () => {
+        vi.restoreAllMocks();
+        await prisma.$disconnect();
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    it('marks invocation completed and releases locks when a RoomMessage exists for the invocation', async () => {
+        const { workspace, teamRun, members } = await createFixture();
+        const request = await createWorkRequest({ teamRunId: teamRun.id, targetMemberId: members[0].id });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+        });
+        expect(lockService.acquire(invocation.id, ['workspace:task:write'])).toBe(true);
+        await prisma.roomMessage.create({
+            data: {
+                teamRunId: teamRun.id,
+                senderType: 'agent',
+                senderId: members[0].id,
+                senderInvocationId: invocation.id,
+                kind: 'chat',
+                content: 'Implemented the change',
+                mentions: '[]',
+                workRequestIds: '[]',
+                artifactRefs: '[]',
+                attachmentIds: '[]',
+            },
+        });
+        await service.handleSessionExit(invocation.sessionId);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'COMPLETED',
+            nextRoomReplyReminderAt: null,
+        });
+        expect(scheduler.releaseInvocationLocks).toHaveBeenCalledWith(invocation.id);
+        expect(lockService.listLocks()).toEqual([]);
+        expect(scheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+    });
+    it('marks invocation waiting, increments reminder count, and sends a reminder when no RoomMessage exists', async () => {
+        const { workspace, teamRun, members } = await createFixture();
+        const request = await createWorkRequest({ teamRunId: teamRun.id, targetMemberId: members[0].id });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+        });
+        await service.handleSessionExit(invocation.sessionId);
+        const reloaded = await prisma.agentInvocation.findUniqueOrThrow({ where: { id: invocation.id } });
+        expect(reloaded.status).toBe('WAITING_ROOM_REPLY');
+        expect(reloaded.roomReplyReminderCount).toBe(1);
+        expect(reloaded.nextRoomReplyReminderAt?.toISOString()).toBe('2026-01-01T00:00:01.000Z');
+        expect(messenger.sendMessage).toHaveBeenCalledWith(invocation.sessionId, TEAM_ROOM_REPLY_REMINDER);
+        expect(scheduler.releaseInvocationLocks).not.toHaveBeenCalled();
+    });
+    it('does not send another reminder before the backoff time is due', async () => {
+        const { workspace, teamRun, members } = await createFixture();
+        const request = await createWorkRequest({ teamRunId: teamRun.id, targetMemberId: members[0].id });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            status: 'WAITING_ROOM_REPLY',
+            roomReplyReminderCount: 1,
+        });
+        await prisma.agentInvocation.update({
+            where: { id: invocation.id },
+            data: { nextRoomReplyReminderAt: new Date(Date.UTC(2026, 0, 1, 0, 1, 0)) },
+        });
+        await service.reconcileInvocation(invocation.id);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'WAITING_ROOM_REPLY',
+            roomReplyReminderCount: 1,
+        });
+        expect(messenger.sendMessage).not.toHaveBeenCalled();
+    });
+    it('marks invocation failed and releases locks when max due reminders are reached without a RoomMessage', async () => {
+        const { workspace, teamRun, members } = await createFixture();
+        const request = await createWorkRequest({ teamRunId: teamRun.id, targetMemberId: members[0].id });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            status: 'WAITING_ROOM_REPLY',
+            roomReplyReminderCount: 2,
+        });
+        await prisma.agentInvocation.update({
+            where: { id: invocation.id },
+            data: { nextRoomReplyReminderAt: new Date(Date.UTC(2025, 11, 31, 23, 59, 59)) },
+        });
+        expect(lockService.acquire(invocation.id, ['workspace:task:write'])).toBe(true);
+        await expect(service.reconcileDueRoomReplyReminders()).resolves.toBe(1);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'WAITING_ROOM_REPLY',
+            roomReplyReminderCount: 3,
+        });
+        expect(messenger.sendMessage).toHaveBeenCalledTimes(1);
+        expect(scheduler.releaseInvocationLocks).not.toHaveBeenCalled();
+        await prisma.agentInvocation.update({
+            where: { id: invocation.id },
+            data: { nextRoomReplyReminderAt: new Date(Date.UTC(2025, 11, 31, 23, 59, 59)) },
+        });
+        await expect(service.reconcileDueRoomReplyReminders()).resolves.toBe(1);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'FAILED',
+            nextRoomReplyReminderAt: null,
+        });
+        expect(scheduler.releaseInvocationLocks).toHaveBeenCalledWith(invocation.id);
+        expect(lockService.listLocks()).toEqual([]);
+    });
+    it('moves an idle TeamRun task from IN_PROGRESS to IN_REVIEW and writes reviewReason', async () => {
+        const { workspace, task, teamRun, members } = await createFixture({ taskStatus: TaskStatus.IN_PROGRESS });
+        const request = await createWorkRequest({ teamRunId: teamRun.id, targetMemberId: members[0].id });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+        });
+        await prisma.roomMessage.create({
+            data: {
+                teamRunId: teamRun.id,
+                senderType: 'agent',
+                senderId: members[0].id,
+                senderInvocationId: invocation.id,
+                kind: 'chat',
+                content: 'Done',
+                mentions: '[]',
+                workRequestIds: '[]',
+                artifactRefs: '[]',
+                attachmentIds: '[]',
+            },
+        });
+        const taskUpdates = [];
+        eventBus.on('task:updated', (payload) => taskUpdates.push(payload));
+        await service.handleSessionExit(invocation.sessionId);
+        await expect(prisma.task.findUnique({ where: { id: task.id } })).resolves.toMatchObject({
+            status: TaskStatus.IN_REVIEW,
+        });
+        await expect(prisma.teamRun.findUnique({ where: { id: teamRun.id } })).resolves.toMatchObject({
+            reviewReason: 'TEAM_QUIESCENT',
+        });
+        expect(taskUpdates).toEqual([
+            { taskId: task.id, projectId: expect.any(String), status: TaskStatus.IN_REVIEW },
+        ]);
+    });
+    it('cancels invocation, releases locks, starts queued work, and advances idle TeamRun on session stop', async () => {
+        const { workspace, task, teamRun, members } = await createFixture({ taskStatus: TaskStatus.IN_PROGRESS });
+        const request = await createWorkRequest({ teamRunId: teamRun.id, targetMemberId: members[0].id });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            status: 'RUNNING',
+        });
+        await prisma.agentInvocation.update({
+            where: { id: invocation.id },
+            data: { nextRoomReplyReminderAt: new Date(Date.UTC(2026, 0, 1, 0, 1, 0)) },
+        });
+        expect(lockService.acquire(invocation.id, ['workspace:task:write'])).toBe(true);
+        await expect(service.handleSessionStopped(invocation.sessionId)).resolves.toBe(true);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'CANCELLED',
+            nextRoomReplyReminderAt: null,
+        });
+        expect(scheduler.releaseInvocationLocks).toHaveBeenCalledWith(invocation.id);
+        expect(lockService.listLocks()).toEqual([]);
+        expect(scheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+        await expect(prisma.task.findUnique({ where: { id: task.id } })).resolves.toMatchObject({
+            status: TaskStatus.IN_REVIEW,
+        });
+        await expect(prisma.teamRun.findUnique({ where: { id: teamRun.id } })).resolves.toMatchObject({
+            reviewReason: 'TEAM_QUIESCENT',
+        });
+    });
+    it('keeps stopped TeamRun out of review when queued work remains', async () => {
+        const { workspace, task, teamRun, members } = await createFixture({
+            taskStatus: TaskStatus.IN_PROGRESS,
+            memberCount: 2,
+        });
+        const request = await createWorkRequest({ teamRunId: teamRun.id, targetMemberId: members[0].id });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            status: 'RUNNING',
+        });
+        await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+            status: 'QUEUED',
+        });
+        await service.handleSessionStopped(invocation.sessionId);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'CANCELLED',
+        });
+        await expect(prisma.task.findUnique({ where: { id: task.id } })).resolves.toMatchObject({
+            status: TaskStatus.IN_PROGRESS,
+        });
+        expect(scheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+    });
+    it.each([
+        ['queued work request', async (teamRunId, memberId) => {
+                await createWorkRequest({ teamRunId, targetMemberId: memberId, status: 'QUEUED' });
+            }],
+        ['pending approval work request', async (teamRunId, memberId) => {
+                await createWorkRequest({ teamRunId, targetMemberId: memberId, status: 'PENDING_APPROVAL' });
+            }],
+        ['running invocation', async (teamRunId, memberId, workspaceId) => {
+                const request = await createWorkRequest({ teamRunId, targetMemberId: memberId });
+                await createRunningInvocation({ teamRunId, workRequestId: request.id, memberId, workspaceId, status: 'RUNNING' });
+            }],
+        ['waiting invocation', async (teamRunId, memberId, workspaceId) => {
+                const request = await createWorkRequest({ teamRunId, targetMemberId: memberId });
+                await createRunningInvocation({
+                    teamRunId,
+                    workRequestId: request.id,
+                    memberId,
+                    workspaceId,
+                    status: 'WAITING_ROOM_REPLY',
+                });
+            }],
+    ])('does not move the task to review while the TeamRun still has %s', async (_caseName, arrange) => {
+        const { workspace, task, teamRun, members } = await createFixture({
+            taskStatus: TaskStatus.IN_PROGRESS,
+            memberCount: 2,
+        });
+        const completedRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'STARTED',
+        });
+        await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: completedRequest.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            status: 'COMPLETED',
+        });
+        await arrange(teamRun.id, members[1].id, workspace.id);
+        const advanced = await service.maybeAdvanceTeamRunToReview(teamRun.id);
+        expect(advanced).toBe(false);
+        await expect(prisma.task.findUnique({ where: { id: task.id } })).resolves.toMatchObject({
+            status: TaskStatus.IN_PROGRESS,
+        });
+    });
+    it('posts a room message from MCP env identity and creates WorkRequests through mentions', async () => {
+        const previousTeamRunId = process.env.AGENT_TOWER_TEAM_RUN_ID;
+        const previousMemberId = process.env.AGENT_TOWER_MEMBER_ID;
+        const previousInvocationId = process.env.AGENT_TOWER_INVOCATION_ID;
+        const { workspace, teamRun, members } = await createFixture({ memberCount: 2 });
+        const request = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'STARTED',
+        });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+        });
+        const app = Fastify({ logger: false });
+        try {
+            process.env.AGENT_TOWER_TEAM_RUN_ID = teamRun.id;
+            process.env.AGENT_TOWER_MEMBER_ID = members[0].id;
+            process.env.AGENT_TOWER_INVOCATION_ID = invocation.id;
+            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-room-test-client', version: '0.1.0' });
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+            await server.connect(serverTransport);
+            await client.connect(clientTransport);
+            const result = await client.callTool({
+                name: 'post_room_message',
+                arguments: {
+                    content: 'Implemented the parser and please review it',
+                    mentions: [{ memberId: members[1].id }],
+                },
+            });
+            await client.close();
+            await server.close();
+            expect(result.isError).not.toBe(true);
+            const resultContent = result.content;
+            const messageText = resultContent[0]?.type === 'text' ? resultContent[0].text ?? '' : '';
+            const message = JSON.parse(messageText);
+            expect(message).toMatchObject({
+                senderType: 'agent',
+                senderInvocationId: invocation.id,
+            });
+            await expect(prisma.roomMessage.findUnique({ where: { id: message.id } })).resolves.toMatchObject({
+                senderType: 'agent',
+                senderId: members[0].id,
+                senderInvocationId: invocation.id,
+            });
+            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 {
+            if (previousTeamRunId === undefined) {
+                delete process.env.AGENT_TOWER_TEAM_RUN_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_TEAM_RUN_ID = previousTeamRunId;
+            }
+            if (previousMemberId === undefined) {
+                delete process.env.AGENT_TOWER_MEMBER_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_MEMBER_ID = previousMemberId;
+            }
+            if (previousInvocationId === undefined) {
+                delete process.env.AGENT_TOWER_INVOCATION_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_INVOCATION_ID = previousInvocationId;
+            }
+            await app.close();
+        }
+    });
+    it('posts a room message from MCP workspace context identity when MCP env identity is missing', async () => {
+        const previousTeamRunId = process.env.AGENT_TOWER_TEAM_RUN_ID;
+        const previousMemberId = process.env.AGENT_TOWER_MEMBER_ID;
+        const previousInvocationId = process.env.AGENT_TOWER_INVOCATION_ID;
+        const previousSessionId = process.env.AGENT_TOWER_SESSION_ID;
+        const { workspace, teamRun, members } = await createFixture({ memberCount: 2 });
+        const request = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'STARTED',
+        });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            status: 'RUNNING',
+        });
+        const contextWorktreePath = fs.realpathSync(workspace.worktreePath);
+        await prisma.workspace.update({
+            where: { id: workspace.id },
+            data: { worktreePath: contextWorktreePath },
+        });
+        const app = Fastify({ logger: false });
+        try {
+            delete process.env.AGENT_TOWER_TEAM_RUN_ID;
+            delete process.env.AGENT_TOWER_MEMBER_ID;
+            delete process.env.AGENT_TOWER_INVOCATION_ID;
+            delete process.env.AGENT_TOWER_SESSION_ID;
+            await app.register((await import('../../routes/system.js')).systemRoutes, { prefix: '/api' });
+            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 previousCwd = process.cwd();
+            let server;
+            try {
+                process.chdir(contextWorktreePath);
+                server = await createMcpServer(`http://127.0.0.1:${address.port}`);
+            }
+            finally {
+                process.chdir(previousCwd);
+            }
+            const client = new Client({ name: 'team-room-context-test-client', version: '0.1.0' });
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+            await server.connect(serverTransport);
+            await client.connect(clientTransport);
+            const result = await client.callTool({
+                name: 'post_room_message',
+                arguments: {
+                    content: 'Implemented through context identity',
+                    mentions: [{ memberId: members[1].id }],
+                },
+            });
+            await client.close();
+            await server.close();
+            expect(result.isError, JSON.stringify(result.content)).not.toBe(true);
+            const resultContent = result.content;
+            const messageText = resultContent[0]?.type === 'text' ? resultContent[0].text ?? '' : '';
+            const message = JSON.parse(messageText);
+            expect(message).toMatchObject({
+                senderType: 'agent',
+                senderInvocationId: invocation.id,
+            });
+            await expect(prisma.roomMessage.findUnique({ where: { id: message.id } })).resolves.toMatchObject({
+                senderType: 'agent',
+                senderId: members[0].id,
+                senderInvocationId: invocation.id,
+            });
+            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 {
+            if (previousTeamRunId === undefined) {
+                delete process.env.AGENT_TOWER_TEAM_RUN_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_TEAM_RUN_ID = previousTeamRunId;
+            }
+            if (previousMemberId === undefined) {
+                delete process.env.AGENT_TOWER_MEMBER_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_MEMBER_ID = previousMemberId;
+            }
+            if (previousInvocationId === undefined) {
+                delete process.env.AGENT_TOWER_INVOCATION_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_INVOCATION_ID = previousInvocationId;
+            }
+            if (previousSessionId === undefined) {
+                delete process.env.AGENT_TOWER_SESSION_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_SESSION_ID = previousSessionId;
+            }
+            await app.close();
+        }
+    });
+    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 { 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;
+            process.env.AGENT_TOWER_MEMBER_ID = members[0].id;
+            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-member-test-client', version: '0.1.0' });
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+            await server.connect(serverTransport);
+            await client.connect(clientTransport);
+            const result = await client.callTool({
+                name: 'list_team_members',
+                arguments: {},
+            });
+            await client.close();
+            await server.close();
+            expect(result.isError).not.toBe(true);
+            const resultContent = result.content;
+            const text = resultContent[0]?.type === 'text' ? resultContent[0].text ?? '' : '';
+            const payload = JSON.parse(text);
+            expect(payload).toMatchObject({
+                teamRunId: teamRun.id,
+                currentMemberId: members[0].id,
+            });
+            expect(payload.members).toHaveLength(2);
+            expect(payload.members[0]).toMatchObject({
+                id: members[0].id,
+                name: 'Member 1',
+                aliases: ['member-1'],
+                status: 'RUNNING',
+                workspacePolicy: 'shared',
+                triggerPolicy: 'MENTION_ONLY',
+                sessionPolicy: 'new_per_request',
+                providerId: 'provider-1',
+            });
+            expect(payload.members[0]?.capabilities).toMatchObject({
+                writeFiles: true,
+                runCommands: false,
+                mentionMembers: true,
+            });
+            expect(payload.members[0]).not.toHaveProperty('rolePrompt');
+            expect(payload.members[0]).not.toHaveProperty('avatar');
+            expect(payload.members[0]).not.toHaveProperty('createdAt');
+            expect(payload.members[0]).not.toHaveProperty('updatedAt');
+            expect(payload.members[0]).not.toHaveProperty('presetId');
+        }
+        finally {
+            if (previousTeamRunId === undefined) {
+                delete process.env.AGENT_TOWER_TEAM_RUN_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_TEAM_RUN_ID = previousTeamRunId;
+            }
+            if (previousMemberId === undefined) {
+                delete process.env.AGENT_TOWER_MEMBER_ID;
+            }
+            else {
+                process.env.AGENT_TOWER_MEMBER_ID = previousMemberId;
+            }
+            await app.close();
+        }
+    });
+    it('rejects explicit mismatched team_run_id in bound MCP TeamRun tools', async () => {
+        const previousEnv = captureTeamRunEnv();
+        const { workspace, teamRun, members } = await createFixture({ memberCount: 1 });
+        const other = await createFixture({ memberCount: 1 });
+        const request = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'STARTED',
+        });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+        });
+        const routeScheduler = createRouteSchedulerMock();
+        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: invocation.id,
+                AGENT_TOWER_SESSION_ID: undefined,
+            });
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            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-mismatch-test-client', version: '0.1.0' });
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+            await server.connect(serverTransport);
+            await client.connect(clientTransport);
+            try {
+                const cases = [
+                    {
+                        name: 'post_room_message',
+                        arguments: {
+                            team_run_id: other.teamRun.id,
+                            content: 'This should be rejected before reaching the API',
+                        },
+                    },
+                    {
+                        name: 'list_room_messages',
+                        arguments: {
+                            team_run_id: other.teamRun.id,
+                        },
+                    },
+                    {
+                        name: 'list_team_members',
+                        arguments: {
+                            team_run_id: other.teamRun.id,
+                        },
+                    },
+                    {
+                        name: 'stop_member_work',
+                        arguments: {
+                            team_run_id: other.teamRun.id,
+                            member_id: other.members[0].id,
+                            cancel_queued: true,
+                        },
+                    },
+                ];
+                for (const toolCall of cases) {
+                    const result = await client.callTool(toolCall);
+                    expect(result.isError, toolCall.name).toBe(true);
+                    expect(getMcpToolText(result), toolCall.name).toContain(TEAM_RUN_MISMATCH_ERROR);
+                }
+            }
+            finally {
+                await client.close();
+                await server.close();
+            }
+            await expect(prisma.roomMessage.count()).resolves.toBe(0);
+            expect(routeScheduler.stopMemberWork).not.toHaveBeenCalled();
+        }
+        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 });
+        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-partial-identity-test-client', version: '0.1.0' });
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+            await server.connect(serverTransport);
+            await client.connect(clientTransport);
+            let messageId;
+            try {
+                const result = await client.callTool({
+                    name: 'post_room_message',
+                    arguments: {
+                        content: 'Partial identity should not be sent as agent',
+                    },
+                });
+                expect(result.isError, getMcpToolText(result)).not.toBe(true);
+                const message = JSON.parse(getMcpToolText(result));
+                messageId = message.id;
+                expect(message).toMatchObject({
+                    senderType: 'user',
+                    senderId: null,
+                    senderInvocationId: null,
+                });
+            }
+            finally {
+                await client.close();
+                await server.close();
+            }
+            await expect(prisma.roomMessage.findUnique({ where: { id: messageId } })).resolves.toMatchObject({
+                senderType: 'user',
+                senderId: null,
+                senderInvocationId: null,
+            });
+        }
+        finally {
+            restoreTeamRunEnv(previousEnv);
+            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,
+            teamRunMode: 'AUTO',
+            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 });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/team-runs/${teamRun.id}/messages`,
+                payload: {
+                    content: '普通用户消息',
+                    senderType: 'user',
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const message = response.json();
+            expect(message.mentions).toEqual([]);
+            expect(message.workRequestIds).toHaveLength(1);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+            await expect(prisma.workRequest.findUnique({ where: { id: message.workRequestIds[0] } })).resolves.toMatchObject({
+                targetMemberId: members[0].id,
+                instruction: '普通用户消息',
+                status: 'QUEUED',
+            });
+            await expect(prisma.agentInvocation.count({
+                where: {
+                    teamRunId: teamRun.id,
+                    memberId: members[0].id,
+                },
+            })).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();
+        }
+    });
+    it('SessionManager.stop routes TeamRun sessions through the reconciler', async () => {
+        const { workspace, teamRun, members } = await createFixture();
+        const request = await createWorkRequest({ teamRunId: teamRun.id, targetMemberId: members[0].id });
+        const session = await prisma.session.create({
+            data: {
+                workspaceId: workspace.id,
+                agentType: 'CODEX',
+                providerId: 'provider-1',
+                prompt: 'Do the work',
+                status: 'RUNNING',
+            },
+        });
+        const invocation = await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            sessionId: session.id,
+            status: 'RUNNING',
+        });
+        const manager = new SessionManager(new EventBus(), service);
+        await expect(manager.stop(session.id)).resolves.toMatchObject({ id: session.id });
+        await expect(prisma.session.findUnique({ where: { id: session.id } })).resolves.toMatchObject({
+            status: 'CANCELLED',
+        });
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'CANCELLED',
+            nextRoomReplyReminderAt: null,
+        });
+        expect(scheduler.releaseInvocationLocks).toHaveBeenCalledWith(invocation.id);
+        expect(scheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+    });
+    it('SessionManager.stop leaves solo sessions without TeamRun reconciliation', async () => {
+        const { workspace } = await createFixture();
+        const session = await prisma.session.create({
+            data: {
+                workspaceId: workspace.id,
+                agentType: 'CODEX',
+                providerId: 'provider-1',
+                prompt: 'Solo work',
+                status: 'RUNNING',
+            },
+        });
+        const manager = new SessionManager(new EventBus(), service);
+        await expect(manager.stop(session.id)).resolves.toMatchObject({ id: session.id });
+        await expect(prisma.session.findUnique({ where: { id: session.id } })).resolves.toMatchObject({
+            status: 'CANCELLED',
+        });
+        expect(scheduler.releaseInvocationLocks).not.toHaveBeenCalled();
+        expect(scheduler.startNextSessions).not.toHaveBeenCalled();
+        await expect(prisma.agentInvocation.count()).resolves.toBe(0);
+    });
+});
+//# sourceMappingURL=team-reconciler.service.test.js.map