@iaforged/context-code 1.0.63 → 1.0.67

package/dist/src/hooks/useInboxPoller.js

@@ -1,709 +0,0 @@
-import { randomUUID } from 'crypto';
-import { useCallback, useEffect, useRef } from 'react';
-import { useInterval } from 'usehooks-ts';
-import { TEAMMATE_MESSAGE_TAG } from '../constants/xml.js';
-import { useTerminalNotification } from '../ink/useTerminalNotification.js';
-import { sendNotification } from '../services/notifier.js';
-import { useAppState, useAppStateStore, useSetAppState, } from '../state/AppState.js';
-import { findToolByName } from '../Tool.js';
-import { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js';
-import { getAllBaseTools } from '../tools.js';
-import { logForDebugging } from '../utils/debug.js';
-import { findInProcessTeammateTaskId, handlePlanApprovalResponse, } from '../utils/inProcessTeammateHelpers.js';
-import { createAssistantMessage } from '../utils/messages.js';
-import { permissionModeFromString, toExternalPermissionMode, } from '../utils/permissions/PermissionMode.js';
-import { applyPermissionUpdate } from '../utils/permissions/PermissionUpdate.js';
-import { jsonStringify } from '../utils/slowOperations.js';
-import { isInsideTmux } from '../utils/swarm/backends/detection.js';
-import { ensureBackendsRegistered, getBackendByType, } from '../utils/swarm/backends/registry.js';
-import { TEAM_LEAD_NAME } from '../utils/swarm/constants.js';
-import { getLeaderToolUseConfirmQueue } from '../utils/swarm/leaderPermissionBridge.js';
-import { sendPermissionResponseViaMailbox } from '../utils/swarm/permissionSync.js';
-import { removeTeammateFromTeamFile, setMemberMode, } from '../utils/swarm/teamHelpers.js';
-import { unassignTeammateTasks } from '../utils/tasks.js';
-import { getAgentName, isPlanModeRequired, isTeamLead, isTeammate, } from '../utils/teammate.js';
-import { isInProcessTeammate } from '../utils/teammateContext.js';
-import { isModeSetRequest, isPermissionRequest, isPermissionResponse, isPlanApprovalRequest, isPlanApprovalResponse, isSandboxPermissionRequest, isSandboxPermissionResponse, isShutdownApproved, isShutdownRequest, isTeamPermissionUpdate, markMessagesAsRead, readUnreadMessages, writeToMailbox, } from '../utils/teammateMailbox.js';
-import { hasPermissionCallback, hasSandboxPermissionCallback, processMailboxPermissionResponse, processSandboxPermissionResponse, } from './useSwarmPermissionPoller.js';
-/**
- * Get the agent name to poll for messages.
- * - In-process teammates return undefined (they use waitForNextPromptOrShutdown instead)
- * - Process-based teammates use their CLAUDE_CODE_AGENT_NAME
- * - Team leads use their name from teamContext.teammates
- * - Standalone sessions return undefined
- */
-function getAgentNameToPoll(appState) {
-    // In-process teammates should NOT use useInboxPoller - they have their own
-    // polling mechanism via waitForNextPromptOrShutdown() in inProcessRunner.ts.
-    // Using useInboxPoller would cause message routing issues since in-process
-    // teammates share the same React context and AppState with the leader.
-    //
-    // Note: This can be called when the leader's REPL re-renders while an
-    // in-process teammate's AsyncLocalStorage context is active (due to shared
-    // setAppState). We return undefined to gracefully skip polling rather than
-    // throwing, since this is a normal occurrence during concurrent execution.
-    if (isInProcessTeammate()) {
-        return undefined;
-    }
-    if (isTeammate()) {
-        return getAgentName();
-    }
-    // Team lead polls using their agent name (not ID)
-    if (isTeamLead(appState.teamContext)) {
-        const leadAgentId = appState.teamContext.leadAgentId;
-        // Look up the lead's name from teammates map
-        const leadName = appState.teamContext.teammates[leadAgentId]?.name;
-        return leadName || 'team-lead';
-    }
-    return undefined;
-}
-const INBOX_POLL_INTERVAL_MS = 1000;
-/**
- * Polls the teammate inbox for new messages and submits them as turns.
- *
- * This hook:
- * 1. Polls every 1s for unread messages (teammates or team leads)
- * 2. When idle: submits messages immediately as a new turn
- * 3. When busy: queues messages in AppState.inbox for UI display, delivers when turn ends
- */
-export function useInboxPoller({ enabled, isLoading, focusedInputDialog, onSubmitMessage, }) {
-    // Assign to original name for clarity within the function
-    const onSubmitTeammateMessage = onSubmitMessage;
-    const store = useAppStateStore();
-    const setAppState = useSetAppState();
-    const inboxMessageCount = useAppState(s => s.inbox.messages.length);
-    const terminal = useTerminalNotification();
-    const poll = useCallback(async () => {
-        if (!enabled)
-            return;
-        // Use ref to avoid dependency on appState object (prevents infinite loop)
-        const currentAppState = store.getState();
-        const agentName = getAgentNameToPoll(currentAppState);
-        if (!agentName)
-            return;
-        const unread = await readUnreadMessages(agentName, currentAppState.teamContext?.teamName);
-        if (unread.length === 0)
-            return;
-        logForDebugging(`[InboxPoller] Found ${unread.length} unread message(s)`);
-        // Check for plan approval responses and transition out of plan mode if approved
-        // Security: Only accept approval responses from the team lead
-        if (isTeammate() && isPlanModeRequired()) {
-            for (const msg of unread) {
-                const approvalResponse = isPlanApprovalResponse(msg.text);
-                // Verify the message is from the team lead to prevent teammates from forging approvals
-                if (approvalResponse && msg.from === 'team-lead') {
-                    logForDebugging(`[InboxPoller] Received plan approval response from team-lead: approved=${approvalResponse.approved}`);
-                    if (approvalResponse.approved) {
-                        // Use leader's permission mode if provided, otherwise default
-                        const targetMode = approvalResponse.permissionMode ?? 'default';
-                        // Transition out of plan mode
-                        setAppState(prev => ({
-                            ...prev,
-                            toolPermissionContext: applyPermissionUpdate(prev.toolPermissionContext, {
-                                type: 'setMode',
-                                mode: toExternalPermissionMode(targetMode),
-                                destination: 'session',
-                            }),
-                        }));
-                        logForDebugging(`[InboxPoller] Plan approved by team lead, exited plan mode to ${targetMode}`);
-                    }
-                    else {
-                        logForDebugging(`[InboxPoller] Plan rejected by team lead: ${approvalResponse.feedback || 'No feedback provided'}`);
-                    }
-                }
-                else if (approvalResponse) {
-                    logForDebugging(`[InboxPoller] Ignoring plan approval response from non-team-lead: ${msg.from}`);
-                }
-            }
-        }
-        // Helper to mark messages as read in the inbox file.
-        // Called after messages are successfully delivered or reliably queued.
-        const markRead = () => {
-            void markMessagesAsRead(agentName, currentAppState.teamContext?.teamName);
-        };
-        // Separate permission messages from regular teammate messages
-        const permissionRequests = [];
-        const permissionResponses = [];
-        const sandboxPermissionRequests = [];
-        const sandboxPermissionResponses = [];
-        const shutdownRequests = [];
-        const shutdownApprovals = [];
-        const teamPermissionUpdates = [];
-        const modeSetRequests = [];
-        const planApprovalRequests = [];
-        const regularMessages = [];
-        for (const m of unread) {
-            const permReq = isPermissionRequest(m.text);
-            const permResp = isPermissionResponse(m.text);
-            const sandboxReq = isSandboxPermissionRequest(m.text);
-            const sandboxResp = isSandboxPermissionResponse(m.text);
-            const shutdownReq = isShutdownRequest(m.text);
-            const shutdownApproval = isShutdownApproved(m.text);
-            const teamPermUpdate = isTeamPermissionUpdate(m.text);
-            const modeSetReq = isModeSetRequest(m.text);
-            const planApprovalReq = isPlanApprovalRequest(m.text);
-            if (permReq) {
-                permissionRequests.push(m);
-            }
-            else if (permResp) {
-                permissionResponses.push(m);
-            }
-            else if (sandboxReq) {
-                sandboxPermissionRequests.push(m);
-            }
-            else if (sandboxResp) {
-                sandboxPermissionResponses.push(m);
-            }
-            else if (shutdownReq) {
-                shutdownRequests.push(m);
-            }
-            else if (shutdownApproval) {
-                shutdownApprovals.push(m);
-            }
-            else if (teamPermUpdate) {
-                teamPermissionUpdates.push(m);
-            }
-            else if (modeSetReq) {
-                modeSetRequests.push(m);
-            }
-            else if (planApprovalReq) {
-                planApprovalRequests.push(m);
-            }
-            else {
-                regularMessages.push(m);
-            }
-        }
-        // Handle permission requests (leader side) - route to ToolUseConfirmQueue
-        if (permissionRequests.length > 0 &&
-            isTeamLead(currentAppState.teamContext)) {
-            logForDebugging(`[InboxPoller] Found ${permissionRequests.length} permission request(s)`);
-            const setToolUseConfirmQueue = getLeaderToolUseConfirmQueue();
-            const teamName = currentAppState.teamContext?.teamName;
-            for (const m of permissionRequests) {
-                const parsed = isPermissionRequest(m.text);
-                if (!parsed)
-                    continue;
-                if (setToolUseConfirmQueue) {
-                    // Route through the standard ToolUseConfirmQueue so tmux workers
-                    // get the same tool-specific UI (BashPermissionRequest, FileEditToolDiff, etc.)
-                    // as in-process teammates.
-                    const tool = findToolByName(getAllBaseTools(), parsed.tool_name);
-                    if (!tool) {
-                        logForDebugging(`[InboxPoller] Unknown tool ${parsed.tool_name}, skipping permission request`);
-                        continue;
-                    }
-                    const entry = {
-                        assistantMessage: createAssistantMessage({ content: '' }),
-                        tool,
-                        description: parsed.description,
-                        input: parsed.input,
-                        toolUseContext: {},
-                        toolUseID: parsed.tool_use_id,
-                        permissionResult: {
-                            behavior: 'ask',
-                            message: parsed.description,
-                        },
-                        permissionPromptStartTimeMs: Date.now(),
-                        workerBadge: {
-                            name: parsed.agent_id,
-                            color: 'cyan',
-                        },
-                        onUserInteraction() {
-                            // No-op for tmux workers (no classifier auto-approval)
-                        },
-                        onAbort() {
-                            void sendPermissionResponseViaMailbox(parsed.agent_id, { decision: 'rejected', resolvedBy: 'leader' }, parsed.request_id, teamName);
-                        },
-                        onAllow(updatedInput, permissionUpdates) {
-                            void sendPermissionResponseViaMailbox(parsed.agent_id, {
-                                decision: 'approved',
-                                resolvedBy: 'leader',
-                                updatedInput,
-                                permissionUpdates,
-                            }, parsed.request_id, teamName);
-                        },
-                        onReject(feedback) {
-                            void sendPermissionResponseViaMailbox(parsed.agent_id, {
-                                decision: 'rejected',
-                                resolvedBy: 'leader',
-                                feedback,
-                            }, parsed.request_id, teamName);
-                        },
-                        async recheckPermission() {
-                            // No-op for tmux workers — permission state is on the worker side
-                        },
-                    };
-                    // Deduplicate: if markMessagesAsRead failed on a prior poll,
-                    // the same message will be re-read — skip if already queued.
-                    setToolUseConfirmQueue(queue => {
-                        if (queue.some(q => q.toolUseID === parsed.tool_use_id)) {
-                            return queue;
-                        }
-                        return [...queue, entry];
-                    });
-                }
-                else {
-                    logForDebugging(`[InboxPoller] ToolUseConfirmQueue unavailable, dropping permission request from ${parsed.agent_id}`);
-                }
-            }
-            // Send desktop notification for the first request
-            const firstParsed = isPermissionRequest(permissionRequests[0]?.text ?? '');
-            if (firstParsed && !isLoading && !focusedInputDialog) {
-                void sendNotification({
-                    message: `${firstParsed.agent_id} needs permission for ${firstParsed.tool_name}`,
-                    notificationType: 'worker_permission_prompt',
-                }, terminal);
-            }
-        }
-        // Handle permission responses (worker side) - invoke registered callbacks
-        if (permissionResponses.length > 0 && isTeammate()) {
-            logForDebugging(`[InboxPoller] Found ${permissionResponses.length} permission response(s)`);
-            for (const m of permissionResponses) {
-                const parsed = isPermissionResponse(m.text);
-                if (!parsed)
-                    continue;
-                if (hasPermissionCallback(parsed.request_id)) {
-                    logForDebugging(`[InboxPoller] Processing permission response for ${parsed.request_id}: ${parsed.subtype}`);
-                    if (parsed.subtype === 'success') {
-                        processMailboxPermissionResponse({
-                            requestId: parsed.request_id,
-                            decision: 'approved',
-                            updatedInput: parsed.response?.updated_input,
-                            permissionUpdates: parsed.response?.permission_updates,
-                        });
-                    }
-                    else {
-                        processMailboxPermissionResponse({
-                            requestId: parsed.request_id,
-                            decision: 'rejected',
-                            feedback: parsed.error,
-                        });
-                    }
-                }
-            }
-        }
-        // Handle sandbox permission requests (leader side) - add to workerSandboxPermissions queue
-        if (sandboxPermissionRequests.length > 0 &&
-            isTeamLead(currentAppState.teamContext)) {
-            logForDebugging(`[InboxPoller] Found ${sandboxPermissionRequests.length} sandbox permission request(s)`);
-            const newSandboxRequests = [];
-            for (const m of sandboxPermissionRequests) {
-                const parsed = isSandboxPermissionRequest(m.text);
-                if (!parsed)
-                    continue;
-                // Validate required nested fields to prevent crashes from malformed messages
-                if (!parsed.hostPattern?.host) {
-                    logForDebugging(`[InboxPoller] Invalid sandbox permission request: missing hostPattern.host`);
-                    continue;
-                }
-                newSandboxRequests.push({
-                    requestId: parsed.requestId,
-                    workerId: parsed.workerId,
-                    workerName: parsed.workerName,
-                    workerColor: parsed.workerColor,
-                    host: parsed.hostPattern.host,
-                    createdAt: parsed.createdAt,
-                });
-            }
-            if (newSandboxRequests.length > 0) {
-                setAppState(prev => ({
-                    ...prev,
-                    workerSandboxPermissions: {
-                        ...prev.workerSandboxPermissions,
-                        queue: [
-                            ...prev.workerSandboxPermissions.queue,
-                            ...newSandboxRequests,
-                        ],
-                    },
-                }));
-                // Send desktop notification for the first new request
-                const firstRequest = newSandboxRequests[0];
-                if (firstRequest && !isLoading && !focusedInputDialog) {
-                    void sendNotification({
-                        message: `${firstRequest.workerName} needs network access to ${firstRequest.host}`,
-                        notificationType: 'worker_permission_prompt',
-                    }, terminal);
-                }
-            }
-        }
-        // Handle sandbox permission responses (worker side) - invoke registered callbacks
-        if (sandboxPermissionResponses.length > 0 && isTeammate()) {
-            logForDebugging(`[InboxPoller] Found ${sandboxPermissionResponses.length} sandbox permission response(s)`);
-            for (const m of sandboxPermissionResponses) {
-                const parsed = isSandboxPermissionResponse(m.text);
-                if (!parsed)
-                    continue;
-                // Check if we have a registered callback for this request
-                if (hasSandboxPermissionCallback(parsed.requestId)) {
-                    logForDebugging(`[InboxPoller] Processing sandbox permission response for ${parsed.requestId}: allow=${parsed.allow}`);
-                    // Process the response using the exported function
-                    processSandboxPermissionResponse({
-                        requestId: parsed.requestId,
-                        host: parsed.host,
-                        allow: parsed.allow,
-                    });
-                    // Clear the pending sandbox request indicator
-                    setAppState(prev => ({
-                        ...prev,
-                        pendingSandboxRequest: null,
-                    }));
-                }
-            }
-        }
-        // Handle team permission updates (teammate side) - apply permission to context
-        if (teamPermissionUpdates.length > 0 && isTeammate()) {
-            logForDebugging(`[InboxPoller] Found ${teamPermissionUpdates.length} team permission update(s)`);
-            for (const m of teamPermissionUpdates) {
-                const parsed = isTeamPermissionUpdate(m.text);
-                if (!parsed) {
-                    logForDebugging(`[InboxPoller] Failed to parse team permission update: ${m.text.substring(0, 100)}`);
-                    continue;
-                }
-                // Validate required nested fields to prevent crashes from malformed messages
-                if (!parsed.permissionUpdate?.rules ||
-                    !parsed.permissionUpdate?.behavior) {
-                    logForDebugging(`[InboxPoller] Invalid team permission update: missing permissionUpdate.rules or permissionUpdate.behavior`);
-                    continue;
-                }
-                // Apply the permission update to the teammate's context
-                logForDebugging(`[InboxPoller] Applying team permission update: ${parsed.toolName} allowed in ${parsed.directoryPath}`);
-                logForDebugging(`[InboxPoller] Permission update rules: ${jsonStringify(parsed.permissionUpdate.rules)}`);
-                setAppState(prev => {
-                    const updated = applyPermissionUpdate(prev.toolPermissionContext, {
-                        type: 'addRules',
-                        rules: parsed.permissionUpdate.rules,
-                        behavior: parsed.permissionUpdate.behavior,
-                        destination: 'session',
-                    });
-                    logForDebugging(`[InboxPoller] Updated session allow rules: ${jsonStringify(updated.alwaysAllowRules.session)}`);
-                    return {
-                        ...prev,
-                        toolPermissionContext: updated,
-                    };
-                });
-            }
-        }
-        // Handle mode set requests (teammate side) - team lead changing teammate's mode
-        if (modeSetRequests.length > 0 && isTeammate()) {
-            logForDebugging(`[InboxPoller] Found ${modeSetRequests.length} mode set request(s)`);
-            for (const m of modeSetRequests) {
-                // Only accept mode changes from team-lead
-                if (m.from !== 'team-lead') {
-                    logForDebugging(`[InboxPoller] Ignoring mode set request from non-team-lead: ${m.from}`);
-                    continue;
-                }
-                const parsed = isModeSetRequest(m.text);
-                if (!parsed) {
-                    logForDebugging(`[InboxPoller] Failed to parse mode set request: ${m.text.substring(0, 100)}`);
-                    continue;
-                }
-                const targetMode = permissionModeFromString(parsed.mode);
-                logForDebugging(`[InboxPoller] Applying mode change from team-lead: ${targetMode}`);
-                // Update local permission context
-                setAppState(prev => ({
-                    ...prev,
-                    toolPermissionContext: applyPermissionUpdate(prev.toolPermissionContext, {
-                        type: 'setMode',
-                        mode: toExternalPermissionMode(targetMode),
-                        destination: 'session',
-                    }),
-                }));
-                // Update config.json so team lead can see the new mode
-                const teamName = currentAppState.teamContext?.teamName;
-                const agentName = getAgentName();
-                if (teamName && agentName) {
-                    setMemberMode(teamName, agentName, targetMode);
-                }
-            }
-        }
-        // Handle plan approval requests (leader side) - auto-approve and write response to teammate inbox
-        if (planApprovalRequests.length > 0 &&
-            isTeamLead(currentAppState.teamContext)) {
-            logForDebugging(`[InboxPoller] Found ${planApprovalRequests.length} plan approval request(s), auto-approving`);
-            const teamName = currentAppState.teamContext?.teamName;
-            const leaderExternalMode = toExternalPermissionMode(currentAppState.toolPermissionContext.mode);
-            const modeToInherit = leaderExternalMode === 'plan' ? 'default' : leaderExternalMode;
-            for (const m of planApprovalRequests) {
-                const parsed = isPlanApprovalRequest(m.text);
-                if (!parsed)
-                    continue;
-                // Write approval response to teammate's inbox
-                const approvalResponse = {
-                    type: 'plan_approval_response',
-                    requestId: parsed.requestId,
-                    approved: true,
-                    timestamp: new Date().toISOString(),
-                    permissionMode: modeToInherit,
-                };
-                void writeToMailbox(m.from, {
-                    from: TEAM_LEAD_NAME,
-                    text: jsonStringify(approvalResponse),
-                    timestamp: new Date().toISOString(),
-                }, teamName);
-                // Update in-process teammate task state if applicable
-                const taskId = findInProcessTeammateTaskId(m.from, currentAppState);
-                if (taskId) {
-                    handlePlanApprovalResponse(taskId, {
-                        type: 'plan_approval_response',
-                        requestId: parsed.requestId,
-                        approved: true,
-                        timestamp: new Date().toISOString(),
-                        permissionMode: modeToInherit,
-                    }, setAppState);
-                }
-                logForDebugging(`[InboxPoller] Auto-approved plan from ${m.from} (request ${parsed.requestId})`);
-                // Still pass through as a regular message so the model has context
-                // about what the teammate is doing, but the approval is already sent
-                regularMessages.push(m);
-            }
-        }
-        // Handle shutdown requests (teammate side) - preserve JSON for UI rendering
-        if (shutdownRequests.length > 0 && isTeammate()) {
-            logForDebugging(`[InboxPoller] Found ${shutdownRequests.length} shutdown request(s)`);
-            // Pass through shutdown requests - the UI component will render them nicely
-            // and the model will receive instructions via the tool prompt documentation
-            for (const m of shutdownRequests) {
-                regularMessages.push(m);
-            }
-        }
-        // Handle shutdown approvals (leader side) - kill the teammate's pane
-        if (shutdownApprovals.length > 0 &&
-            isTeamLead(currentAppState.teamContext)) {
-            logForDebugging(`[InboxPoller] Found ${shutdownApprovals.length} shutdown approval(s)`);
-            for (const m of shutdownApprovals) {
-                const parsed = isShutdownApproved(m.text);
-                if (!parsed)
-                    continue;
-                // Kill the pane if we have the info (pane-based teammates)
-                if (parsed.paneId && parsed.backendType) {
-                    void (async () => {
-                        try {
-                            // Ensure backend classes are imported (no subprocess probes)
-                            await ensureBackendsRegistered();
-                            const insideTmux = await isInsideTmux();
-                            const backend = getBackendByType(parsed.backendType);
-                            const success = await backend?.killPane(parsed.paneId, !insideTmux);
-                            logForDebugging(`[InboxPoller] Killed pane ${parsed.paneId} for ${parsed.from}: ${success}`);
-                        }
-                        catch (error) {
-                            logForDebugging(`[InboxPoller] Failed to kill pane for ${parsed.from}: ${error}`);
-                        }
-                    })();
-                }
-                // Remove the teammate from teamContext.teammates so the count is accurate
-                const teammateToRemove = parsed.from;
-                if (teammateToRemove && currentAppState.teamContext?.teammates) {
-                    // Find the teammate ID by name
-                    const teammateId = Object.entries(currentAppState.teamContext.teammates).find(([, t]) => t.name === teammateToRemove)?.[0];
-                    if (teammateId) {
-                        // Remove from team file (leader owns team file mutations)
-                        const teamName = currentAppState.teamContext?.teamName;
-                        if (teamName) {
-                            removeTeammateFromTeamFile(teamName, {
-                                agentId: teammateId,
-                                name: teammateToRemove,
-                            });
-                        }
-                        // Unassign tasks and build notification message
-                        const { notificationMessage } = teamName
-                            ? await unassignTeammateTasks(teamName, teammateId, teammateToRemove, 'shutdown')
-                            : { notificationMessage: `${teammateToRemove} has shut down.` };
-                        setAppState(prev => {
-                            if (!prev.teamContext?.teammates)
-                                return prev;
-                            if (!(teammateId in prev.teamContext.teammates))
-                                return prev;
-                            const { [teammateId]: _, ...remainingTeammates } = prev.teamContext.teammates;
-                            // Mark the teammate's task as completed so hasRunningTeammates
-                            // becomes false and the spinner stops. Without this, out-of-process
-                            // (tmux) teammate tasks stay status:'running' forever because
-                            // only in-process teammates have a runner that sets 'completed'.
-                            const updatedTasks = { ...prev.tasks };
-                            for (const [tid, task] of Object.entries(updatedTasks)) {
-                                if (isInProcessTeammateTask(task) &&
-                                    task.identity.agentId === teammateId) {
-                                    updatedTasks[tid] = {
-                                        ...task,
-                                        status: 'completed',
-                                        endTime: Date.now(),
-                                    };
-                                }
-                            }
-                            return {
-                                ...prev,
-                                tasks: updatedTasks,
-                                teamContext: {
-                                    ...prev.teamContext,
-                                    teammates: remainingTeammates,
-                                },
-                                inbox: {
-                                    messages: [
-                                        ...prev.inbox.messages,
-                                        {
-                                            id: randomUUID(),
-                                            from: 'system',
-                                            text: jsonStringify({
-                                                type: 'teammate_terminated',
-                                                message: notificationMessage,
-                                            }),
-                                            timestamp: new Date().toISOString(),
-                                            status: 'pending',
-                                        },
-                                    ],
-                                },
-                            };
-                        });
-                        logForDebugging(`[InboxPoller] Removed ${teammateToRemove} (${teammateId}) from teamContext`);
-                    }
-                }
-                // Pass through for UI rendering - the component will render it nicely
-                regularMessages.push(m);
-            }
-        }
-        // Process regular teammate messages (existing logic)
-        if (regularMessages.length === 0) {
-            // No regular messages, but we may have processed non-regular messages
-            // (permissions, shutdown requests, etc.) above — mark those as read.
-            markRead();
-            return;
-        }
-        // Format messages with XML wrapper for Claude (include color if available)
-        // Transform plan approval requests to include instructions for Claude
-        const formatted = regularMessages
-            .map(m => {
-            const colorAttr = m.color ? ` color="${m.color}"` : '';
-            const summaryAttr = m.summary ? ` summary="${m.summary}"` : '';
-            const messageContent = m.text;
-            return `<${TEAMMATE_MESSAGE_TAG} teammate_id="${m.from}"${colorAttr}${summaryAttr}>\n${messageContent}\n</${TEAMMATE_MESSAGE_TAG}>`;
-        })
-            .join('\n\n');
-        // Helper to queue messages in AppState for later delivery
-        const queueMessages = () => {
-            setAppState(prev => ({
-                ...prev,
-                inbox: {
-                    messages: [
-                        ...prev.inbox.messages,
-                        ...regularMessages.map(m => ({
-                            id: randomUUID(),
-                            from: m.from,
-                            text: m.text,
-                            timestamp: m.timestamp,
-                            status: 'pending',
-                            color: m.color,
-                            summary: m.summary,
-                        })),
-                    ],
-                },
-            }));
-        };
-        if (!isLoading && !focusedInputDialog) {
-            // IDLE: Submit as new turn immediately
-            logForDebugging(`[InboxPoller] Session idle, submitting immediately`);
-            const submitted = onSubmitTeammateMessage(formatted);
-            if (!submitted) {
-                // Submission rejected (query already running), queue for later
-                logForDebugging(`[InboxPoller] Submission rejected, queuing for later delivery`);
-                queueMessages();
-            }
-        }
-        else {
-            // BUSY: Add to inbox queue for UI display + later delivery
-            logForDebugging(`[InboxPoller] Session busy, queuing for later delivery`);
-            queueMessages();
-        }
-        // Mark messages as read only after they have been successfully delivered
-        // or reliably queued in AppState. This prevents permanent message loss
-        // when the session is busy — if we crash before this point, the messages
-        // will be re-read on the next poll cycle instead of being silently dropped.
-        markRead();
-    }, [
-        enabled,
-        isLoading,
-        focusedInputDialog,
-        onSubmitTeammateMessage,
-        setAppState,
-        terminal,
-        store,
-    ]);
-    // When session becomes idle, deliver any pending messages and clean up processed ones
-    useEffect(() => {
-        if (!enabled)
-            return;
-        // Skip if busy or in a dialog
-        if (isLoading || focusedInputDialog) {
-            return;
-        }
-        // Use ref to avoid dependency on appState object (prevents infinite loop)
-        const currentAppState = store.getState();
-        const agentName = getAgentNameToPoll(currentAppState);
-        if (!agentName)
-            return;
-        const pendingMessages = currentAppState.inbox.messages.filter(m => m.status === 'pending');
-        const processedMessages = currentAppState.inbox.messages.filter(m => m.status === 'processed');
-        // Clean up processed messages (they were already delivered mid-turn as attachments)
-        if (processedMessages.length > 0) {
-            logForDebugging(`[InboxPoller] Cleaning up ${processedMessages.length} processed message(s) that were delivered mid-turn`);
-            const processedIds = new Set(processedMessages.map(m => m.id));
-            setAppState(prev => ({
-                ...prev,
-                inbox: {
-                    messages: prev.inbox.messages.filter(m => !processedIds.has(m.id)),
-                },
-            }));
-        }
-        // No pending messages to deliver
-        if (pendingMessages.length === 0)
-            return;
-        logForDebugging(`[InboxPoller] Session idle, delivering ${pendingMessages.length} pending message(s)`);
-        // Format messages with XML wrapper for Claude (include color if available)
-        const formatted = pendingMessages
-            .map(m => {
-            const colorAttr = m.color ? ` color="${m.color}"` : '';
-            const summaryAttr = m.summary ? ` summary="${m.summary}"` : '';
-            return `<${TEAMMATE_MESSAGE_TAG} teammate_id="${m.from}"${colorAttr}${summaryAttr}>\n${m.text}\n</${TEAMMATE_MESSAGE_TAG}>`;
-        })
-            .join('\n\n');
-        // Try to submit - only clear messages if successful
-        const submitted = onSubmitTeammateMessage(formatted);
-        if (submitted) {
-            // Clear the specific messages we just submitted by their IDs
-            const submittedIds = new Set(pendingMessages.map(m => m.id));
-            setAppState(prev => ({
-                ...prev,
-                inbox: {
-                    messages: prev.inbox.messages.filter(m => !submittedIds.has(m.id)),
-                },
-            }));
-        }
-        else {
-            logForDebugging(`[InboxPoller] Submission rejected, keeping messages queued`);
-        }
-    }, [
-        enabled,
-        isLoading,
-        focusedInputDialog,
-        onSubmitTeammateMessage,
-        setAppState,
-        inboxMessageCount,
-        store,
-    ]);
-    // Poll if running as a teammate or as a team lead
-    const shouldPoll = enabled && !!getAgentNameToPoll(store.getState());
-    useInterval(() => void poll(), shouldPoll ? INBOX_POLL_INTERVAL_MS : null);
-    // Initial poll on mount (only once)
-    const hasDoneInitialPollRef = useRef(false);
-    useEffect(() => {
-        if (!enabled)
-            return;
-        if (hasDoneInitialPollRef.current)
-            return;
-        // Use store.getState() to avoid dependency on appState object
-        if (getAgentNameToPoll(store.getState())) {
-            hasDoneInitialPollRef.current = true;
-            void poll();
-        }
-        // Note: poll uses store.getState() (not appState) so it won't re-run on appState changes
-        // The ref guard is a safety measure to ensure initial poll only happens once
-    }, [enabled, poll, store]);
-}