crewly 1.2.3 → 1.2.6

package/dist/backend/backend/src/controllers/team/team.controller.js

@@ -9,6 +9,7 @@ import { ActivityMonitorService } from '../../services/monitoring/activity-monit
 import { MemoryService } from '../../services/memory/memory.service.js';
 import { SubAgentMessageQueue } from '../../services/messaging/sub-agent-message-queue.service.js';
 import { SUB_AGENT_QUEUE_CONSTANTS } from '../../constants.js';
+import { getCriticalEventTypes } from '../../types/event-bus.types.js';
 import { LoggerService } from '../../services/core/logger.service.js';
 const logger = LoggerService.getInstance().createComponentLogger('TeamController');
 /**
@@ -160,14 +161,22 @@ async function _startTeamMemberCore(context, team, member, projectPath) {
                     }
                 }
                 else {
-                    // Session exists and agent status is active/activating - this is normal conflict
+                    // Session exists and agent status is active/activating/starting — skip this member
+                    // Restore the agentStatus to ACTIVE in storage (it may have been set to STARTING by the caller)
+                    const freshTeams = await context.storageService.getTeams();
+                    const freshTeam = freshTeams.find(t => t.id === team.id);
+                    const freshMember = freshTeam?.members.find(m => m.id === member.id);
+                    if (freshTeam && freshMember && freshMember.agentStatus !== CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVE) {
+                        freshMember.agentStatus = CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVE;
+                        freshMember.updatedAt = new Date().toISOString();
+                        await context.storageService.saveTeam(freshTeam);
+                    }
                     return {
-                        success: false,
+                        success: true,
                         memberName: member.name,
                         memberId: member.id,
                         sessionName: member.sessionName,
                         status: 'already_active',
-                        error: 'Team member already has an active session'
                     };
                 }
             }
@@ -387,11 +396,17 @@ async function _stopTeamMemberCore(context, team, member) {
     }
 }
 /**
- * Creates (or refreshes) orchestrator subscriptions to agent lifecycle events.
+ * Creates (or refreshes) orchestrator subscriptions to critical agent events.
  *
  * Clears any existing subscriptions for the orchestrator session first to avoid
- * duplicates on re-registration, then subscribes to all agent status change events
- * with the maximum TTL (24 hours). Re-created each time the orchestrator registers.
+ * duplicates on re-registration, then subscribes to only CRITICAL event types
+ * (task completions, failures, agent crashes, escalations) with the maximum
+ * TTL (24 hours). Info events (idle/busy toggles, minor status changes) are
+ * intentionally excluded to prevent flooding the orchestrator terminal.
+ *
+ * Critical events are also delivered immediately (no debounce delay) by the
+ * EventBusService, ensuring the orchestrator learns about task completions
+ * within seconds.
  */
 function ensureOrchestratorSubscriptions() {
     if (!eventBusService)
@@ -401,9 +416,10 @@ function ensureOrchestratorSubscriptions() {
     for (const sub of existing) {
         eventBusService.unsubscribe(sub.id);
     }
-    // Subscribe to all agent lifecycle events with max TTL
+    // Subscribe to CRITICAL events only — task completions, failures, agent crashes, escalations.
+    // Info events (idle/busy, status_changed) are excluded to prevent terminal flooding.
     eventBusService.subscribe({
-        eventType: ['agent:status_changed', 'agent:idle', 'agent:busy', 'agent:active', 'agent:inactive'],
+        eventType: getCriticalEventTypes(),
         filter: {},
         subscriberSession: ORCHESTRATOR_SESSION_NAME,
         oneShot: false,
@@ -412,7 +428,7 @@ function ensureOrchestratorSubscriptions() {
 }
 export async function createTeam(req, res) {
     try {
-        const { name, description, members, projectPath, currentProject, projectIds } = req.body;
+        const { name, description, members, projectPath, currentProject, projectIds, hierarchical, templateId, parentTeamId } = req.body;
         if (!name || !members || !Array.isArray(members) || members.length === 0) {
             res.status(400).json({
                 success: false,
@@ -429,6 +445,17 @@ export async function createTeam(req, res) {
                 return;
             }
         }
+        // Validate hierarchical team requirements
+        if (hierarchical) {
+            const leaders = members.filter(m => m.role === 'team-leader' || m.canDelegate);
+            if (leaders.length === 0) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Hierarchical teams require at least one team-leader or member with canDelegate=true'
+                });
+                return;
+            }
+        }
         const existingTeams = await this.storageService.getTeams();
         if (existingTeams.find(t => t.name === name)) {
             res.status(409).json({
@@ -437,11 +464,31 @@ export async function createTeam(req, res) {
             });
             return;
         }
+        // Validate parentTeamId references an existing team
+        if (parentTeamId) {
+            // Orchestrator is a system team and cannot be used as a parent
+            if (parentTeamId === CREWLY_CONSTANTS.AGENT_IDS.ORCHESTRATOR_ID) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Cannot use Orchestrator Team as parent — it is a system team'
+                });
+                return;
+            }
+            const parentTeam = existingTeams.find(t => t.id === parentTeamId);
+            if (!parentTeam) {
+                res.status(400).json({
+                    success: false,
+                    error: `Parent team with id "${parentTeamId}" not found`
+                });
+                return;
+            }
+        }
         const teamId = uuidv4();
         const teamMembers = [];
         for (let i = 0; i < members.length; i++) {
             const member = members[i];
             const memberId = uuidv4();
+            const isLeaderRole = member.role === 'team-leader' || member.canDelegate === true;
             const teamMember = {
                 id: memberId,
                 name: member.name,
@@ -455,10 +502,37 @@ export async function createTeam(req, res) {
                 skillOverrides: member.skillOverrides || [],
                 excludedRoleSkills: member.excludedRoleSkills || [],
                 createdAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString()
+                updatedAt: new Date().toISOString(),
+                // Hierarchy fields (only set for hierarchical teams)
+                ...(hierarchical ? {
+                    hierarchyLevel: member.hierarchyLevel ?? (isLeaderRole ? 1 : 2),
+                    canDelegate: isLeaderRole,
+                    subordinateIds: [],
+                } : {}),
             };
             teamMembers.push(teamMember);
         }
+        // For hierarchical teams: wire up parent-child relationships
+        let leaderId;
+        let leaderIds;
+        if (hierarchical) {
+            // Collect all leaders (team-leader role or canDelegate)
+            const leaders = teamMembers.filter(m => m.role === 'team-leader' || m.canDelegate);
+            if (leaders.length > 0) {
+                leaderIds = leaders.map(l => l.id);
+                leaderId = leaderIds[0];
+                // For single-leader teams, wire all workers under the one leader
+                if (leaders.length === 1) {
+                    const leader = leaders[0];
+                    const workers = teamMembers.filter(m => m.id !== leader.id);
+                    leader.subordinateIds = workers.map(w => w.id);
+                    for (const worker of workers) {
+                        worker.parentMemberId = leader.id;
+                    }
+                }
+                // For multi-leader teams, subordinateIds are managed via parentMemberId on each worker
+            }
+        }
         const team = {
             id: teamId,
             name,
@@ -466,7 +540,10 @@ export async function createTeam(req, res) {
             members: teamMembers,
             projectIds: projectIds || (currentProject ? [currentProject] : []),
             createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString()
+            updatedAt: new Date().toISOString(),
+            ...(hierarchical ? { hierarchical: true, leaderId, leaderIds } : {}),
+            ...(templateId ? { templateId } : {}),
+            ...(parentTeamId ? { parentTeamId } : {}),
         };
         await this.storageService.saveTeam(team);
         for (const member of teamMembers) {
@@ -633,15 +710,45 @@ export async function startTeam(req, res) {
         let sessionsCreated = 0;
         let sessionsAlreadyRunning = 0;
         const results = [];
-        // PHASE 2: Immediately set ALL members to 'starting' for instant UI feedback
+        // PHASE 2: Set inactive members to 'starting' for instant UI feedback
+        // Skip members that are already active/started/starting to avoid interrupting running agents
+        const NON_STARTABLE_STATUSES = new Set([
+            CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVE,
+            CREWLY_CONSTANTS.AGENT_STATUSES.STARTED,
+            CREWLY_CONSTANTS.AGENT_STATUSES.STARTING,
+            CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVATING,
+        ]);
+        const alreadyActiveMembers = new Set();
         for (const member of team.members) {
-            const mutableMember = member;
-            mutableMember.agentStatus = CREWLY_CONSTANTS.AGENT_STATUSES.STARTING;
-            mutableMember.updatedAt = new Date().toISOString();
+            if (NON_STARTABLE_STATUSES.has(member.agentStatus)) {
+                alreadyActiveMembers.add(member.id);
+            }
+            else {
+                const mutableMember = member;
+                mutableMember.agentStatus = CREWLY_CONSTANTS.AGENT_STATUSES.STARTING;
+                mutableMember.updatedAt = new Date().toISOString();
+            }
         }
         await this.storageService.saveTeam(team);
-        // Start each team member using the internal helper function
+        // Start each team member using the internal helper function (skip verified active members)
         for (const member of team.members) {
+            // Fast-path: if the member was already active before PHASE 2, verify session and skip
+            if (alreadyActiveMembers.has(member.id) && member.sessionName) {
+                const sessions = await this.tmuxService.listSessions();
+                const hasLiveSession = sessions.some(s => s.sessionName === member.sessionName);
+                if (hasLiveSession) {
+                    sessionsAlreadyRunning++;
+                    results.push({
+                        memberName: member.name,
+                        sessionName: member.sessionName,
+                        status: 'already_running',
+                        success: true,
+                        memberId: member.id,
+                    });
+                    continue;
+                }
+                // Session doesn't exist despite active status — fall through to start it
+            }
             const result = await _startTeamMemberCore(this, team, member, assignedProject.path);
             // Convert internal result to the expected format for the response
             const resultForResponse = {
@@ -811,6 +918,13 @@ export async function deleteTeam(req, res) {
                 }
             }
         }
+        // Unset parentTeamId on any child teams referencing this team
+        const childTeams = teams.filter(t => t.parentTeamId === id);
+        for (const child of childTeams) {
+            child.parentTeamId = undefined;
+            child.updatedAt = new Date().toISOString();
+            await this.storageService.saveTeam(child);
+        }
         await this.storageService.deleteTeam(id);
         res.json({ success: true, message: 'Team terminated successfully' });
     }
@@ -956,7 +1070,31 @@ export async function startTeamMember(req, res) {
             res.status(404).json({ success: false, error: 'Team member not found' });
             return;
         }
-        // PHASE 3: Immediately set target member to 'starting' for instant UI feedback
+        // Skip members that are already active to avoid interrupting running agents
+        const skipStatuses = new Set([
+            CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVE,
+            CREWLY_CONSTANTS.AGENT_STATUSES.STARTED,
+            CREWLY_CONSTANTS.AGENT_STATUSES.STARTING,
+            CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVATING,
+        ]);
+        if (skipStatuses.has(member.agentStatus) && member.sessionName) {
+            // Verify the session actually exists before skipping
+            const sessions = await this.tmuxService.listSessions();
+            const hasLiveSession = sessions.some(s => s.sessionName === member.sessionName);
+            if (hasLiveSession) {
+                res.json({
+                    success: true,
+                    message: `Team member ${member.name} is already active`,
+                    data: {
+                        memberId: member.id,
+                        sessionName: member.sessionName,
+                        status: member.agentStatus
+                    }
+                });
+                return;
+            }
+        }
+        // Set target member to 'starting' for instant UI feedback
         const mutableMember = member;
         mutableMember.agentStatus = CREWLY_CONSTANTS.AGENT_STATUSES.STARTING;
         mutableMember.updatedAt = new Date().toISOString();
@@ -1572,7 +1710,15 @@ export async function updateTeam(req, res) {
             return;
         }
         // Handle orchestrator team specially
-        if (id === 'orchestrator') {
+        if (id === CREWLY_CONSTANTS.AGENT_IDS.ORCHESTRATOR_ID) {
+            // Orchestrator is a system team — cannot have a parent
+            if (updates.parentTeamId !== undefined && updates.parentTeamId !== null) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Cannot set parentTeamId on Orchestrator Team — it is a system team'
+                });
+                return;
+            }
             // Orchestrator team is virtual and stored separately
             const orchestratorStatus = await this.storageService.getOrchestratorStatus();
             if (!orchestratorStatus) {
@@ -1618,6 +1764,72 @@ export async function updateTeam(req, res) {
         if (updates.description !== undefined) {
             team.description = updates.description;
         }
+        if (updates.hierarchical !== undefined) {
+            team.hierarchical = updates.hierarchical;
+            if (!updates.hierarchical) {
+                // Disable hierarchy: clear leaderId, leaderIds, and member hierarchy fields
+                team.leaderId = undefined;
+                team.leaderIds = undefined;
+                for (const m of team.members) {
+                    m.parentMemberId = undefined;
+                    m.hierarchyLevel = undefined;
+                    m.canDelegate = undefined;
+                    m.subordinateIds = undefined;
+                }
+            }
+        }
+        // Support leaderIds update (multi-TL)
+        if (updates.leaderIds !== undefined && team.hierarchical) {
+            team.leaderIds = updates.leaderIds;
+            team.leaderId = updates.leaderIds[0]; // backward compat
+            // Set hierarchy fields on each leader
+            for (const lid of updates.leaderIds) {
+                const leader = team.members.find(m => m.id === lid);
+                if (leader) {
+                    leader.hierarchyLevel = 1;
+                    leader.canDelegate = true;
+                }
+            }
+            // Workers: any member not in leaderIds and not orchestrator
+            const leaderIdSet = new Set(updates.leaderIds);
+            const workers = team.members.filter(m => !leaderIdSet.has(m.id) && m.role !== 'orchestrator');
+            for (const worker of workers) {
+                worker.hierarchyLevel = 2;
+                worker.canDelegate = false;
+                // Assign to first leader if no parentMemberId already set to a valid leader
+                if (!worker.parentMemberId || !leaderIdSet.has(worker.parentMemberId)) {
+                    worker.parentMemberId = updates.leaderIds[0];
+                }
+            }
+            // Update subordinateIds on each leader
+            for (const lid of updates.leaderIds) {
+                const leader = team.members.find(m => m.id === lid);
+                if (leader) {
+                    leader.subordinateIds = workers
+                        .filter(w => w.parentMemberId === lid)
+                        .map(w => w.id);
+                }
+            }
+        }
+        else if (updates.leaderId !== undefined && team.hierarchical) {
+            // Legacy single-leader update path
+            team.leaderId = updates.leaderId;
+            team.leaderIds = [updates.leaderId]; // keep in sync
+            // Wire parent-child relationships for the new leader
+            const leader = team.members.find(m => m.id === updates.leaderId);
+            if (leader) {
+                leader.hierarchyLevel = 1;
+                leader.canDelegate = true;
+                const workers = team.members.filter(m => m.id !== updates.leaderId && m.role !== 'orchestrator');
+                leader.subordinateIds = workers.map(w => w.id);
+                for (const worker of workers) {
+                    worker.parentMemberId = leader.id;
+                    worker.hierarchyLevel = 2;
+                    worker.canDelegate = false;
+                    worker.subordinateIds = [];
+                }
+            }
+        }
         // Update members if provided (from TeamModal edit)
         if (updates.members !== undefined && Array.isArray(updates.members)) {
             team.members = await Promise.all(updates.members.map(async (memberUpdate) => {
@@ -1655,6 +1867,48 @@ export async function updateTeam(req, res) {
                 }
             }));
         }
+        // Handle parentTeamId updates
+        if (updates.parentTeamId !== undefined) {
+            if (updates.parentTeamId === null) {
+                // Explicitly remove parent (make top-level)
+                team.parentTeamId = undefined;
+            }
+            else {
+                // Orchestrator is a system team and cannot be used as a parent
+                if (updates.parentTeamId === CREWLY_CONSTANTS.AGENT_IDS.ORCHESTRATOR_ID) {
+                    res.status(400).json({
+                        success: false,
+                        error: 'Cannot use Orchestrator Team as parent — it is a system team'
+                    });
+                    return;
+                }
+                // Validate parent team exists and prevent self-reference / circular references
+                if (updates.parentTeamId === id) {
+                    res.status(400).json({
+                        success: false,
+                        error: 'A team cannot be its own parent'
+                    });
+                    return;
+                }
+                const parentTeam = teams.find(t => t.id === updates.parentTeamId);
+                if (!parentTeam) {
+                    res.status(400).json({
+                        success: false,
+                        error: `Parent team with id "${updates.parentTeamId}" not found`
+                    });
+                    return;
+                }
+                // Prevent circular reference: parent's parentTeamId must not be this team
+                if (parentTeam.parentTeamId === id) {
+                    res.status(400).json({
+                        success: false,
+                        error: 'Circular parent reference detected'
+                    });
+                    return;
+                }
+                team.parentTeamId = updates.parentTeamId;
+            }
+        }
         // Update timestamp
         team.updatedAt = new Date().toISOString();
         await this.storageService.saveTeam(team);