Method handleCodexEvent

cli/src/codex/codexRemoteLauncher.ts:1959–2476

(msg: Record<string, unknown>)

        let codexEventQueue: Promise<void> | null = null;

        const handleCodexEvent = async (msg: Record<string, unknown>): Promise<void> => {
            const msgType = asString(msg.type);
            if (!msgType) return;
            const eventTurnId = asString(msg.turn_id ?? msg.turnId);
            const eventThreadId = asString(msg.thread_id ?? msg.threadId);
            const isTerminalEvent = msgType === 'task_complete' || msgType === 'turn_aborted' || msgType === 'task_failed';
            const suppressReadyForThisTerminalEvent = isTerminalEvent
                ? consumeInterruptedTurnReadySuppression(eventTurnId)
                : false;

            if (msgType === 'thread_started') {
                const threadId = asString(msg.thread_id ?? msg.threadId);
                if (threadId) {
                    if (!this.currentThreadId || this.currentThreadId === threadId) {
                        this.currentThreadId = threadId;
                        session.onSessionFound(threadId);
                    } else {
                        logger.debug(
                            `[Codex] Ignoring thread_started for non-active thread; ` +
                            `eventThreadId=${threadId}, activeThread=${this.currentThreadId}`
                        );
                    }
                }
                return;
            }

            if (msgType === 'thread_compacted') {
                completeCompactRecovery(eventThreadId);
                return;
            }

            if (eventThreadId && this.currentThreadId && eventThreadId !== this.currentThreadId) {
                logger.debug(
                    `[Codex] Routing event from non-active thread into agent trace; ` +
                    `type=${msgType}, eventThreadId=${eventThreadId}, activeThread=${this.currentThreadId}`
                );
                if (msgType === 'task_started') {
                    if (eventTurnId) {
                        this.activeChildTurns.set(eventThreadId, eventTurnId);
                    } else {
                        logger.debug(`[Codex] Child task_started missing turn id; threadId=${eventThreadId}`);
                    }
                    linkPendingAgentStartFromChildTask(eventThreadId);
                } else if (isTerminalEvent) {
                    this.activeChildTurns.delete(eventThreadId);
                }
                handleChildCodexEvent(eventThreadId, msg);
                return;
            }

            if (!eventThreadId && this.currentThreadId && isScopeSensitiveCodexEvent(msgType) && hasKnownChildAgents()) {
                logger.debug(
                    `[Codex] Dropping unscoped scope-sensitive event while child agents are active; ` +
                    `type=${msgType}, activeThread=${this.currentThreadId}`
                );
                return;
            }