agent-tower 0.4.15 → 0.4.16-beta.3

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

@@ -0,0 +1,699 @@
+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 { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-tower-team-run-'));
+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 TeamRunService;
+let prisma;
+const capabilities = {
+    readRoom: true,
+    postRoomMessage: true,
+    mentionMembers: true,
+    stopMemberWork: false,
+    markReadyForReview: true,
+    readFiles: true,
+    writeFiles: true,
+    runCommands: false,
+    readDiff: true,
+    mergeWorkspace: false,
+};
+function presetInput(name, aliases = [name.toLowerCase()]) {
+    return {
+        name,
+        aliases,
+        providerId: `provider-${name.toLowerCase()}`,
+        rolePrompt: `${name} role`,
+        capabilities,
+        workspacePolicy: 'dedicated',
+        triggerPolicy: 'MENTION_ONLY',
+        sessionPolicy: 'new_per_request',
+        avatar: null,
+    };
+}
+function userMessagesPresetInput(name, aliases = [name.toLowerCase()]) {
+    return {
+        ...presetInput(name, aliases),
+        triggerPolicy: 'USER_MESSAGES',
+    };
+}
+async function createTask(title = 'Team task') {
+    const project = await prisma.project.create({
+        data: {
+            name: `${title} project`,
+            repoPath: testDir,
+        },
+    });
+    return prisma.task.create({
+        data: {
+            title,
+            projectId: project.id,
+        },
+    });
+}
+describe('TeamRunService', () => {
+    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 serviceModule = await import('../team-run.service.js');
+        const utilsModule = await import('../../utils/index.js');
+        TeamRunService = serviceModule.TeamRunService;
+        prisma = utilsModule.prisma;
+    });
+    beforeEach(async () => {
+        service = new TeamRunService();
+        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.task.deleteMany();
+        await prisma.project.deleteMany();
+    });
+    afterAll(async () => {
+        await prisma.$disconnect();
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    it('returns structured aliases and capabilities after creating a MemberPreset', async () => {
+        const preset = await service.createMemberPreset(presetInput('Reviewer', ['reviewer', 'review']));
+        expect(preset.aliases).toEqual(['reviewer', 'review']);
+        expect(preset.capabilities).toEqual(capabilities);
+        expect(preset.sessionPolicy).toBe('new_per_request');
+    });
+    it('preserves session policy in MemberPreset and TeamMember snapshots', async () => {
+        const preset = await service.createMemberPreset({
+            ...presetInput('Implementer', ['impl']),
+            sessionPolicy: 'resume_last',
+        });
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        expect(preset.sessionPolicy).toBe('resume_last');
+        expect(teamRun.members?.[0]).toMatchObject({
+            name: 'Implementer',
+            sessionPolicy: 'resume_last',
+        });
+    });
+    it('rejects deleting a MemberPreset that is referenced by a TeamTemplate', async () => {
+        const preset = await service.createMemberPreset(presetInput('Reviewer'));
+        await service.createTeamTemplate({
+            name: 'Review team',
+            memberPresetIds: [preset.id],
+        });
+        await expect(service.deleteMemberPreset(preset.id)).rejects.toMatchObject({
+            code: 'CONFLICT',
+            statusCode: 409,
+        });
+        await expect(service.getMemberPresetById(preset.id)).resolves.toMatchObject({
+            id: preset.id,
+            name: 'Reviewer',
+        });
+    });
+    it('preserves repeated MemberPresets in TeamTemplate members', async () => {
+        const preset = await service.createMemberPreset(presetInput('Implementer', ['impl']));
+        const template = await service.createTeamTemplate({
+            name: 'Parallel implementers',
+            memberPresetIds: [preset.id, preset.id, preset.id],
+        });
+        expect(template.members).toHaveLength(3);
+        expect(template.members?.map((member) => member.memberPresetId)).toEqual([preset.id, preset.id, preset.id]);
+        expect(template.members?.map((member) => member.position)).toEqual([0, 1, 2]);
+        expect(template.members?.map((member) => member.memberPreset?.name)).toEqual([
+            'Implementer',
+            'Implementer',
+            'Implementer',
+        ]);
+    });
+    it('updates TeamTemplate members with repeated MemberPresets in order', async () => {
+        const first = await service.createMemberPreset(presetInput('Implementer', ['impl']));
+        const second = await service.createMemberPreset(presetInput('Reviewer', ['review']));
+        const template = await service.createTeamTemplate({
+            name: 'Initial team',
+            memberPresetIds: [second.id],
+        });
+        const updated = await service.updateTeamTemplate(template.id, {
+            memberPresetIds: [first.id, second.id, first.id],
+        });
+        expect(updated.members).toHaveLength(3);
+        expect(updated.members?.map((member) => member.memberPresetId)).toEqual([
+            first.id,
+            second.id,
+            first.id,
+        ]);
+        expect(updated.members?.map((member) => member.position)).toEqual([0, 1, 2]);
+    });
+    it('creates TeamMember snapshots from multiple MemberPresets', async () => {
+        const first = await service.createMemberPreset(presetInput('Planner', ['planner']));
+        const second = await service.createMemberPreset(presetInput('Coder', ['coder']));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'CONFIRM',
+            memberPresetIds: [first.id, second.id],
+        });
+        expect(teamRun.members).toHaveLength(2);
+        expect(teamRun.members?.map((member) => member.name)).toEqual(['Planner', 'Coder']);
+        expect(teamRun.members?.map((member) => member.presetId)).toEqual([first.id, second.id]);
+    });
+    it('creates stable instance names when the same MemberPreset is selected more than once', async () => {
+        const preset = await service.createMemberPreset(presetInput('Implementer', ['impl']));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id, preset.id, preset.id],
+        });
+        expect(teamRun.members).toHaveLength(3);
+        expect(teamRun.members?.map((member) => member.name)).toEqual([
+            'Implementer #1',
+            'Implementer #2',
+            'Implementer #3',
+        ]);
+        expect(teamRun.members?.map((member) => member.presetId)).toEqual([preset.id, preset.id, preset.id]);
+        expect(teamRun.members?.map((member) => member.aliases)).toEqual([['impl'], ['impl'], ['impl']]);
+    });
+    it('creates stable instance names for repeated explicit TeamRun members', async () => {
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            members: [
+                presetInput('Implementer', ['impl']),
+                presetInput('Implementer', ['impl']),
+            ],
+        });
+        expect(teamRun.members).toHaveLength(2);
+        expect(teamRun.members?.map((member) => member.name)).toEqual([
+            'Implementer #1',
+            'Implementer #2',
+        ]);
+        expect(teamRun.members?.map((member) => member.presetId)).toEqual([null, null]);
+    });
+    it('creates stable instance names across TeamTemplate and explicit MemberPreset duplicates', async () => {
+        const preset = await service.createMemberPreset(presetInput('Implementer', ['impl']));
+        const task = await createTask();
+        const template = await service.createTeamTemplate({
+            name: 'Three implementers',
+            memberPresetIds: [preset.id, preset.id],
+        });
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            teamTemplateId: template.id,
+            memberPresetIds: [preset.id],
+        });
+        expect(teamRun.members).toHaveLength(3);
+        expect(teamRun.members?.map((member) => member.name)).toEqual([
+            'Implementer #1',
+            'Implementer #2',
+            'Implementer #3',
+        ]);
+    });
+    it('keeps TeamMember snapshots unchanged after updating a MemberPreset', async () => {
+        const preset = await service.createMemberPreset(presetInput('Implementer', ['impl']));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        await service.updateMemberPreset(preset.id, {
+            name: 'Updated Implementer',
+            aliases: ['updated'],
+        });
+        const reloaded = await service.getTeamRunById(teamRun.id);
+        expect(reloaded.members?.[0]?.name).toBe('Implementer');
+        expect(reloaded.members?.[0]?.aliases).toEqual(['impl']);
+    });
+    it('creates a RoomMessage without WorkRequests when mentions are omitted', async () => {
+        const preset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'General note',
+        });
+        expect(message.senderType).toBe('user');
+        expect(message.kind).toBe('chat');
+        expect(message.mentions).toEqual([]);
+        expect(message.workRequestIds).toEqual([]);
+        await expect(service.listWorkRequests(teamRun.id)).resolves.toEqual([]);
+    });
+    it('creates WorkRequests for USER_MESSAGES members when a user message has no mentions', async () => {
+        const leaderPreset = await service.createMemberPreset(userMessagesPresetInput('Leader'));
+        const coderPreset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [leaderPreset.id, coderPreset.id],
+        });
+        const leader = teamRun.members?.find((member) => member.name === 'Leader');
+        expect(leader).toBeDefined();
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'General user request',
+        });
+        const requests = await service.listWorkRequests(teamRun.id);
+        expect(message.kind).toBe('chat');
+        expect(message.mentions).toEqual([]);
+        expect(message.workRequestIds).toEqual([requests[0]?.id]);
+        expect(requests).toHaveLength(1);
+        expect(requests[0]).toMatchObject({
+            requesterType: 'user',
+            requesterMemberId: null,
+            targetMemberId: leader.id,
+            triggerMessageId: message.id,
+            instruction: 'General user request',
+            ifBusy: 'queue',
+            cancelQueued: false,
+            status: 'QUEUED',
+        });
+    });
+    it('creates WorkRequests from RoomMessage mentions and writes workRequestIds back', async () => {
+        const preset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'CONFIRM',
+            memberPresetIds: [preset.id],
+        });
+        const member = teamRun.members?.[0];
+        expect(member).toBeDefined();
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'Please implement this',
+            mentions: [{ memberId: member.id, ifBusy: 'cancel_current_and_start', cancelQueued: true }],
+        });
+        const requests = await service.listWorkRequests(teamRun.id);
+        expect(message.kind).toBe('work_request');
+        expect(message.workRequestIds).toEqual([requests[0]?.id]);
+        expect(requests).toHaveLength(1);
+        expect(requests[0]).toMatchObject({
+            requesterType: 'user',
+            requesterMemberId: null,
+            targetMemberId: member.id,
+            triggerMessageId: message.id,
+            instruction: 'Please implement this',
+            ifBusy: 'cancel_current_and_start',
+            cancelQueued: true,
+            status: 'PENDING_APPROVAL',
+        });
+    });
+    it('derives TeamMember status from active invocations and open WorkRequests', async () => {
+        const runningPreset = await service.createMemberPreset(presetInput('Runner'));
+        const pendingPreset = await service.createMemberPreset(presetInput('Pending'));
+        const queuedPreset = await service.createMemberPreset(presetInput('Queued'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'CONFIRM',
+            memberPresetIds: [runningPreset.id, pendingPreset.id, queuedPreset.id],
+        });
+        const [runningMember, pendingMember, queuedMember] = teamRun.members ?? [];
+        expect(runningMember).toBeDefined();
+        expect(pendingMember).toBeDefined();
+        expect(queuedMember).toBeDefined();
+        const workspace = await prisma.workspace.create({
+            data: {
+                taskId: task.id,
+                branchName: 'team-shared-status',
+                worktreePath: testDir,
+                status: 'ACTIVE',
+            },
+        });
+        const runningRequest = await prisma.workRequest.create({
+            data: {
+                teamRunId: teamRun.id,
+                requesterMemberId: null,
+                requesterType: 'user',
+                targetMemberId: runningMember.id,
+                triggerMessageId: 'running-trigger',
+                instruction: 'Running work',
+                status: 'STARTED',
+            },
+        });
+        await prisma.agentInvocation.create({
+            data: {
+                teamRunId: teamRun.id,
+                workRequestId: runningRequest.id,
+                memberId: runningMember.id,
+                workspaceId: workspace.id,
+                sessionId: null,
+                status: 'RUNNING',
+            },
+        });
+        await prisma.workRequest.create({
+            data: {
+                teamRunId: teamRun.id,
+                requesterMemberId: null,
+                requesterType: 'user',
+                targetMemberId: pendingMember.id,
+                triggerMessageId: 'pending-trigger',
+                instruction: 'Pending work',
+                status: 'PENDING_APPROVAL',
+            },
+        });
+        await prisma.workRequest.create({
+            data: {
+                teamRunId: teamRun.id,
+                requesterMemberId: null,
+                requesterType: 'user',
+                targetMemberId: queuedMember.id,
+                triggerMessageId: 'queued-trigger',
+                instruction: 'Queued work',
+                status: 'QUEUED',
+            },
+        });
+        const members = await service.listTeamMembers(teamRun.id);
+        const statuses = new Map(members.map((member) => [member.id, member.status]));
+        expect(statuses.get(runningMember.id)).toBe('RUNNING');
+        expect(statuses.get(pendingMember.id)).toBe('PENDING_APPROVAL');
+        expect(statuses.get(queuedMember.id)).toBe('QUEUED');
+    });
+    it('creates WorkRequests only for the selected memberId when same-name members are mentioned', async () => {
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            members: [
+                presetInput('Coder'),
+                presetInput('Coder'),
+            ],
+        });
+        const [firstCoder, secondCoder] = teamRun.members ?? [];
+        expect(firstCoder).toBeDefined();
+        expect(secondCoder).toBeDefined();
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: '@Coder please implement this',
+            mentions: [{ memberId: secondCoder.id, label: secondCoder.name }],
+        });
+        const requests = await service.listWorkRequests(teamRun.id);
+        expect(message.mentions).toEqual([{ memberId: secondCoder.id, label: secondCoder.name }]);
+        expect(message.workRequestIds).toEqual([requests[0]?.id]);
+        expect(requests).toHaveLength(1);
+        expect(requests[0]).toMatchObject({
+            targetMemberId: secondCoder.id,
+            triggerMessageId: message.id,
+            instruction: '@Coder please implement this',
+            status: 'QUEUED',
+        });
+        expect(requests[0]?.targetMemberId).not.toBe(firstCoder.id);
+    });
+    it('does not parse text @name into WorkRequests when structured mentions are omitted', async () => {
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            members: [
+                presetInput('Coder'),
+                presetInput('Coder'),
+            ],
+        });
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: '@Coder please implement this',
+        });
+        expect(message.mentions).toEqual([]);
+        expect(message.workRequestIds).toEqual([]);
+        await expect(service.listWorkRequests(teamRun.id)).resolves.toEqual([]);
+    });
+    it('does not create USER_MESSAGES WorkRequests when a user message already has mentions', async () => {
+        const leaderPreset = await service.createMemberPreset(userMessagesPresetInput('Leader'));
+        const coderPreset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'CONFIRM',
+            memberPresetIds: [leaderPreset.id, coderPreset.id],
+        });
+        const coder = teamRun.members?.find((member) => member.name === 'Coder');
+        expect(coder).toBeDefined();
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'Please implement this',
+            mentions: [{ memberId: coder.id }],
+        });
+        const requests = await service.listWorkRequests(teamRun.id);
+        expect(message.workRequestIds).toEqual([requests[0]?.id]);
+        expect(requests).toHaveLength(1);
+        expect(requests[0]?.targetMemberId).toBe(coder.id);
+    });
+    it('creates USER_MESSAGES WorkRequests for unmentioned agent messages from other members', async () => {
+        const leaderPreset = await service.createMemberPreset(userMessagesPresetInput('Leader'));
+        const coderPreset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [leaderPreset.id, coderPreset.id],
+        });
+        const leader = teamRun.members?.find((member) => member.name === 'Leader');
+        const coder = teamRun.members?.find((member) => member.name === 'Coder');
+        expect(leader).toBeDefined();
+        expect(coder).toBeDefined();
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'Agent result',
+            senderType: 'agent',
+            senderId: coder.id,
+        });
+        const requests = await service.listWorkRequests(teamRun.id);
+        expect(message.workRequestIds).toEqual([requests[0]?.id]);
+        expect(requests).toHaveLength(1);
+        expect(requests[0]).toMatchObject({
+            requesterType: 'agent',
+            requesterMemberId: coder.id,
+            targetMemberId: leader.id,
+            triggerMessageId: message.id,
+            instruction: 'Agent result',
+            ifBusy: 'queue',
+            cancelQueued: false,
+            status: 'QUEUED',
+        });
+    });
+    it('does not create USER_MESSAGES WorkRequests for the sending member itself', async () => {
+        const leaderPreset = await service.createMemberPreset(userMessagesPresetInput('Leader'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [leaderPreset.id],
+        });
+        const leader = teamRun.members?.find((member) => member.name === 'Leader');
+        expect(leader).toBeDefined();
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'Leader summary',
+            senderType: 'agent',
+            senderId: leader.id,
+        });
+        expect(message.workRequestIds).toEqual([]);
+        await expect(service.listWorkRequests(teamRun.id)).resolves.toEqual([]);
+    });
+    it('queues WorkRequests in AUTO mode and preserves senderInvocationId', async () => {
+        const preset = await service.createMemberPreset(presetInput('Reviewer'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        const member = teamRun.members?.[0];
+        expect(member).toBeDefined();
+        const workspace = await prisma.workspace.create({
+            data: {
+                taskId: task.id,
+                branchName: 'team-shared',
+                worktreePath: testDir,
+                status: 'ACTIVE',
+            },
+        });
+        const request = await prisma.workRequest.create({
+            data: {
+                teamRunId: teamRun.id,
+                requesterMemberId: null,
+                requesterType: 'user',
+                targetMemberId: member.id,
+                triggerMessageId: 'trigger-message-1',
+                instruction: 'Original work',
+                status: 'STARTED',
+            },
+        });
+        const session = await prisma.session.create({
+            data: {
+                workspaceId: workspace.id,
+                agentType: 'CODEX',
+                providerId: member.providerId,
+                prompt: 'Do the work',
+                status: 'RUNNING',
+            },
+        });
+        const invocation = await prisma.agentInvocation.create({
+            data: {
+                teamRunId: teamRun.id,
+                workRequestId: request.id,
+                memberId: member.id,
+                workspaceId: workspace.id,
+                sessionId: session.id,
+                status: 'RUNNING',
+            },
+        });
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'Review this change',
+            mentions: [{ memberId: member.id }],
+            senderType: 'agent',
+            senderId: member.id,
+            senderInvocationId: invocation.id,
+        });
+        const requests = await service.listWorkRequests(teamRun.id);
+        const createdRequest = requests.find((item) => item.triggerMessageId === message.id);
+        expect(message.senderInvocationId).toBe(invocation.id);
+        expect(createdRequest).toMatchObject({
+            requesterType: 'agent',
+            requesterMemberId: member.id,
+            status: 'QUEUED',
+        });
+    });
+    it('rejects agent RoomMessages when senderInvocationId does not belong to the sender', async () => {
+        const senderPreset = await service.createMemberPreset(presetInput('Sender'));
+        const otherPreset = await service.createMemberPreset(presetInput('Other'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [senderPreset.id, otherPreset.id],
+        });
+        const sender = teamRun.members?.find((member) => member.name === 'Sender');
+        const other = teamRun.members?.find((member) => member.name === 'Other');
+        expect(sender).toBeDefined();
+        expect(other).toBeDefined();
+        const workspace = await prisma.workspace.create({
+            data: {
+                taskId: task.id,
+                branchName: 'team-shared',
+                worktreePath: testDir,
+                status: 'ACTIVE',
+            },
+        });
+        const request = await prisma.workRequest.create({
+            data: {
+                teamRunId: teamRun.id,
+                requesterMemberId: null,
+                requesterType: 'user',
+                targetMemberId: other.id,
+                triggerMessageId: 'trigger-message-2',
+                instruction: 'Original work',
+                status: 'STARTED',
+            },
+        });
+        const session = await prisma.session.create({
+            data: {
+                workspaceId: workspace.id,
+                agentType: 'CODEX',
+                providerId: other.providerId,
+                prompt: 'Do the work',
+                status: 'RUNNING',
+            },
+        });
+        const invocation = await prisma.agentInvocation.create({
+            data: {
+                teamRunId: teamRun.id,
+                workRequestId: request.id,
+                memberId: other.id,
+                workspaceId: workspace.id,
+                sessionId: session.id,
+                status: 'RUNNING',
+            },
+        });
+        await expect(service.createRoomMessage(teamRun.id, {
+            content: 'Spoofed result',
+            senderType: 'agent',
+            senderId: sender.id,
+            senderInvocationId: invocation.id,
+        })).rejects.toMatchObject({
+            code: 'VALIDATION_ERROR',
+            statusCode: 400,
+        });
+    });
+    it('saves and reads RoomMessage attachmentIds', async () => {
+        const preset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'See attached',
+            attachmentIds: ['attachment-1', 'attachment-2'],
+        });
+        const messages = await service.listRoomMessages(teamRun.id);
+        expect(message.attachmentIds).toEqual(['attachment-1', 'attachment-2']);
+        expect(messages[0]?.attachmentIds).toEqual(['attachment-1', 'attachment-2']);
+    });
+    it('adds attachment markdown context to WorkRequest instructions from RoomMessage attachmentIds', async () => {
+        const preset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        const attachment = await prisma.attachment.create({
+            data: {
+                originalName: 'screenshot.png',
+                mimeType: 'image/png',
+                sizeBytes: 128,
+                storagePath: path.join(testDir, 'screenshot.png'),
+                hash: 'attachment-context-hash',
+            },
+        });
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'Please inspect this UI',
+            mentions: [{ memberId: teamRun.members[0].id, label: 'Coder' }],
+            attachmentIds: [attachment.id],
+        });
+        const request = await prisma.workRequest.findUnique({
+            where: { id: message.workRequestIds[0] },
+        });
+        expect(request?.instruction).toBe(`Please inspect this UI\n\nAttachments:\n![screenshot.png](${attachment.storagePath})`);
+    });
+    it('does not duplicate WorkRequest attachment context when content already includes the storage path', async () => {
+        const preset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        const attachment = await prisma.attachment.create({
+            data: {
+                originalName: 'screenshot.png',
+                mimeType: 'image/png',
+                sizeBytes: 128,
+                storagePath: path.join(testDir, 'screenshot-dedup.png'),
+                hash: 'attachment-context-dedup-hash',
+            },
+        });
+        const content = `Please inspect this UI\n\n![screenshot.png](${attachment.storagePath})`;
+        const message = await service.createRoomMessage(teamRun.id, {
+            content,
+            mentions: [{ memberId: teamRun.members[0].id, label: 'Coder' }],
+            attachmentIds: [attachment.id],
+        });
+        const request = await prisma.workRequest.findUnique({
+            where: { id: message.workRequestIds[0] },
+        });
+        expect(request?.instruction).toBe(content);
+        expect(request?.instruction).not.toContain('Attachments:');
+    });
+    it('returns a clear conflict when creating a second TeamRun for one Task', async () => {
+        const preset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const input = {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        };
+        await service.createTeamRun(task.id, input);
+        await expect(service.createTeamRun(task.id, input)).rejects.toMatchObject({
+            code: 'CONFLICT',
+            statusCode: 409,
+        });
+    });
+});
+//# sourceMappingURL=team-run.service.test.js.map