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

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

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { AgentType } from '../../types/index.js';
+import { AgentType, TaskStatus } from '../../types/index.js';
 import { TeamLockService } from '../team-lock.service.js';
 const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-tower-team-scheduler-'));
 const dbPath = path.join(testDir, 'test.db');
@@ -40,7 +40,7 @@ const commandCapabilities = {
 function stringifyJson(value) {
     return JSON.stringify(value);
 }
-async function createTask(title = 'Team scheduler task') {
+async function createTask(title = 'Team scheduler task', status = TaskStatus.TODO) {
     const project = await prisma.project.create({
         data: {
             name: `${title} project`,
@@ -51,12 +51,13 @@ async function createTask(title = 'Team scheduler task') {
         data: {
             title,
             projectId: project.id,
+            status,
         },
     });
     return { project, task };
 }
 async function createTeamRunFixture(options = {}) {
-    const { project, task } = await createTask();
+    const { project, task } = await createTask('Team scheduler task', options.taskStatus);
     const teamRun = await prisma.teamRun.create({
         data: {
             taskId: task.id,
@@ -100,7 +101,7 @@ async function createWorkRequest(options) {
             requesterMemberId: null,
             requesterType: 'user',
             targetMemberId: options.targetMemberId,
-            triggerMessageId: `message-${Math.random().toString(16).slice(2)}`,
+            triggerMessageId: options.triggerMessageId ?? `message-${Math.random().toString(16).slice(2)}`,
             instruction: options.instruction ?? 'Please do the work',
             ifBusy: options.ifBusy ?? 'queue',
             cancelQueued: options.cancelQueued ?? false,
@@ -617,26 +618,124 @@ describe('TeamSchedulerService', () => {
             }),
         ]);
     });
-    it('leaves dedicated workspace members blocked because dedicated startup is reserved', async () => {
-        const { teamRun, members } = await createTeamRunFixture({
-            workspacePolicies: ['dedicated'],
+    it('starts dedicated members in child workspaces without shared workspace locks', async () => {
+        const { workspace: mainWorkspace, teamRun, members } = await createTeamRunFixture({
+            memberCapabilities: [writeCapabilities, writeCapabilities],
+            workspacePolicies: ['dedicated', 'dedicated'],
         });
-        const request = await createWorkRequest({
+        const first = await createWorkRequest({
             teamRunId: teamRun.id,
             targetMemberId: members[0].id,
         });
+        const second = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+        });
+        const childByMemberId = new Map();
+        const workspaceService = {
+            create: vi.fn(),
+            getOrCreateMainWorkspace: vi.fn(async () => mainWorkspace),
+            getOrCreateDedicatedWorkspace: vi.fn(async (_teamRunId, memberId) => {
+                const existing = childByMemberId.get(memberId);
+                if (existing) {
+                    return existing;
+                }
+                const workspace = await prisma.workspace.create({
+                    data: {
+                        taskId: teamRun.taskId,
+                        parentWorkspaceId: mainWorkspace.id,
+                        ownerMemberId: memberId,
+                        branchName: `dedicated-${memberId.slice(0, 8)}`,
+                        worktreePath: path.join(testDir, `dedicated-${memberId}`),
+                        status: 'ACTIVE',
+                    },
+                });
+                childByMemberId.set(memberId, workspace);
+                return workspace;
+            }),
+        };
+        service = new TeamSchedulerService(lockService, {
+            workspaceService,
+            sessionManager: createSessionManagerMock(),
+            getProviderById: createProviderLookup(),
+        });
         await expect(service.planNext(teamRun.id)).resolves.toEqual([
             expect.objectContaining({
-                workRequestId: request.id,
-                canStart: false,
-                blockedReason: 'unsupported_workspace_policy',
+                workRequestId: first.id,
+                canStart: true,
+                lockKeys: [],
+                workspaceId: null,
+            }),
+            expect.objectContaining({
+                workRequestId: second.id,
+                canStart: true,
+                lockKeys: [],
+                workspaceId: null,
             }),
         ]);
-        await expect(service.startNext(teamRun.id)).resolves.toEqual([]);
-        await expect(prisma.agentInvocation.count()).resolves.toBe(0);
-        await expect(prisma.workRequest.findUnique({ where: { id: request.id } })).resolves.toMatchObject({
+        const invocations = await service.startNextSessions(teamRun.id);
+        expect(invocations).toHaveLength(2);
+        expect(new Set(invocations.map((invocation) => invocation.workspaceId)).size).toBe(2);
+        expect(new Set(invocations.map((invocation) => invocation.workRequestId))).toEqual(new Set([
+            first.id,
+            second.id,
+        ]));
+        expect(workspaceService.getOrCreateDedicatedWorkspace).toHaveBeenCalledTimes(2);
+        expect(workspaceService.create).not.toHaveBeenCalled();
+        expect(lockService.listLocks()).toEqual([]);
+        const childWorkspaces = await prisma.workspace.findMany({
+            where: { parentWorkspaceId: mainWorkspace.id },
+            orderBy: { ownerMemberId: 'asc' },
+        });
+        expect(childWorkspaces).toHaveLength(2);
+        expect(new Set(childWorkspaces.map((workspace) => workspace.ownerMemberId))).toEqual(new Set([
+            members[0].id,
+            members[1].id,
+        ]));
+    });
+    it('records the dedicated child workspace for queued no-session invocations', async () => {
+        const { workspace: mainWorkspace, teamRun, members } = await createTeamRunFixture({
+            memberCapabilities: [writeCapabilities],
+            workspacePolicies: ['dedicated'],
+        });
+        const request = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+        });
+        const childWorkspace = await prisma.workspace.create({
+            data: {
+                taskId: teamRun.taskId,
+                parentWorkspaceId: mainWorkspace.id,
+                ownerMemberId: members[0].id,
+                branchName: 'dedicated-queued',
+                worktreePath: path.join(testDir, 'dedicated-queued'),
+                status: 'ACTIVE',
+            },
+        });
+        const workspaceService = {
+            create: vi.fn(),
+            getOrCreateMainWorkspace: vi.fn(async () => mainWorkspace),
+            getOrCreateDedicatedWorkspace: vi.fn(async () => childWorkspace),
+        };
+        service = new TeamSchedulerService(lockService, {
+            workspaceService,
+            sessionManager: createSessionManagerMock(),
+            getProviderById: createProviderLookup(),
+        });
+        const invocations = await service.startNext(teamRun.id);
+        expect(invocations).toHaveLength(1);
+        expect(invocations[0]).toMatchObject({
+            workRequestId: request.id,
+            memberId: members[0].id,
+            workspaceId: childWorkspace.id,
+            sessionId: null,
             status: 'QUEUED',
         });
+        expect(lockService.listLocks()).toEqual([]);
+        expect(workspaceService.getOrCreateDedicatedWorkspace).toHaveBeenCalledWith(teamRun.id, members[0].id);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocations[0].id } })).resolves.toMatchObject({
+            workspaceId: childWorkspace.id,
+        });
     });
     it('cancels only queued requests for the same member when cancelQueued is set', async () => {
         const { teamRun, members } = await createTeamRunFixture();
@@ -702,6 +801,88 @@ describe('TeamSchedulerService', () => {
             status: 'RUNNING',
         });
     });
+    it('builds session prompt attachment context from the trigger RoomMessage attachmentIds', async () => {
+        const { task, teamRun, members } = await createTeamRunFixture({ withWorkspace: false });
+        const attachment = await prisma.attachment.create({
+            data: {
+                originalName: 'reference.png',
+                mimeType: 'image/png',
+                sizeBytes: 256,
+                storagePath: path.join(testDir, 'reference.png'),
+                hash: 'scheduler-attachment-context-hash',
+            },
+        });
+        const message = await prisma.roomMessage.create({
+            data: {
+                teamRunId: teamRun.id,
+                senderType: 'user',
+                kind: 'work_request',
+                content: 'Use this reference',
+                mentions: stringifyJson([{ memberId: members[0].id, label: 'Member 1' }]),
+                workRequestIds: stringifyJson([]),
+                artifactRefs: stringifyJson([]),
+                attachmentIds: stringifyJson([attachment.id]),
+            },
+        });
+        await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            instruction: 'Use this reference',
+            triggerMessageId: message.id,
+        });
+        const workspaceService = createWorkspaceServiceMock();
+        const sessionManager = createSessionManagerMock();
+        service = new TeamSchedulerService(lockService, {
+            workspaceService,
+            sessionManager,
+            getProviderById: createProviderLookup(),
+        });
+        await service.startNextSessions(teamRun.id);
+        expect(workspaceService.create).toHaveBeenCalledWith(task.id);
+        expect(sessionManager.create).toHaveBeenCalledWith(expect.any(String), AgentType.CODEX, `Role 1\n\nTask:\nUse this reference\n\nAttachments:\n![reference.png](${attachment.storagePath})`, 'DEFAULT', members[0].providerId);
+    });
+    it('does not duplicate session prompt attachment context when the WorkRequest instruction already includes the storage path', async () => {
+        const { task, teamRun, members } = await createTeamRunFixture({ withWorkspace: false });
+        const attachment = await prisma.attachment.create({
+            data: {
+                originalName: 'reference.png',
+                mimeType: 'image/png',
+                sizeBytes: 256,
+                storagePath: path.join(testDir, 'reference-dedup.png'),
+                hash: 'scheduler-attachment-context-dedup-hash',
+            },
+        });
+        const instruction = `Use this reference\n\n![reference.png](${attachment.storagePath})`;
+        const message = await prisma.roomMessage.create({
+            data: {
+                teamRunId: teamRun.id,
+                senderType: 'user',
+                kind: 'work_request',
+                content: instruction,
+                mentions: stringifyJson([{ memberId: members[0].id, label: 'Member 1' }]),
+                workRequestIds: stringifyJson([]),
+                artifactRefs: stringifyJson([]),
+                attachmentIds: stringifyJson([attachment.id]),
+            },
+        });
+        await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            instruction,
+            triggerMessageId: message.id,
+        });
+        const workspaceService = createWorkspaceServiceMock();
+        const sessionManager = createSessionManagerMock();
+        service = new TeamSchedulerService(lockService, {
+            workspaceService,
+            sessionManager,
+            getProviderById: createProviderLookup(),
+        });
+        await service.startNextSessions(teamRun.id);
+        expect(workspaceService.create).toHaveBeenCalledWith(task.id);
+        expect(sessionManager.create).toHaveBeenCalledWith(expect.any(String), AgentType.CODEX, `Role 1\n\nTask:\n${instruction}`, 'DEFAULT', members[0].providerId);
+        expect(sessionManager.create.mock.calls[0]?.[2]).not.toContain('Attachments:');
+    });
     it('starts resume_last members with executor resume context while keeping a new Tower session and invocation', async () => {
         const { workspace, teamRun, members } = await createTeamRunFixture({
             sessionPolicies: ['resume_last'],
@@ -766,6 +947,202 @@ describe('TeamSchedulerService', () => {
             status: 'RUNNING',
         });
     });
+    it('starts new_per_request members without resuming previous native context', async () => {
+        const { workspace, teamRun, members } = await createTeamRunFixture({
+            sessionPolicies: ['new_per_request'],
+        });
+        const previousRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'STARTED',
+            instruction: 'Previous work',
+        });
+        const previousSession = await prisma.session.create({
+            data: {
+                workspaceId: workspace.id,
+                agentType: AgentType.CODEX,
+                providerId: members[0].providerId,
+                prompt: 'previous prompt',
+                status: 'COMPLETED',
+                logSnapshot: JSON.stringify({ sessionId: 'agent-native-session-1', entries: [] }),
+            },
+        });
+        await prisma.agentInvocation.create({
+            data: {
+                teamRunId: teamRun.id,
+                workRequestId: previousRequest.id,
+                memberId: members[0].id,
+                workspaceId: workspace.id,
+                sessionId: previousSession.id,
+                status: 'COMPLETED',
+            },
+        });
+        const nextRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            instruction: 'Fresh request',
+        });
+        const sessionManager = createSessionManagerMock();
+        service = new TeamSchedulerService(lockService, {
+            workspaceService: createWorkspaceServiceMock(),
+            sessionManager,
+            getProviderById: createProviderLookup(),
+        });
+        const invocations = await service.startNextSessions(teamRun.id);
+        expect(invocations).toHaveLength(1);
+        expect(invocations[0]).toMatchObject({
+            workRequestId: nextRequest.id,
+            memberId: members[0].id,
+            sessionId: expect.any(String),
+            status: 'RUNNING',
+        });
+        expect(invocations[0].sessionId).not.toBe(previousSession.id);
+        expect(sessionManager.start).toHaveBeenCalledWith(invocations[0].sessionId);
+        expect(sessionManager.startFollowUp).not.toHaveBeenCalled();
+    });
+    it('does not resume_last from a different member even when native context exists in the same workspace', async () => {
+        const { workspace, teamRun, members } = await createTeamRunFixture({
+            memberCapabilities: [readOnlyCapabilities, readOnlyCapabilities],
+            sessionPolicies: ['resume_last', 'resume_last'],
+        });
+        const otherMemberRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+            status: 'STARTED',
+            instruction: 'Other member previous work',
+        });
+        const otherMemberSession = await prisma.session.create({
+            data: {
+                workspaceId: workspace.id,
+                agentType: AgentType.CODEX,
+                providerId: members[1].providerId,
+                prompt: 'other member prompt',
+                status: 'COMPLETED',
+                logSnapshot: JSON.stringify({ sessionId: 'agent-native-session-2', entries: [] }),
+            },
+        });
+        await prisma.agentInvocation.create({
+            data: {
+                teamRunId: teamRun.id,
+                workRequestId: otherMemberRequest.id,
+                memberId: members[1].id,
+                workspaceId: workspace.id,
+                sessionId: otherMemberSession.id,
+                status: 'COMPLETED',
+            },
+        });
+        const nextRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            instruction: 'Member 1 fresh work',
+        });
+        const sessionManager = createSessionManagerMock();
+        service = new TeamSchedulerService(lockService, {
+            workspaceService: createWorkspaceServiceMock(),
+            sessionManager,
+            getProviderById: createProviderLookup(),
+        });
+        const invocations = await service.startNextSessions(teamRun.id);
+        expect(invocations).toHaveLength(1);
+        expect(invocations[0]).toMatchObject({
+            workRequestId: nextRequest.id,
+            memberId: members[0].id,
+            status: 'RUNNING',
+        });
+        expect(sessionManager.start).toHaveBeenCalledWith(invocations[0].sessionId);
+        expect(sessionManager.startFollowUp).not.toHaveBeenCalled();
+    });
+    it('resume_last only resumes native context from the same member in the selected workspace', async () => {
+        const { task, workspace: selectedWorkspace, teamRun, members } = await createTeamRunFixture({
+            sessionPolicies: ['resume_last'],
+        });
+        const otherWorkspace = await prisma.workspace.create({
+            data: {
+                taskId: task.id,
+                parentWorkspaceId: selectedWorkspace.id,
+                branchName: 'other-workspace',
+                worktreePath: path.join(testDir, 'other-workspace'),
+                status: 'ACTIVE',
+            },
+        });
+        const previousRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'STARTED',
+            instruction: 'Previous work in another workspace',
+        });
+        const otherWorkspaceSession = await prisma.session.create({
+            data: {
+                workspaceId: otherWorkspace.id,
+                agentType: AgentType.CODEX,
+                providerId: members[0].providerId,
+                prompt: 'previous prompt in other workspace',
+                status: 'COMPLETED',
+                logSnapshot: JSON.stringify({ sessionId: 'agent-native-session-other-workspace', entries: [] }),
+                createdAt: new Date(Date.UTC(2026, 0, 1, 0, 0, 0)),
+                updatedAt: new Date(Date.UTC(2026, 0, 1, 0, 0, 0)),
+            },
+        });
+        await prisma.agentInvocation.create({
+            data: {
+                teamRunId: teamRun.id,
+                workRequestId: previousRequest.id,
+                memberId: members[0].id,
+                workspaceId: otherWorkspace.id,
+                sessionId: otherWorkspaceSession.id,
+                status: 'COMPLETED',
+                createdAt: new Date(Date.UTC(2026, 0, 1, 0, 0, 0)),
+                updatedAt: new Date(Date.UTC(2026, 0, 1, 0, 0, 0)),
+            },
+        });
+        const nextRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            instruction: 'Continue in selected workspace',
+        });
+        const sessionManager = createSessionManagerMock();
+        service = new TeamSchedulerService(lockService, {
+            workspaceService: createWorkspaceServiceMock(),
+            sessionManager,
+            getProviderById: createProviderLookup(),
+        });
+        const firstRun = await service.startNextSessions(teamRun.id);
+        expect(firstRun).toHaveLength(1);
+        expect(firstRun[0]).toMatchObject({
+            workRequestId: nextRequest.id,
+            workspaceId: selectedWorkspace.id,
+            status: 'RUNNING',
+        });
+        expect(sessionManager.start).toHaveBeenCalledWith(firstRun[0].sessionId);
+        expect(sessionManager.startFollowUp).not.toHaveBeenCalled();
+        await prisma.session.update({
+            where: { id: firstRun[0].sessionId },
+            data: {
+                status: 'COMPLETED',
+                logSnapshot: JSON.stringify({ sessionId: 'agent-native-session-selected-workspace', entries: [] }),
+            },
+        });
+        await prisma.agentInvocation.update({
+            where: { id: firstRun[0].id },
+            data: { status: 'COMPLETED' },
+        });
+        const followUpRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            instruction: 'Continue again in selected workspace',
+        });
+        sessionManager.start.mockClear();
+        sessionManager.startFollowUp.mockClear();
+        const secondRun = await service.startNextSessions(teamRun.id);
+        expect(secondRun).toHaveLength(1);
+        expect(secondRun[0]).toMatchObject({
+            workRequestId: followUpRequest.id,
+            workspaceId: selectedWorkspace.id,
+            status: 'RUNNING',
+        });
+        expect(sessionManager.startFollowUp).toHaveBeenCalledWith(secondRun[0].sessionId, firstRun[0].sessionId);
+        expect(sessionManager.start).not.toHaveBeenCalled();
+    });
     it('falls back to a normal session start for resume_last members without previous native context', async () => {
         const { teamRun, members } = await createTeamRunFixture({
             sessionPolicies: ['resume_last'],
@@ -998,6 +1375,73 @@ describe('TeamSchedulerService', () => {
             status: 'QUEUED',
         });
     });
+    it('starts none-policy write and command members on the shared workspace without workspace locks', async () => {
+        const { workspace, teamRun, members } = await createTeamRunFixture({
+            memberCapabilities: [
+                { ...writeCapabilities, runCommands: true },
+                writeCapabilities,
+            ],
+            workspacePolicies: ['none', 'shared'],
+        });
+        const noneRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+        });
+        const sharedRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+        });
+        const sessionManager = createSessionManagerMock();
+        service = new TeamSchedulerService(lockService, {
+            workspaceService: createWorkspaceServiceMock(),
+            sessionManager,
+            getProviderById: createProviderLookup(),
+        });
+        const invocations = await service.startNextSessions(teamRun.id);
+        expect(invocations).toHaveLength(2);
+        expect(invocations.map((invocation) => invocation.workspaceId)).toEqual([workspace.id, workspace.id]);
+        expect(new Set(invocations.map((invocation) => invocation.workRequestId))).toEqual(new Set([
+            noneRequest.id,
+            sharedRequest.id,
+        ]));
+        expect(lockService.listLocks()).toEqual([
+            { key: `workspace:task:${teamRun.taskId}:write`, ownerId: invocations[1].id },
+        ]);
+    });
+    it('keeps shared command locks on the stable task key after creating a real workspace', async () => {
+        const { task, teamRun, members } = await createTeamRunFixture({
+            memberCapabilities: [commandCapabilities, commandCapabilities],
+            withWorkspace: false,
+        });
+        const first = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+        });
+        const second = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+        });
+        service = new TeamSchedulerService(lockService, {
+            workspaceService: createWorkspaceServiceMock(),
+            sessionManager: createSessionManagerMock(),
+            getProviderById: createProviderLookup(),
+        });
+        const invocations = await service.startNextSessions(teamRun.id);
+        expect(invocations).toHaveLength(1);
+        expect(invocations[0]).toMatchObject({
+            workRequestId: first.id,
+            workspaceId: expect.any(String),
+            status: 'RUNNING',
+        });
+        expect(lockService.listLocks()).toEqual([
+            { key: `workspace:task:${task.id}:command`, ownerId: invocations[0].id },
+        ]);
+        await expect(prisma.workspace.count({ where: { taskId: task.id, status: 'ACTIVE' } })).resolves.toBe(1);
+        await expect(prisma.workRequest.findUnique({ where: { id: second.id } })).resolves.toMatchObject({
+            status: 'QUEUED',
+        });
+        await expect(service.startNextSessions(teamRun.id)).resolves.toEqual([]);
+    });
     it('keeps shared writer locks on the stable task key after creating a real workspace', async () => {
         const { task, teamRun, members } = await createTeamRunFixture({
             memberCapabilities: [writeCapabilities, writeCapabilities],
@@ -1092,7 +1536,7 @@ describe('TeamSchedulerService', () => {
         expect(new Set(sessions.map((session) => session.workspaceId))).toEqual(new Set([workspaceIds[0]]));
         expect(lockService.listLocks()).toEqual([]);
     });
-    it('fails clearly and leaves no session or lock when a provider is missing', async () => {
+    it('marks a request failed and leaves no session or lock when a provider is missing', async () => {
         const { teamRun, members } = await createTeamRunFixture({
             memberCapabilities: [writeCapabilities],
             withWorkspace: false,
@@ -1108,18 +1552,104 @@ describe('TeamSchedulerService', () => {
             sessionManager,
             getProviderById: vi.fn(() => null),
         });
-        await expect(service.startNextSessions(teamRun.id)).rejects.toMatchObject({
-            code: 'PROVIDER_NOT_FOUND',
-            message: `Provider not found: ${members[0].providerId}`,
-        });
+        await expect(service.startNextSessions(teamRun.id)).resolves.toEqual([]);
         expect(workspaceService.create).not.toHaveBeenCalled();
         expect(sessionManager.create).not.toHaveBeenCalled();
         expect(lockService.listLocks()).toEqual([]);
         await expect(prisma.session.count()).resolves.toBe(0);
-        await expect(prisma.agentInvocation.count()).resolves.toBe(0);
+        await expect(prisma.agentInvocation.findFirst({ where: { workRequestId: request.id } })).resolves.toMatchObject({
+            memberId: members[0].id,
+            sessionId: null,
+            status: 'FAILED',
+        });
         await expect(prisma.workRequest.findUnique({ where: { id: request.id } })).resolves.toMatchObject({
-            status: 'QUEUED',
+            status: 'STARTED',
+        });
+        await expect(service.startNextSessions(teamRun.id)).resolves.toEqual([]);
+    });
+    it('advances an idle TeamRun to review when provider missing failures consume all queued work', async () => {
+        const { task, teamRun, members } = await createTeamRunFixture({
+            memberCapabilities: [writeCapabilities],
+            withWorkspace: false,
+            taskStatus: TaskStatus.IN_PROGRESS,
+        });
+        const request = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+        });
+        service = new TeamSchedulerService(lockService, {
+            workspaceService: createWorkspaceServiceMock(),
+            sessionManager: createSessionManagerMock(),
+            getProviderById: vi.fn(() => null),
+        });
+        await expect(service.startNextSessions(teamRun.id)).resolves.toEqual([]);
+        await expect(prisma.workRequest.findUnique({ where: { id: request.id } })).resolves.toMatchObject({
+            status: 'STARTED',
+        });
+        await expect(prisma.agentInvocation.findFirst({ where: { workRequestId: request.id } })).resolves.toMatchObject({
+            status: 'FAILED',
+            sessionId: null,
+        });
+        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(lockService.listLocks()).toEqual([]);
+    });
+    it('continues starting later queued work when an earlier request has a missing provider', async () => {
+        const { teamRun, members } = await createTeamRunFixture({
+            memberCapabilities: [writeCapabilities, readOnlyCapabilities],
+            withWorkspace: false,
+        });
+        const missingProviderRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+        });
+        const validProviderRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[1].id,
+        });
+        const workspaceService = createWorkspaceServiceMock();
+        const sessionManager = createSessionManagerMock();
+        service = new TeamSchedulerService(lockService, {
+            workspaceService,
+            sessionManager,
+            getProviderById: vi.fn((providerId) => (providerId === members[0].providerId
+                ? null
+                : {
+                    id: providerId,
+                    name: providerId,
+                    agentType: AgentType.CODEX,
+                    env: {},
+                    config: {},
+                    isDefault: false,
+                })),
         });
+        const invocations = await service.startNextSessions(teamRun.id);
+        expect(invocations).toHaveLength(1);
+        expect(invocations[0]).toMatchObject({
+            workRequestId: validProviderRequest.id,
+            memberId: members[1].id,
+            status: 'RUNNING',
+            sessionId: expect.any(String),
+        });
+        await expect(prisma.workRequest.findUnique({ where: { id: missingProviderRequest.id } })).resolves.toMatchObject({
+            status: 'STARTED',
+        });
+        await expect(prisma.agentInvocation.findFirst({
+            where: { workRequestId: missingProviderRequest.id },
+        })).resolves.toMatchObject({
+            memberId: members[0].id,
+            sessionId: null,
+            status: 'FAILED',
+        });
+        await expect(prisma.workRequest.findUnique({ where: { id: validProviderRequest.id } })).resolves.toMatchObject({
+            status: 'STARTED',
+        });
+        expect(sessionManager.create).toHaveBeenCalledTimes(1);
+        expect(lockService.listLocks()).toEqual([]);
     });
     it('marks invocation and session failed and releases locks when session start fails', async () => {
         const { teamRun, members } = await createTeamRunFixture({