agent-tower 0.6.0-beta.11 → 0.6.0-beta.13

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

@@ -8,8 +8,10 @@ import { WorkspaceService } from './workspace.service.js';
 import { appendAttachmentMarkdownContext } from './attachment-context.js';
 import { emitTeamRunInvalidated } from './team-run-events.js';
 import { TeamReconcilerService } from './team-reconciler.service.js';
+import { acquireTeamMemberAdmission } from './team-member-admission-barrier.js';
 import { ensureTaskNotDeleted, isTaskDeleted } from './deleted-task-guard.js';
 import { TEAM_ROOM_SYSTEM_SHARED_PROTOCOL } from '../prompts/team-room-system-shared-protocol.js';
+import { evaluateSessionRuntimeCleanup } from './session-runtime-cleanup-gate.js';
 const ACTIVE_INVOCATION_STATUSES = [
     'QUEUED',
     'RUNNING',
@@ -22,6 +24,7 @@ const STOPPABLE_INVOCATION_STATUSES = [
     'SESSION_ENDED',
     'WAITING_ROOM_REPLY',
 ];
+const TERMINAL_INVOCATION_STATUSES = ['COMPLETED', 'FAILED', 'CANCELLED'];
 const CANCELLABLE_QUEUED_WORK_REQUEST_STATUSES = [
     'PENDING_APPROVAL',
     'QUEUED',
@@ -168,7 +171,6 @@ function serializeTargetSyncStatus(value) {
 }
 export class TeamSchedulerService {
     lockService;
-    static memberSchedulingLocks = new Set();
     static sharedWorkspaceClaims = new Map();
     workspaceService;
     sessionManager;
@@ -183,6 +185,7 @@ export class TeamSchedulerService {
         this.now = dependencies.now ?? (() => new Date());
         this.teamRunReviewAdvancer = dependencies.teamRunReviewAdvancer ?? new TeamReconcilerService({
             eventBus: getEventBus(),
+            sessionMessenger: this.sessionManager,
             scheduler: {
                 releaseInvocationLocks: (invocationId) => this.releaseInvocationLocks(invocationId),
                 startNextSessions: (nextTeamRunId) => this.startNextSessions(nextTeamRunId),
@@ -293,10 +296,7 @@ export class TeamSchedulerService {
             if (!member) {
                 continue;
             }
-            const memberLockKey = this.memberSchedulingLockKey(teamRunId, member.id);
-            if (!this.acquireMemberSchedulingLock(memberLockKey)) {
-                continue;
-            }
+            const releaseMemberSchedulingLock = await acquireTeamMemberAdmission(teamRunId, member.id);
             let invocationId = null;
             try {
                 if (await this.hasActiveInvocation(teamRunId, member.id)) {
@@ -332,7 +332,7 @@ export class TeamSchedulerService {
                 throw error;
             }
             finally {
-                this.releaseMemberSchedulingLock(memberLockKey);
+                releaseMemberSchedulingLock();
             }
         }
         return startedInvocations;
@@ -357,10 +357,7 @@ export class TeamSchedulerService {
                 retryBlockedMemberIds.add(member.id);
                 continue;
             }
-            const memberLockKey = this.memberSchedulingLockKey(teamRunId, member.id);
-            if (!this.acquireMemberSchedulingLock(memberLockKey)) {
-                continue;
-            }
+            const releaseMemberSchedulingLock = await acquireTeamMemberAdmission(teamRunId, member.id);
             let invocationId = null;
             try {
                 if (await this.hasActiveInvocation(teamRunId, member.id)) {
@@ -457,6 +454,15 @@ export class TeamSchedulerService {
                     invocationId = null;
                     continue;
                 }
+                // A stop/cancel can win after the initial queue claim but before the
+                // expensive provider/session spawn. Recheck the authoritative DB state
+                // immediately before crossing into the process-owning SessionManager.
+                if (!(await this.isInvocationAdmitted(createdInvocation.id, freshWorkRequest.id))) {
+                    await this.cancelUnadmittedInvocation(createdInvocation.id, session.id);
+                    this.lockService.releaseByOwner(invocationId);
+                    invocationId = null;
+                    continue;
+                }
                 const resumeFromSessionId = await this.findResumeSourceSessionId(member, session.id, workspace.id, target?.targetHeadSha ?? null);
                 try {
                     if (resumeFromSessionId && this.sessionManager.startFollowUp) {
@@ -467,12 +473,19 @@ export class TeamSchedulerService {
                     }
                 }
                 catch (error) {
+                    if (error instanceof ServiceError && error.code === 'SESSION_NOT_ADMITTED') {
+                        await this.cancelUnadmittedInvocation(createdInvocation.id, session.id);
+                        this.lockService.releaseByOwner(invocationId);
+                        invocationId = null;
+                        continue;
+                    }
                     const failureResult = await this.markInvocationStartFailed(createdInvocation.id, session.id, error);
-                    this.lockService.releaseByOwner(createdInvocation.id);
                     if (failureResult === 'terminal') {
+                        this.lockService.releaseByOwner(createdInvocation.id);
                         createdTerminalInvocation = true;
                     }
                     else if (failureResult === 'retry') {
+                        this.lockService.releaseByOwner(createdInvocation.id);
                         retryBlockedMemberIds.add(member.id);
                     }
                     await this.emitTeamRunInvalidated(context.teamRun, ['work-requests', 'agent-invocations'], 'agent-invocation-updated');
@@ -502,7 +515,7 @@ export class TeamSchedulerService {
                 }
             }
             finally {
-                this.releaseMemberSchedulingLock(memberLockKey);
+                releaseMemberSchedulingLock();
             }
         }
         if (createdTerminalInvocation) {
@@ -582,49 +595,67 @@ export class TeamSchedulerService {
         return workRequest;
     }
     async stopMemberWork(teamRunId, memberId, options = {}) {
-        await this.getTeamMemberOrThrow(teamRunId, memberId);
-        const activeInvocations = await prisma.agentInvocation.findMany({
-            where: {
-                teamRunId,
-                memberId,
-                status: { in: STOPPABLE_INVOCATION_STATUSES },
-            },
-            orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
-        });
         const stoppedSessionIds = [];
-        const queuedInvocationIds = activeInvocations
-            .filter((invocation) => invocation.sessionId == null)
-            .map((invocation) => invocation.id);
-        const queuedCancellation = queuedInvocationIds.length > 0
-            ? await this.cancelInvocationsWithoutSession(queuedInvocationIds)
-            : { cancelledInvocationIds: [], cancelledWorkRequestIds: [] };
-        if (options.cancelQueued) {
-            const cancelledQueuedRequestIds = await this.cancelQueuedWorkRequestsForMember(teamRunId, memberId);
-            queuedCancellation.cancelledWorkRequestIds.push(...cancelledQueuedRequestIds);
-        }
-        const sessionIds = activeInvocations
-            .map((invocation) => invocation.sessionId)
-            .filter((sessionId) => sessionId != null);
-        if (sessionIds.length > 0) {
-            if (!this.sessionManager.stop) {
-                throw new ServiceError('Session stop is not available', 'SESSION_STOP_UNAVAILABLE', 500);
+        const queuedCancellation = {
+            cancelledInvocationIds: [],
+            cancelledWorkRequestIds: [],
+        };
+        let shouldStartNextForQueuedOnly = false;
+        let hadActiveInvocations = false;
+        const releaseMemberSchedulingLock = await acquireTeamMemberAdmission(teamRunId, memberId);
+        try {
+            // Re-read all admission state after acquiring the same barrier used by
+            // startNextSessions. A DB cancellation observed before this point must
+            // not be followed by a stale process stop/start decision.
+            await this.getTeamMemberOrThrow(teamRunId, memberId);
+            const stopAdmission = await this.establishMemberStopAdmissionGate(teamRunId, memberId, options.cancelQueued === true);
+            const activeInvocations = stopAdmission.activeInvocations;
+            hadActiveInvocations = activeInvocations.length > 0;
+            queuedCancellation.cancelledInvocationIds.push(...stopAdmission.cancelledInvocationIds);
+            queuedCancellation.cancelledWorkRequestIds.push(...stopAdmission.cancelledWorkRequestIds);
+            for (const invocationId of stopAdmission.cancelledInvocationIds) {
+                this.releaseInvocationLocks(invocationId);
             }
-            for (const sessionId of sessionIds) {
-                const stopped = await this.sessionManager.stop(sessionId);
-                if (stopped) {
-                    stoppedSessionIds.push(sessionId);
+            const sessionIds = activeInvocations
+                .map((invocation) => invocation.sessionId)
+                .filter((sessionId) => sessionId != null);
+            if (sessionIds.length > 0) {
+                if (!this.sessionManager.stop) {
+                    throw new ServiceError('Session stop is not available', 'SESSION_STOP_UNAVAILABLE', 500);
+                }
+                for (const sessionId of sessionIds) {
+                    // SessionManager.stop normally reconciles TeamRun immediately. The
+                    // scheduler already owns the member barrier here, so defer that
+                    // reconciliation until after the barrier is released below.
+                    const stopped = await this.sessionManager.stop(sessionId, { skipTeamRunReconcile: true });
+                    if (stopped) {
+                        stoppedSessionIds.push(sessionId);
+                    }
                 }
             }
+            const cancelledWorkRequestIds = Array.from(new Set(queuedCancellation.cancelledWorkRequestIds));
+            shouldStartNextForQueuedOnly = !hadActiveInvocations && (queuedCancellation.cancelledInvocationIds.length > 0
+                || cancelledWorkRequestIds.length > 0);
+        }
+        finally {
+            // Never call startNextSessions recursively while holding this barrier.
+            releaseMemberSchedulingLock();
         }
         const cancelledWorkRequestIds = Array.from(new Set(queuedCancellation.cancelledWorkRequestIds));
-        const shouldStartNext = stoppedSessionIds.length > 0
+        const startedInvocations = [];
+        for (const sessionId of stoppedSessionIds) {
+            startedInvocations.push(...await (this.teamRunReviewAdvancer.handleSessionStopped?.(sessionId) ?? Promise.resolve([])));
+        }
+        if (shouldStartNextForQueuedOnly) {
+            startedInvocations.push(...await this.startNextSessions(teamRunId));
+        }
+        if (stoppedSessionIds.length > 0
             || queuedCancellation.cancelledInvocationIds.length > 0
-            || cancelledWorkRequestIds.length > 0;
-        const startedInvocations = shouldStartNext
-            ? await this.startNextSessions(teamRunId)
-            : [];
-        if (shouldStartNext) {
+            || cancelledWorkRequestIds.length > 0) {
             await this.emitTeamRunInvalidatedById(teamRunId, ['work-requests', 'agent-invocations', 'team-run'], 'member-work-stopped');
+            if (shouldStartNextForQueuedOnly) {
+                await this.teamRunReviewAdvancer.maybeAdvanceTeamRunToReview(teamRunId);
+            }
         }
         return {
             stoppedSessionIds,
@@ -633,6 +664,59 @@ export class TeamSchedulerService {
             startedInvocations,
         };
     }
+    async stopSession(sessionId) {
+        const invocation = await prisma.agentInvocation.findFirst({
+            where: { sessionId },
+            select: { id: true, teamRunId: true, memberId: true, status: true },
+        });
+        if (!invocation) {
+            return this.sessionManager.stop?.(sessionId) ?? null;
+        }
+        const releaseMemberSchedulingLock = await acquireTeamMemberAdmission(invocation.teamRunId, invocation.memberId);
+        let stopped = null;
+        let shouldReconcileStop = false;
+        try {
+            const revoked = await prisma.agentInvocation.updateMany({
+                where: {
+                    id: invocation.id,
+                    sessionId,
+                    status: { in: STOPPABLE_INVOCATION_STATUSES },
+                },
+                data: {
+                    dispatchRevokedAt: this.now(),
+                    nextRoomReplyReminderAt: null,
+                },
+            });
+            if (revoked.count === 0) {
+                const currentInvocation = await prisma.agentInvocation.findUnique({
+                    where: { id: invocation.id },
+                    select: { status: true },
+                });
+                if (currentInvocation
+                    && TERMINAL_INVOCATION_STATUSES.includes(currentInvocation.status)) {
+                    stopped = await this.sessionManager.stop?.(sessionId, { skipTeamRunReconcile: true }) ?? null;
+                    shouldReconcileStop = stopped != null;
+                }
+            }
+            if (revoked.count > 0 && !this.sessionManager.stop) {
+                throw new ServiceError('Session stop is not available', 'SESSION_STOP_UNAVAILABLE', 500);
+            }
+            if (revoked.count > 0) {
+                stopped = await this.sessionManager.stop(sessionId, { skipTeamRunReconcile: true });
+            }
+            if (revoked.count > 0 && stopped) {
+                shouldReconcileStop = true;
+            }
+        }
+        finally {
+            releaseMemberSchedulingLock();
+        }
+        if (shouldReconcileStop) {
+            await this.teamRunReviewAdvancer.handleSessionStopped?.(sessionId);
+            await this.emitTeamRunInvalidatedById(invocation.teamRunId, ['work-requests', 'agent-invocations', 'team-run'], 'member-work-stopped');
+        }
+        return stopped;
+    }
     releaseInvocationLocks(invocationId) {
         this.lockService.releaseByOwner(invocationId);
     }
@@ -749,6 +833,17 @@ export class TeamSchedulerService {
     }
     async createRunningInvocationForClaimedWorkRequest(teamRun, member, workRequest, invocationId, workspaceId, sessionId, targetStartData = {}) {
         return prisma.$transaction(async (tx) => {
+            const session = await tx.session.findUnique({
+                where: { id: sessionId },
+                select: { status: true },
+            });
+            if (!session || session.status !== 'PENDING') {
+                await tx.workRequest.updateMany({
+                    where: { id: workRequest.id, teamRunId: teamRun.id, status: 'QUEUED' },
+                    data: { status: 'CANCELLED' },
+                });
+                return null;
+            }
             const claimed = await tx.workRequest.updateMany({
                 where: {
                     id: workRequest.id,
@@ -1002,71 +1097,74 @@ export class TeamSchedulerService {
         }
         return this.serializeWorkRequest(updated);
     }
-    async cancelInvocationsWithoutSession(invocationIds) {
-        if (invocationIds.length === 0) {
-            return { cancelledInvocationIds: [], cancelledWorkRequestIds: [] };
-        }
-        const cancelled = await prisma.$transaction(async (tx) => {
-            const invocations = await tx.agentInvocation.findMany({
+    async establishMemberStopAdmissionGate(teamRunId, memberId, cancelQueued) {
+        return prisma.$transaction(async (tx) => {
+            const activeInvocations = await tx.agentInvocation.findMany({
                 where: {
-                    id: { in: invocationIds },
-                    sessionId: null,
+                    teamRunId,
+                    memberId,
                     status: { in: STOPPABLE_INVOCATION_STATUSES },
                 },
-                select: { id: true, workRequestId: true },
+                orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
             });
-            if (invocations.length === 0) {
-                return { invocationIds: [], workRequestIds: [] };
+            const now = this.now();
+            const sessionInvocations = activeInvocations.filter((invocation) => invocation.sessionId != null);
+            const noSessionInvocations = activeInvocations.filter((invocation) => invocation.sessionId == null);
+            if (activeInvocations.length > 0) {
+                await tx.agentInvocation.updateMany({
+                    where: {
+                        id: { in: activeInvocations.map((invocation) => invocation.id) },
+                        status: { in: STOPPABLE_INVOCATION_STATUSES },
+                    },
+                    data: {
+                        dispatchRevokedAt: now,
+                        nextRoomReplyReminderAt: null,
+                    },
+                });
+            }
+            const cancelledInvocationIds = noSessionInvocations.map((invocation) => invocation.id);
+            const noSessionWorkRequestIds = noSessionInvocations.map((invocation) => invocation.workRequestId);
+            if (cancelledInvocationIds.length > 0) {
+                await tx.agentInvocation.updateMany({
+                    where: { id: { in: cancelledInvocationIds }, status: { in: STOPPABLE_INVOCATION_STATUSES } },
+                    data: { status: 'CANCELLED' },
+                });
+                await tx.workRequest.updateMany({
+                    where: {
+                        id: { in: noSessionWorkRequestIds },
+                        status: { in: ['PENDING_APPROVAL', 'QUEUED', 'STARTED'] },
+                    },
+                    data: { status: 'CANCELLED' },
+                });
+            }
+            const queuedWorkRequests = cancelQueued
+                ? await tx.workRequest.findMany({
+                    where: {
+                        teamRunId,
+                        targetMemberId: memberId,
+                        status: { in: CANCELLABLE_QUEUED_WORK_REQUEST_STATUSES },
+                    },
+                    select: { id: true },
+                })
+                : [];
+            if (queuedWorkRequests.length > 0) {
+                await tx.workRequest.updateMany({
+                    where: {
+                        id: { in: queuedWorkRequests.map((workRequest) => workRequest.id) },
+                        status: { in: CANCELLABLE_QUEUED_WORK_REQUEST_STATUSES },
+                    },
+                    data: { status: 'CANCELLED' },
+                });
             }
-            const cancellableWorkRequestIds = invocations.map((invocation) => invocation.workRequestId);
-            await tx.agentInvocation.updateMany({
-                where: { id: { in: invocations.map((invocation) => invocation.id) } },
-                data: {
-                    status: 'CANCELLED',
-                    nextRoomReplyReminderAt: null,
-                },
-            });
-            await tx.workRequest.updateMany({
-                where: {
-                    id: { in: cancellableWorkRequestIds },
-                    status: { in: ['PENDING_APPROVAL', 'QUEUED', 'STARTED'] },
-                },
-                data: { status: 'CANCELLED' },
-            });
             return {
-                invocationIds: invocations.map((invocation) => invocation.id),
-                workRequestIds: cancellableWorkRequestIds,
+                activeInvocations: sessionInvocations,
+                cancelledInvocationIds,
+                cancelledWorkRequestIds: [
+                    ...noSessionWorkRequestIds,
+                    ...queuedWorkRequests.map((workRequest) => workRequest.id),
+                ],
             };
         });
-        for (const invocationId of cancelled.invocationIds) {
-            this.releaseInvocationLocks(invocationId);
-        }
-        return {
-            cancelledInvocationIds: cancelled.invocationIds,
-            cancelledWorkRequestIds: cancelled.workRequestIds,
-        };
-    }
-    async cancelQueuedWorkRequestsForMember(teamRunId, memberId) {
-        const workRequests = await prisma.workRequest.findMany({
-            where: {
-                teamRunId,
-                targetMemberId: memberId,
-                status: { in: CANCELLABLE_QUEUED_WORK_REQUEST_STATUSES },
-            },
-            select: { id: true },
-        });
-        if (workRequests.length === 0) {
-            return [];
-        }
-        const workRequestIds = workRequests.map((workRequest) => workRequest.id);
-        await prisma.workRequest.updateMany({
-            where: {
-                id: { in: workRequestIds },
-                status: { in: CANCELLABLE_QUEUED_WORK_REQUEST_STATUSES },
-            },
-            data: { status: 'CANCELLED' },
-        });
-        return workRequestIds;
     }
     async findActiveMemberIds(teamRunId) {
         const activeInvocations = await prisma.agentInvocation.findMany({
@@ -1086,7 +1184,50 @@ export class TeamSchedulerService {
                 status: { in: ACTIVE_INVOCATION_STATUSES },
             },
         });
-        return count > 0;
+        if (count > 0)
+            return true;
+        // A terminal DB status is not enough to admit the next WorkRequest when
+        // the owned ACP tree still needs cleanup. The cleanup callback updates
+        // this metadata only after the OS tree has been confirmed gone.
+        const terminalInvocations = await prisma.agentInvocation.findMany({
+            where: {
+                teamRunId,
+                memberId,
+                status: { in: TERMINAL_INVOCATION_STATUSES },
+                sessionId: { not: null },
+            },
+            select: { sessionId: true, workRequestId: true },
+        });
+        if (terminalInvocations.length === 0)
+            return false;
+        const terminalWorkRequests = await prisma.workRequest.findMany({
+            where: { id: { in: terminalInvocations.map((invocation) => invocation.workRequestId) } },
+            select: { id: true, status: true },
+        });
+        const workRequestStatusById = new Map(terminalWorkRequests.map((workRequest) => [workRequest.id, workRequest.status]));
+        for (const invocation of terminalInvocations) {
+            // STARTED is the durable after-terminal winner. Until the reconciler
+            // consumes it, locks/queue admission remain blocked even if cleanup has
+            // just become confirmable.
+            if (workRequestStatusById.get(invocation.workRequestId) === 'STARTED')
+                return true;
+            const sessionId = invocation.sessionId;
+            if (!sessionId)
+                continue;
+            const cleanupConfirmed = this.sessionManager.isRuntimeCleanupConfirmed
+                ? await this.sessionManager.isRuntimeCleanupConfirmed(sessionId)
+                : (await evaluateSessionRuntimeCleanup(sessionId, {
+                    hasActiveTurn: this.sessionManager.hasActiveTurn
+                        ? (candidateId) => this.sessionManager.hasActiveTurn(candidateId)
+                        : undefined,
+                    hasRuntimeProcessOwner: this.sessionManager.hasRuntimeProcessOwner
+                        ? (runtimeInstanceId) => this.sessionManager.hasRuntimeProcessOwner(runtimeInstanceId)
+                        : undefined,
+                }, this.now())).confirmed;
+            if (!cleanupConfirmed)
+                return true;
+        }
+        return false;
     }
     async getOrCreateWorkspaceForMember(teamRun, member) {
         if (member.workspacePolicy === 'dedicated') {
@@ -1214,6 +1355,38 @@ export class TeamSchedulerService {
         return previousInvocation.sessionId;
     }
     async markInvocationStartFailed(invocationId, sessionId, error) {
+        const cleanupConfirmed = this.sessionManager.isRuntimeCleanupConfirmed
+            ? await this.sessionManager.isRuntimeCleanupConfirmed(sessionId)
+            : (await evaluateSessionRuntimeCleanup(sessionId, {
+                hasActiveTurn: this.sessionManager.hasActiveTurn
+                    ? (candidateId) => this.sessionManager.hasActiveTurn(candidateId)
+                    : undefined,
+                hasRuntimeProcessOwner: this.sessionManager.hasRuntimeProcessOwner
+                    ? (runtimeInstanceId) => this.sessionManager.hasRuntimeProcessOwner(runtimeInstanceId)
+                    : undefined,
+            }, this.now())).confirmed;
+        if (!cleanupConfirmed) {
+            await prisma.$transaction(async (tx) => {
+                const invocation = await tx.agentInvocation.findUnique({
+                    where: { id: invocationId },
+                    select: { workRequestId: true },
+                });
+                if (!invocation)
+                    return;
+                await tx.agentInvocation.updateMany({
+                    where: { id: invocationId, status: 'RUNNING' },
+                    data: { dispatchRevokedAt: this.now(), nextRoomReplyReminderAt: null },
+                });
+                await tx.workRequest.updateMany({
+                    where: { id: invocation.workRequestId, status: 'STARTED' },
+                    data: {
+                        lastStartError: startErrorMessage(error),
+                        nextStartRetryAt: null,
+                    },
+                });
+            });
+            return 'pending';
+        }
         return prisma.$transaction(async (tx) => {
             const invocation = await tx.agentInvocation.findUnique({
                 where: { id: invocationId },
@@ -1272,11 +1445,53 @@ export class TeamSchedulerService {
         await emitTeamRunInvalidated({ teamRunId, scopes, reason });
     }
     async markSessionFailed(sessionId) {
-        await prisma.session.update({
-            where: { id: sessionId },
+        await prisma.session.updateMany({
+            where: { id: sessionId, status: 'PENDING' },
             data: { status: 'FAILED' },
         });
     }
+    async isInvocationAdmitted(invocationId, workRequestId) {
+        const state = await prisma.agentInvocation.findUnique({
+            where: { id: invocationId },
+            select: { status: true, workRequestId: true, dispatchRevokedAt: true, sessionId: true },
+        });
+        if (!state)
+            return false;
+        const workRequest = await prisma.workRequest.findUnique({
+            where: { id: state.workRequestId },
+            select: { id: true, status: true },
+        });
+        const session = state.sessionId
+            ? await prisma.session.findUnique({ where: { id: state.sessionId }, select: { status: true } })
+            : null;
+        return state.status === 'RUNNING'
+            && state.dispatchRevokedAt == null
+            && session?.status === 'PENDING'
+            && workRequest?.id === workRequestId
+            && workRequest.status === 'STARTED';
+    }
+    async cancelUnadmittedInvocation(invocationId, sessionId) {
+        const cancelled = await prisma.agentInvocation.updateMany({
+            where: { id: invocationId, status: 'RUNNING' },
+            data: { status: 'CANCELLED', nextRoomReplyReminderAt: null },
+        });
+        if (cancelled.count !== 1)
+            return;
+        const invocation = await prisma.agentInvocation.findUnique({
+            where: { id: invocationId },
+            select: { workRequestId: true },
+        });
+        if (invocation) {
+            await prisma.workRequest.updateMany({
+                where: { id: invocation.workRequestId, status: 'STARTED' },
+                data: { status: 'CANCELLED' },
+            });
+        }
+        await prisma.session.updateMany({
+            where: { id: sessionId, status: 'PENDING' },
+            data: { status: 'CANCELLED' },
+        });
+    }
     getRequiredLocks(teamRun, member) {
         const request = {
             teamRunId: teamRun.id,
@@ -1302,19 +1517,6 @@ export class TeamSchedulerService {
         }
         return `task:${teamRun.taskId}`;
     }
-    memberSchedulingLockKey(teamRunId, memberId) {
-        return `scheduling:${teamRunId}:member:${memberId}`;
-    }
-    acquireMemberSchedulingLock(lockKey) {
-        if (TeamSchedulerService.memberSchedulingLocks.has(lockKey)) {
-            return false;
-        }
-        TeamSchedulerService.memberSchedulingLocks.add(lockKey);
-        return true;
-    }
-    releaseMemberSchedulingLock(lockKey) {
-        TeamSchedulerService.memberSchedulingLocks.delete(lockKey);
-    }
     serializeWorkRequest(workRequest) {
         return {
             ...workRequest,
@@ -1342,6 +1544,7 @@ export class TeamSchedulerService {
                 : null,
             lastHeartbeatAt: invocation.lastHeartbeatAt ? toIso(invocation.lastHeartbeatAt) : null,
             firstNudgeAt: invocation.firstNudgeAt ? toIso(invocation.firstNudgeAt) : null,
+            dispatchRevokedAt: invocation.dispatchRevokedAt ? toIso(invocation.dispatchRevokedAt) : null,
         };
     }
 }