devchain-cli 0.11.5 → 0.12.0

package/dist/server/modules/teams/services/teams.service.js

@@ -0,0 +1,748 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamsService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const error_types_1 = require("../../../common/errors/error-types");
+const sessions_service_1 = require("../../sessions/services/sessions.service");
+const storage_interface_1 = require("../../storage/interfaces/storage.interface");
+const teams_store_1 = require("../storage/teams.store");
+const events_service_1 = require("../../events/services/events.service");
+const logger_1 = require("../../../common/logging/logger");
+const logger = (0, logger_1.createLogger)('TeamsService');
+let TeamsService = class TeamsService {
+    constructor(teamsStore, storage, moduleRef, eventsService) {
+        this.teamsStore = teamsStore;
+        this.storage = storage;
+        this.moduleRef = moduleRef;
+        this.eventsService = eventsService;
+    }
+    getSessionsService() {
+        if (!this.sessionsServiceRef) {
+            this.sessionsServiceRef = this.moduleRef.get(sessions_service_1.SessionsService, { strict: false });
+        }
+        return this.sessionsServiceRef;
+    }
+    async createTeam(data) {
+        const uniqueMembers = [...new Set(data.memberAgentIds)];
+        const uniqueProfileIds = data.profileIds ? [...new Set(data.profileIds)] : undefined;
+        const teamLeadAgentId = data.teamLeadAgentId ?? null;
+        if (uniqueMembers.length < 1) {
+            throw new error_types_1.ValidationError('A team must have at least 1 member');
+        }
+        if (teamLeadAgentId !== null && !uniqueMembers.includes(teamLeadAgentId)) {
+            throw new error_types_1.ValidationError('Team lead must be included in the members list');
+        }
+        await this.validateAgentsInProject(data.projectId, uniqueMembers);
+        if (uniqueProfileIds && uniqueProfileIds.length > 0) {
+            await this.validateProfilesInProject(data.projectId, uniqueProfileIds);
+        }
+        const dedupedSelections = this.dedupeProfileConfigSelections(data.profileConfigSelections);
+        if (dedupedSelections && dedupedSelections.length > 0) {
+            const effectiveProfileIds = uniqueProfileIds ?? [];
+            this.validateSelectionsAgainstProfiles(dedupedSelections, effectiveProfileIds);
+            await this.validateConfigProfileConsistency(dedupedSelections);
+        }
+        const filteredSelections = dedupedSelections?.filter((s) => s.configIds.length > 0);
+        const effectiveMaxMembers = data.maxMembers ?? 5;
+        const effectiveMaxConcurrentTasks = data.maxConcurrentTasks ?? effectiveMaxMembers;
+        if (effectiveMaxConcurrentTasks > effectiveMaxMembers) {
+            throw new error_types_1.ValidationError('maxConcurrentTasks cannot exceed maxMembers');
+        }
+        const nonLeadCount = uniqueMembers.filter((id) => id !== teamLeadAgentId).length;
+        if (nonLeadCount > effectiveMaxMembers) {
+            throw new error_types_1.ValidationError('Initial team exceeds maxMembers');
+        }
+        return this.teamsStore.createTeam({
+            ...data,
+            teamLeadAgentId,
+            maxMembers: effectiveMaxMembers,
+            maxConcurrentTasks: effectiveMaxConcurrentTasks,
+            memberAgentIds: uniqueMembers,
+            profileIds: uniqueProfileIds,
+            profileConfigSelections: filteredSelections,
+        });
+    }
+    async getTeam(id) {
+        return this.teamsStore.getTeam(id);
+    }
+    async listTeams(projectId, options) {
+        const result = await this.teamsStore.listTeams(projectId, options);
+        const agentsResult = await this.storage.listAgents(projectId, {
+            limit: 1000,
+        });
+        const agentNameMap = new Map(agentsResult.items.map((a) => [a.id, a.name]));
+        return {
+            ...result,
+            items: result.items.map((team) => ({
+                ...team,
+                teamLeadAgentName: team.teamLeadAgentId
+                    ? (agentNameMap.get(team.teamLeadAgentId) ?? null)
+                    : null,
+            })),
+        };
+    }
+    async findTeamByExactName(projectId, name) {
+        return this.teamsStore.findTeamByExactName(projectId, name.trim());
+    }
+    async updateTeam(id, data) {
+        const current = await this.teamsStore.getTeam(id);
+        if (!current) {
+            const { NotFoundError } = await Promise.resolve().then(() => __importStar(require('../../../common/errors/error-types')));
+            throw new NotFoundError('Team', id);
+        }
+        const dedupedMembers = data.memberAgentIds ? [...new Set(data.memberAgentIds)] : undefined;
+        const dedupedProfileIds = data.profileIds ? [...new Set(data.profileIds)] : undefined;
+        const effectiveMembers = dedupedMembers ?? current.members.map((m) => m.agentId);
+        const effectiveLead = data.teamLeadAgentId !== undefined ? data.teamLeadAgentId : current.teamLeadAgentId;
+        if (dedupedMembers !== undefined && effectiveMembers.length < 1) {
+            throw new error_types_1.ValidationError('A team must have at least 1 member');
+        }
+        if (effectiveLead !== null && !effectiveMembers.includes(effectiveLead)) {
+            throw new error_types_1.ValidationError('Team lead must be included in the members list');
+        }
+        if (dedupedMembers !== undefined) {
+            await this.validateAgentsInProject(current.projectId, effectiveMembers);
+        }
+        else if (data.teamLeadAgentId !== undefined && effectiveLead !== null) {
+            await this.validateAgentsInProject(current.projectId, [effectiveLead]);
+        }
+        if (dedupedProfileIds !== undefined && dedupedProfileIds.length > 0) {
+            await this.validateProfilesInProject(current.projectId, dedupedProfileIds);
+        }
+        const dedupedSelections = this.dedupeProfileConfigSelections(data.profileConfigSelections);
+        if (dedupedSelections && dedupedSelections.length > 0) {
+            const effectiveProfileIds = dedupedProfileIds ?? current.profileIds;
+            this.validateSelectionsAgainstProfiles(dedupedSelections, effectiveProfileIds);
+            await this.validateConfigProfileConsistency(dedupedSelections);
+        }
+        const filteredSelections = dedupedSelections !== undefined
+            ? dedupedSelections.filter((s) => s.configIds.length > 0)
+            : undefined;
+        const eMM = data.maxMembers ?? current.maxMembers;
+        const eMCT = data.maxConcurrentTasks ?? current.maxConcurrentTasks;
+        if (eMCT > eMM) {
+            throw new error_types_1.ValidationError('maxConcurrentTasks cannot exceed maxMembers');
+        }
+        if (dedupedMembers !== undefined ||
+            data.teamLeadAgentId !== undefined ||
+            data.maxMembers !== undefined) {
+            const finalNonLeadCount = effectiveMembers.filter((mid) => mid !== effectiveLead).length;
+            if (finalNonLeadCount > eMM) {
+                throw new error_types_1.ValidationError('Team member count exceeds maxMembers');
+            }
+        }
+        const storeData = dedupedMembers !== undefined
+            ? {
+                ...data,
+                memberAgentIds: dedupedMembers,
+                profileIds: dedupedProfileIds,
+                profileConfigSelections: filteredSelections,
+            }
+            : { ...data, profileIds: dedupedProfileIds, profileConfigSelections: filteredSelections };
+        const previousMaxMembers = current.maxMembers;
+        const previousMaxConcurrentTasks = current.maxConcurrentTasks;
+        const previousAllowTeamLeadCreateAgents = current.allowTeamLeadCreateAgents;
+        const result = await this.teamsStore.updateTeam(id, storeData);
+        if (result.maxMembers !== previousMaxMembers ||
+            result.maxConcurrentTasks !== previousMaxConcurrentTasks ||
+            result.allowTeamLeadCreateAgents !== previousAllowTeamLeadCreateAgents) {
+            try {
+                await this.eventsService?.publish('team.config.updated', {
+                    teamId: id,
+                    projectId: current.projectId,
+                    teamLeadAgentId: result.teamLeadAgentId,
+                    teamName: result.name,
+                    previous: {
+                        maxMembers: previousMaxMembers,
+                        maxConcurrentTasks: previousMaxConcurrentTasks,
+                        allowTeamLeadCreateAgents: previousAllowTeamLeadCreateAgents,
+                    },
+                    current: {
+                        maxMembers: result.maxMembers,
+                        maxConcurrentTasks: result.maxConcurrentTasks,
+                        allowTeamLeadCreateAgents: result.allowTeamLeadCreateAgents,
+                    },
+                });
+            }
+            catch {
+            }
+        }
+        if (dedupedMembers !== undefined) {
+            const previousMemberIds = new Set(current.members.map((m) => m.agentId));
+            const nextMemberIds = new Set(dedupedMembers);
+            const addedAgentIds = [...nextMemberIds].filter((aid) => !previousMemberIds.has(aid));
+            const removedAgentIds = [...previousMemberIds].filter((aid) => !nextMemberIds.has(aid));
+            for (const agentId of addedAgentIds) {
+                try {
+                    const agent = await this.storage.getAgent(agentId).catch(() => null);
+                    await this.eventsService?.publish('team.member.added', {
+                        teamId: id,
+                        projectId: current.projectId,
+                        teamLeadAgentId: result.teamLeadAgentId,
+                        teamName: result.name,
+                        addedAgentId: agentId,
+                        addedAgentName: agent?.name ?? null,
+                    });
+                }
+                catch {
+                }
+            }
+            for (const agentId of removedAgentIds) {
+                try {
+                    const agent = await this.storage.getAgent(agentId).catch(() => null);
+                    await this.eventsService?.publish('team.member.removed', {
+                        teamId: id,
+                        projectId: current.projectId,
+                        teamLeadAgentId: result.teamLeadAgentId,
+                        teamName: result.name,
+                        removedAgentId: agentId,
+                        removedAgentName: agent?.name ?? null,
+                    });
+                }
+                catch {
+                }
+            }
+        }
+        return result;
+    }
+    async disbandTeam(id) {
+        return this.teamsStore.deleteTeam(id);
+    }
+    async deleteTeamsByProject(projectId) {
+        return this.teamsStore.deleteTeamsByProject(projectId);
+    }
+    async deleteTeamsByIds(ids) {
+        if (!ids || ids.length === 0)
+            return;
+        return this.teamsStore.deleteTeamsByIds(ids);
+    }
+    async listTeamsByAgent(agentId) {
+        return this.teamsStore.listTeamsByAgent(agentId);
+    }
+    async countBusyTeamMembers(teamId, teamLeadAgentId) {
+        return this.teamsStore.countBusyTeamMembers(teamId, teamLeadAgentId);
+    }
+    async canDeleteAgent(agentId) {
+        const leadTeams = await this.teamsStore.getTeamLeadTeams(agentId);
+        return {
+            canDelete: true,
+            blockingTeams: leadTeams.map((t) => t.name),
+        };
+    }
+    async listConfigsVisibleToLead(leadAgentId, projectId) {
+        const ledTeams = await this.teamsStore.getTeamLeadTeams(leadAgentId);
+        const projectTeams = ledTeams.filter((t) => t.projectId === projectId);
+        if (projectTeams.length === 0) {
+            return {
+                error: {
+                    code: 'FORBIDDEN_NOT_TEAM_LEAD',
+                    message: 'You do not lead any teams in this project',
+                },
+            };
+        }
+        const seen = new Set();
+        const configs = [];
+        for (const team of projectTeams) {
+            const teamConfigs = await this.teamsStore.listConfigsForTeam(team.id);
+            for (const config of teamConfigs) {
+                const profile = await this.storage.getAgentProfile(config.profileId);
+                const key = `${config.name.trim().toLowerCase()}|${profile.name.trim().toLowerCase()}|${team.name.trim().toLowerCase()}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    configs.push({
+                        configName: config.name,
+                        description: config.description,
+                        profileName: profile.name,
+                        teamName: team.name,
+                    });
+                }
+            }
+        }
+        return configs;
+    }
+    async resolveLedTeam(leadAgentId, projectId, teamName) {
+        const ledTeams = await this.teamsStore.getTeamLeadTeams(leadAgentId);
+        const projectTeams = ledTeams.filter((t) => t.projectId === projectId);
+        if (projectTeams.length === 0) {
+            return {
+                error: {
+                    code: 'FORBIDDEN_NOT_TEAM_LEAD',
+                    message: 'You do not lead any teams in this project',
+                },
+            };
+        }
+        if (teamName) {
+            const trimmedName = teamName.trim().toLowerCase();
+            const matches = projectTeams.filter((t) => t.name.trim().toLowerCase() === trimmedName);
+            if (matches.length === 0) {
+                return {
+                    error: {
+                        code: 'TEAM_NOT_FOUND_OR_NOT_LED',
+                        message: `No team named "${teamName}" found among teams you lead`,
+                    },
+                };
+            }
+            return { team: matches[0] };
+        }
+        if (projectTeams.length === 1) {
+            return { team: projectTeams[0] };
+        }
+        return {
+            error: {
+                code: 'AMBIGUOUS_TEAM_LEAD',
+                message: 'You lead multiple teams. Specify teamName to disambiguate.',
+                data: { candidates: projectTeams.map((t) => ({ teamName: t.name })) },
+            },
+        };
+    }
+    async createTeamAgent(input) {
+        const teamResult = await this.resolveLedTeam(input.leadAgentId, input.projectId, input.teamName);
+        if ('error' in teamResult)
+            return teamResult;
+        const { team } = teamResult;
+        if (!team.allowTeamLeadCreateAgents) {
+            return {
+                error: {
+                    code: 'TEAM_LEAD_CREATION_DISABLED',
+                    message: 'Team does not allow lead-initiated agent creation',
+                    data: { teamId: team.id, teamName: team.name },
+                },
+            };
+        }
+        const teamConfigs = await this.teamsStore.listConfigsForTeam(team.id);
+        const configsWithProfiles = [];
+        for (const config of teamConfigs) {
+            const profile = await this.storage.getAgentProfile(config.profileId);
+            configsWithProfiles.push({
+                id: config.id,
+                profileId: config.profileId,
+                name: config.name,
+                description: config.description,
+                profileName: profile.name,
+            });
+        }
+        const trimmedConfigName = input.configName.trim().toLowerCase();
+        let candidates = configsWithProfiles.filter((c) => c.name.trim().toLowerCase() === trimmedConfigName);
+        if (input.profileName) {
+            const trimmedProfileName = input.profileName.trim().toLowerCase();
+            candidates = candidates.filter((c) => c.profileName.trim().toLowerCase() === trimmedProfileName);
+        }
+        if (candidates.length === 0) {
+            return {
+                error: {
+                    code: 'CONFIG_NOT_FOUND',
+                    message: `No provider configuration named "${input.configName}" found for this team`,
+                },
+            };
+        }
+        if (candidates.length > 1) {
+            return {
+                error: {
+                    code: 'AMBIGUOUS_CONFIG_NAME',
+                    message: `Multiple configurations named "${input.configName}" found. Specify profileName to disambiguate.`,
+                    data: {
+                        candidates: candidates.map((c) => ({
+                            configName: c.name,
+                            profileName: c.profileName,
+                        })),
+                    },
+                },
+            };
+        }
+        const resolved = candidates[0];
+        const { items: existingAgents } = await this.storage.listAgents(input.projectId, {
+            limit: 10000,
+        });
+        const trimmedAgentName = input.name.trim().toLowerCase();
+        if (existingAgents.some((a) => a.name.trim().toLowerCase() === trimmedAgentName)) {
+            return {
+                error: {
+                    code: 'AGENT_NAME_EXISTS',
+                    message: `An agent named "${input.name}" already exists in this project`,
+                },
+            };
+        }
+        const effectiveDescription = input.description?.trim() || resolved.description?.trim() || '';
+        let agent;
+        try {
+            agent = await this.teamsStore.createTeamAgentAtomicCapped({
+                teamId: team.id,
+                maxMembers: team.maxMembers,
+                teamLeadAgentId: team.teamLeadAgentId,
+                createAgentFn: () => this.storage.createAgent({
+                    projectId: input.projectId,
+                    profileId: resolved.profileId,
+                    providerConfigId: resolved.id,
+                    name: input.name,
+                    description: effectiveDescription,
+                }),
+            });
+        }
+        catch (error) {
+            if (error instanceof error_types_1.TeamMemberCapReachedError) {
+                return {
+                    error: {
+                        code: 'TEAM_MEMBER_CAP_REACHED',
+                        message: error.message,
+                        data: error.details,
+                    },
+                };
+            }
+            throw error;
+        }
+        try {
+            await this.eventsService?.publish('agent.created', {
+                agentId: agent.id,
+                agentName: agent.name,
+                projectId: input.projectId,
+                profileId: resolved.profileId,
+                providerConfigId: resolved.id,
+                actor: { type: 'agent', id: input.leadAgentId },
+            });
+        }
+        catch (error) {
+            logger.error({ agentId: agent.id, projectId: input.projectId, error }, 'Failed to publish agent.created event');
+        }
+        try {
+            await this.eventsService?.publish('team.member.added', {
+                teamId: team.id,
+                projectId: input.projectId,
+                teamLeadAgentId: team.teamLeadAgentId,
+                teamName: team.name,
+                addedAgentId: agent.id,
+                addedAgentName: agent.name,
+            });
+        }
+        catch (error) {
+            logger.error({ agentId: agent.id, projectId: input.projectId, teamId: team.id, error }, 'Failed to publish team.member.added event');
+        }
+        return {
+            agent: {
+                id: agent.id,
+                name: agent.name,
+                description: agent.description,
+                profileName: resolved.profileName,
+                configName: resolved.name,
+            },
+            teamName: team.name,
+        };
+    }
+    async createTeamAgentForRest(input) {
+        const team = await this.teamsStore.getTeam(input.teamId);
+        if (!team || team.projectId !== input.projectId) {
+            throw new error_types_1.NotFoundError('Team');
+        }
+        if (team.teamLeadAgentId === null) {
+            throw new error_types_1.ValidationError('Team has no lead');
+        }
+        if (input.actorLeadAgentId !== team.teamLeadAgentId) {
+            throw new error_types_1.ValidationError('Not team lead');
+        }
+        const config = await this.storage.getProfileProviderConfig(input.providerConfigId);
+        const profile = await this.storage.getAgentProfile(config.profileId);
+        if (profile.projectId !== team.projectId) {
+            throw new error_types_1.NotFoundError('Provider config');
+        }
+        const teamProfileIds = await this.teamsStore.listProfilesForTeam(input.teamId);
+        if (!teamProfileIds.includes(config.profileId)) {
+            throw new error_types_1.ValidationError('Profile not linked to team');
+        }
+        const { items: existingAgents } = await this.storage.listAgents(input.projectId, {
+            limit: 10000,
+        });
+        const trimmedName = input.name.trim().toLowerCase();
+        if (existingAgents.some((a) => a.name.trim().toLowerCase() === trimmedName)) {
+            throw new error_types_1.ConflictError(`An agent named "${input.name}" already exists in this project`);
+        }
+        const effectiveDescription = input.description?.trim() || config.description?.trim() || '';
+        let agent;
+        try {
+            agent = await this.teamsStore.createTeamAgentAtomicCapped({
+                teamId: input.teamId,
+                maxMembers: team.maxMembers,
+                teamLeadAgentId: team.teamLeadAgentId,
+                createAgentFn: () => this.storage.createAgent({
+                    projectId: input.projectId,
+                    profileId: config.profileId,
+                    providerConfigId: input.providerConfigId,
+                    name: input.name,
+                    description: effectiveDescription,
+                }),
+            });
+        }
+        catch (error) {
+            if (error instanceof error_types_1.TeamMemberCapReachedError) {
+                throw new error_types_1.ConflictError('Team is at member cap');
+            }
+            throw error;
+        }
+        try {
+            await this.eventsService?.publish('agent.created', {
+                agentId: agent.id,
+                agentName: agent.name,
+                projectId: input.projectId,
+                profileId: config.profileId,
+                providerConfigId: input.providerConfigId,
+                actor: { type: 'agent', id: input.actorLeadAgentId },
+            });
+        }
+        catch (error) {
+            logger.error({ agentId: agent.id, projectId: input.projectId, error }, 'Failed to publish agent.created event');
+        }
+        try {
+            await this.eventsService?.publish('team.member.added', {
+                teamId: input.teamId,
+                projectId: input.projectId,
+                teamLeadAgentId: team.teamLeadAgentId,
+                teamName: team.name,
+                addedAgentId: agent.id,
+                addedAgentName: agent.name,
+            });
+        }
+        catch {
+        }
+        return agent;
+    }
+    async deleteTeamAgent(input) {
+        const teamResult = await this.resolveLedTeam(input.leadAgentId, input.projectId, input.teamName);
+        if ('error' in teamResult)
+            return teamResult;
+        const { team } = teamResult;
+        const teamDetail = await this.teamsStore.getTeam(team.id);
+        if (!teamDetail) {
+            return { error: { code: 'TEAM_NOT_FOUND_OR_NOT_LED', message: 'Team no longer exists' } };
+        }
+        const memberAgentIds = teamDetail.members.map((m) => m.agentId);
+        const { items: projectAgents } = await this.storage.listAgents(input.projectId, {
+            limit: 10000,
+        });
+        const memberAgents = projectAgents.filter((a) => memberAgentIds.includes(a.id));
+        const trimmedName = input.name.trim().toLowerCase();
+        const nameMatches = memberAgents.filter((a) => a.name.trim().toLowerCase() === trimmedName);
+        if (nameMatches.length === 0) {
+            return {
+                error: {
+                    code: 'AGENT_NOT_FOUND_IN_TEAM',
+                    message: `No agent named "${input.name}" found in team "${team.name}"`,
+                },
+            };
+        }
+        if (nameMatches.length > 1) {
+            return {
+                error: {
+                    code: 'AMBIGUOUS_AGENT_NAME',
+                    message: `Multiple agents named "${input.name}" found in team "${team.name}". Cannot disambiguate.`,
+                },
+            };
+        }
+        const targetAgent = nameMatches[0];
+        if (targetAgent.id === team.teamLeadAgentId) {
+            return {
+                error: {
+                    code: 'CANNOT_DELETE_TEAM_LEAD',
+                    message: `Cannot delete "${targetAgent.name}" — they are the team lead of "${team.name}"`,
+                },
+            };
+        }
+        const agentTeams = await this.teamsStore.listTeamsByAgent(targetAgent.id);
+        for (const agentTeam of agentTeams) {
+            if (agentTeam.id === team.id)
+                continue;
+            if (agentTeam.teamLeadAgentId === targetAgent.id) {
+                return {
+                    error: {
+                        code: 'TARGET_LEADS_OTHER_TEAM',
+                        message: `Cannot delete "${targetAgent.name}" — they lead team "${agentTeam.name}"`,
+                    },
+                };
+            }
+            return {
+                error: {
+                    code: 'TARGET_BELONGS_TO_OTHER_TEAM',
+                    message: `Cannot delete "${targetAgent.name}" — they also belong to team "${agentTeam.name}". Remove them from that team first.`,
+                },
+            };
+        }
+        try {
+            const sessionsService = this.getSessionsService();
+            const activeSessions = await sessionsService.listActiveSessions(input.projectId, new Set([targetAgent.id]));
+            for (const session of activeSessions) {
+                try {
+                    await sessionsService.terminateSession(session.id);
+                }
+                catch (error) {
+                    logger.error({ sessionId: session.id, agentId: targetAgent.id, error }, 'Failed to terminate session before agent deletion');
+                }
+            }
+        }
+        catch (error) {
+            logger.error({ agentId: targetAgent.id, error }, 'Failed to list active sessions before agent deletion');
+        }
+        const preDeleteData = {
+            teamId: team.id,
+            teamName: team.name,
+            teamLeadAgentId: team.teamLeadAgentId,
+            removedAgentId: targetAgent.id,
+            removedAgentName: targetAgent.name,
+        };
+        try {
+            await this.storage.deleteAgent(targetAgent.id);
+        }
+        catch (error) {
+            if (error instanceof error_types_1.ConflictError) {
+                return {
+                    error: { code: 'AGENT_HAS_RUNNING_SESSIONS', message: error.message },
+                };
+            }
+            throw error;
+        }
+        try {
+            await this.eventsService?.publish('team.member.removed', {
+                teamId: preDeleteData.teamId,
+                projectId: input.projectId,
+                teamLeadAgentId: preDeleteData.teamLeadAgentId,
+                teamName: preDeleteData.teamName,
+                removedAgentId: preDeleteData.removedAgentId,
+                removedAgentName: preDeleteData.removedAgentName,
+            });
+        }
+        catch (error) {
+            logger.error({ agentId: targetAgent.id, teamId: team.id, error }, 'Failed to publish team.member.removed event');
+        }
+        try {
+            await this.eventsService?.publish('agent.deleted', {
+                agentId: targetAgent.id,
+                agentName: targetAgent.name,
+                projectId: input.projectId,
+                actor: { type: 'agent', id: input.leadAgentId },
+                teamId: team.id,
+                teamName: team.name,
+            });
+        }
+        catch (error) {
+            logger.error({ agentId: targetAgent.id, projectId: input.projectId, error }, 'Failed to publish agent.deleted event');
+        }
+        return {
+            result: {
+                deletedAgentId: targetAgent.id,
+                deletedAgentName: targetAgent.name,
+                teamName: team.name,
+            },
+        };
+    }
+    async validateAgentsInProject(projectId, agentIds) {
+        for (const agentId of agentIds) {
+            const agent = await this.storage.getAgent(agentId);
+            if (agent.projectId !== projectId) {
+                throw new error_types_1.ValidationError(`Agent "${agent.name}" belongs to a different project`, {
+                    agentId,
+                    expectedProjectId: projectId,
+                    actualProjectId: agent.projectId,
+                });
+            }
+        }
+    }
+    async validateProfilesInProject(projectId, profileIds) {
+        const uniqueIds = [...new Set(profileIds)];
+        for (const profileId of uniqueIds) {
+            const profile = await this.storage.getAgentProfile(profileId);
+            if (profile.projectId !== projectId) {
+                throw new error_types_1.ValidationError(`Profile "${profile.name}" belongs to a different project`, {
+                    profileId,
+                    expectedProjectId: projectId,
+                    actualProjectId: profile.projectId,
+                });
+            }
+        }
+    }
+    dedupeProfileConfigSelections(selections) {
+        if (!selections)
+            return undefined;
+        const seen = new Set();
+        const result = [];
+        for (const sel of selections) {
+            if (seen.has(sel.profileId))
+                continue;
+            seen.add(sel.profileId);
+            result.push({ profileId: sel.profileId, configIds: [...new Set(sel.configIds)] });
+        }
+        return result;
+    }
+    validateSelectionsAgainstProfiles(selections, effectiveProfileIds) {
+        const profileIdSet = new Set(effectiveProfileIds);
+        for (const sel of selections) {
+            if (!profileIdSet.has(sel.profileId)) {
+                throw new error_types_1.ValidationError(`Config selection references profile "${sel.profileId}" which is not linked to this team`, { profileId: sel.profileId });
+            }
+        }
+    }
+    async validateConfigProfileConsistency(selections) {
+        for (const sel of selections) {
+            for (const configId of sel.configIds) {
+                const config = await this.storage.getProfileProviderConfig(configId);
+                if (config.profileId !== sel.profileId) {
+                    throw new error_types_1.ValidationError(`Config "${configId}" belongs to profile "${config.profileId}", not "${sel.profileId}"`, {
+                        configId,
+                        expectedProfileId: sel.profileId,
+                        actualProfileId: config.profileId,
+                    });
+                }
+            }
+        }
+    }
+};
+exports.TeamsService = TeamsService;
+exports.TeamsService = TeamsService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
+    __param(3, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [teams_store_1.TeamsStore, Object, core_1.ModuleRef,
+        events_service_1.EventsService])
+], TeamsService);
+//# sourceMappingURL=teams.service.js.map