let turnCompletionIdleTimer: ReturnType<typeof setTimeout> | undefined;

let turnCompletionIdleWatchArmed = false;

let turnCompletionIdleWatchPinnedByTerminalError = false;

let turnCompletionIdleTimeoutOverrideMs: number | undefined;

let turnAssistantCompletionIdleTimer: ReturnType<typeof setTimeout> | undefined;

let turnAssistantCompletionIdleWatchArmed = false;

let turnAssistantCompletionLastActivityAt = Date.now();

) {

return;

}

const timeoutMs = turnCompletionIdleTimeoutOverrideMs ?? turnCompletionIdleTimeoutMs;

const idleMs = Math.max(0, Date.now() - turnCompletionLastActivityAt);

if (idleMs < turnCompletionIdleTimeoutMs) {

if (idleMs < timeoutMs) {

scheduleTurnCompletionIdleWatch();

return;

}

threadId: thread.threadId,

turnId,

idleMs,

timeoutMs: turnCompletionIdleTimeoutMs,

timeoutMs,

lastActivityReason: turnCompletionLastActivityReason,

...turnCompletionLastActivityDetails,

});

embeddedAgentLog.warn("codex app-server turn idle timed out waiting for completion", {

threadId: thread.threadId,

turnId,

idleMs,

timeoutMs: turnCompletionIdleTimeoutMs,

timeoutMs,

lastActivityReason: turnCompletionLastActivityReason,

...turnCompletionLastActivityDetails,

});

return;

}

const elapsedMs = Math.max(0, Date.now() - turnCompletionLastActivityAt);

const delayMs = Math.max(1, turnCompletionIdleTimeoutMs - elapsedMs);

const timeoutMs = turnCompletionIdleTimeoutOverrideMs ?? turnCompletionIdleTimeoutMs;

const delayMs = Math.max(1, timeoutMs - elapsedMs);

turnCompletionIdleTimer = setTimeout(fireTurnCompletionIdleTimeout, delayMs);

turnCompletionIdleTimer.unref?.();

}

turnCompletionLastActivityAt = Date.now();

turnCompletionLastActivityReason = reason;

turnCompletionLastActivityDetails = options?.details;

turnCompletionIdleTimeoutOverrideMs = undefined;

if (options?.attemptProgress) {

turnAttemptLastProgressAt = turnCompletionLastActivityAt;

turnAttemptLastProgressReason = reason;

const disarmTurnCompletionIdleWatch = () => {

turnCompletionIdleWatchArmed = false;

turnCompletionIdleWatchPinnedByTerminalError = false;

turnCompletionIdleTimeoutOverrideMs = undefined;

clearTurnCompletionIdleTimer();

};

scheduleTurnAssistantCompletionIdleWatch();

};

const armTurnCompletionIdleWatch = (options?: { pinnedByTerminalError?: boolean }) => {

const armTurnCompletionIdleWatch = (options?: {

pinnedByTerminalError?: boolean;

timeoutMs?: number;

}) => {

turnCompletionIdleWatchArmed = true;

turnCompletionIdleWatchPinnedByTerminalError = options?.pinnedByTerminalError === true;

turnCompletionIdleTimeoutOverrideMs =

options?.timeoutMs !== undefined ? Math.max(1, Math.floor(options.timeoutMs)) : undefined;

scheduleTurnCompletionIdleWatch();

};

notification,

turnCrossedToolHandoff,

);

const postToolRawAssistantCompletionNeedsTerminalGuard =

isCurrentTurnNotification &&

turnCrossedToolHandoff &&

isRawAssistantCompletionNotification(notification) &&

activeTurnItemIds.size === 0;

const shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem =

isCurrentTurnNotification &&

notification.method === "item/completed" &&

disarmTurnAssistantCompletionIdleWatch();

} else if (isCurrentTurnNotification && assistantCompletionCanRelease) {

armTurnAssistantCompletionIdleWatch(describeNotificationActivity(notification));

} else if (postToolRawAssistantCompletionNeedsTerminalGuard) {

armTurnCompletionIdleWatch({ timeoutMs: turnAssistantCompletionIdleTimeoutMs });

} else if (unblockedAssistantCompletionRelease) {

armTurnAssistantCompletionIdleWatch(describeNotificationActivity(notification));

} else if (shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) {

isCurrentTurnNotification &&

!trackedDynamicToolCompletion &&

!rawToolOutputCompletion &&

!postToolRawAssistantCompletionNeedsTerminalGuard &&

!shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem

) {

// The short completion-idle watchdog guards blind gaps after Codex