import { getLatestOpenPairedTaskForChat, getMessagesSinceSeq, getOpenWorkItemForChat, markWorkItemDelivered, type WorkItem, } from './db.js'; import { SERVICE_SESSION_SCOPE } from './config.js'; import { resolveRuntimeAttachmentBaseDirs } from './attachment-base-dirs.js'; import { enqueueGenericFollowUpAfterDeliveryRetry as enqueueDeliveryRetryFollowUp } from './message-runtime-dispatch.js'; import { processOpenWorkItemDelivery } from './message-runtime-delivery.js'; import { runPendingPairedTurnIfNeeded, runQueuedGroupTurn, } from './message-runtime-queue.js'; import { advanceLastAgentCursor, filterLoopingPairedBotMessages, getProcessableMessages, shouldSkipBotOnlyCollaboration, } from './message-runtime-rules.js'; import { resolveOwnerTaskForHumanMessage } from './paired-execution-context.js'; import { hasReviewerLease } from './service-routing.js'; import { getFixedRoleChannelName, getMissingRoleChannelMessage, } from './message-runtime-shared.js'; import { resolvePairedRoleChannels } from './message-runtime-role-channels.js'; import { getFreshHumanPreflightMessages, hasHumanMessageAfterWorkItem, } from './message-runtime-preflight-messages.js'; import { deliverCanonicalOutboundMessage } from './ipc-outbound-delivery.js'; import { isReloginRequired, RELOGIN_REQUIRED_MESSAGE, } from './token-refresh.js'; import { findChannel, formatMessages } from './router.js'; import { findStopRequest, stopRoomWorkIfRequested, type RoomStopResult, } from './room-stop.js'; import { isRoomPausedForClaudeUsage, isRoomPausedOnlyForAlignment, releaseRoomFromClaudeUsagePause, } from './claude-usage-pause.js'; import { getUsageAlignmentHold, grantUsageAlignmentBypass, hasUrgentMention, } from './usage-alignment-hold.js'; import { reopenReviewSkippedTaskForReview } from './review-request-gate.js'; import { createScopedLogger, logger } from './logger.js'; import type { GroupQueue, GroupRunContext } from './group-queue.js'; import type { ExecuteTurnFn, RoleToChannelMap, } from './message-runtime-types.js'; import type { Channel, NewMessage, PairedTask, RegisteredGroup, } from './types.js'; interface ProcessGroupMessagesDeps { assistantName: string; failureFinalText: string; timezone: string; channels: Channel[]; queue: Pick; getRoomBindings: () => Record; getLastAgentTimestamps: () => Record; saveState: () => void; executeTurn: ExecuteTurnFn; openContinuation: (chatJid: string) => void; isDuplicateOfLastBotFinal: (chatJid: string, text: string) => boolean; labelPairedSenders: (chatJid: string, messages: NewMessage[]) => NewMessage[]; } interface RuntimeContext { chatJid: string; runId: string; group: RegisteredGroup; channel: Channel; log: ReturnType; roleToChannel: RoleToChannelMap; } interface PendingDeliveryState { pendingTask: PairedTask | null; openWorkItem: WorkItem | undefined; } export function createProcessGroupMessages( args: ProcessGroupMessagesDeps, ): (chatJid: string, context: GroupRunContext) => Promise { return async (chatJid, context): Promise => { const runtime = resolveRuntimeContext(args, chatJid, context.runId); if (!runtime) return true; const pendingDelivery = resolvePendingDeliveryState(args, runtime); const deliveryOutcome = await deliverPendingWorkItem( args, runtime, pendingDelivery, ); if (deliveryOutcome !== null) { return deliveryOutcome; } return processMissedMessages(args, runtime); }; } function resolveRuntimeContext( args: ProcessGroupMessagesDeps, chatJid: string, runId: string, ): RuntimeContext | null { const group = args.getRoomBindings()[chatJid]; if (!group) return null; const log = createScopedLogger({ chatJid, groupName: group.name, groupFolder: group.folder, runId, }); const channel = findChannel(args.channels, chatJid); if (!channel) { log.warn('No channel owns JID, skipping messages'); return null; } const { roleToChannel, reviewerChannelName, foundReviewerChannel, arbiterChannelName, foundArbiterChannel, } = resolvePairedRoleChannels(args.channels, channel); if (hasReviewerLease(chatJid)) { log.info( { reviewerChannelName, foundChannel: foundReviewerChannel?.name ?? null, arbiterChannelName, foundArbiterChannel: foundArbiterChannel?.name ?? null, availableChannels: args.channels.map((c) => c.name), }, 'Paired room reviewer/arbiter channel resolution', ); } return { chatJid, runId, group, channel, log, roleToChannel }; } function resolvePendingDeliveryState( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, ): PendingDeliveryState { const { chatJid, channel, group, log } = runtime; let pendingTask: PairedTask | null = hasReviewerLease(chatJid) ? (getLatestOpenPairedTaskForChat(chatJid) ?? null) : null; let openWorkItem = getOpenWorkItemForChat(chatJid, SERVICE_SESSION_SCOPE); if (openWorkItem?.delivery_role !== 'owner' || !pendingTask) { return { pendingTask, openWorkItem }; } const freshHumanMessages = getFreshHumanPreflightMessages({ chatJid, channel, lastAgentTimestamps: args.getLastAgentTimestamps(), assistantName: args.assistantName, failureFinalText: args.failureFinalText, }); if (pendingTask.status === 'merge_ready' && freshHumanMessages.length > 0) { const resolvedTask = resolveOwnerTaskForHumanMessage({ group, chatJid, existingTask: pendingTask, }); pendingTask = resolvedTask.task ?? null; if (resolvedTask.supersededTask) { markWorkItemDelivered(openWorkItem.id); log.info( { chatJid, workItemId: openWorkItem.id, supersededTaskId: resolvedTask.supersededTask.id, replacementTaskId: resolvedTask.task?.id ?? null, }, 'Suppressed stale owner delivery retry because a new human message superseded the merge_ready task', ); openWorkItem = undefined; } } else if ( pendingTask.status === 'active' && hasHumanMessageAfterWorkItem(openWorkItem, freshHumanMessages) ) { markWorkItemDelivered(openWorkItem.id); log.info( { chatJid, workItemId: openWorkItem.id, taskId: pendingTask.id, taskStatus: pendingTask.status, workItemEndSeq: openWorkItem.end_seq ?? null, freshHumanMessageCount: freshHumanMessages.length, }, 'Suppressed stale owner delivery retry because a new human message arrived while the paired task was still active', ); openWorkItem = undefined; } return { pendingTask, openWorkItem }; } async function deliverPendingWorkItem( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, pendingDelivery: PendingDeliveryState, ): Promise { const { chatJid, runId, group, channel, roleToChannel, log } = runtime; const openWorkItemOutcome = await processOpenWorkItemDelivery({ chatJid, runId, openWorkItem: pendingDelivery.openWorkItem, pendingTask: pendingDelivery.pendingTask, channel, roleToChannel, log, attachmentBaseDirs: resolveRuntimeAttachmentBaseDirs(group), isPairedRoom: hasReviewerLease(chatJid), getMissingRoleChannelMessage, isDuplicateOfLastBotFinal: args.isDuplicateOfLastBotFinal, openContinuation: args.openContinuation, enqueueFollowUpAfterDeliveryRetry: ({ deliveryRole, pendingTask, workItemId, }) => enqueueDeliveryRetryFollowUp({ chatJid, runId, deliveryRole, pendingTask, workItemId, log, enqueueMessageCheck: () => args.queue.enqueueMessageCheck(chatJid), }), }); if (openWorkItemOutcome === 'failed') { return false; } if (openWorkItemOutcome === 'delivered') { return true; } return null; } async function processMissedMessages( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, ): Promise { while (true) { const rawMissedMessages = getMessagesSinceSeq( runtime.chatJid, args.getLastAgentTimestamps()[runtime.chatJid] || '0', args.assistantName, ); const missedMessages = filterLoopingPairedBotMessages( runtime.chatJid, getProcessableMessages( runtime.chatJid, rawMissedMessages, runtime.channel, ), args.failureFinalText, ); // Urgent bypass of the usage-alignment hold: an @-mention lets this room // run until the hold ends. const alignmentHold = getUsageAlignmentHold(); if (alignmentHold && hasUrgentMention(missedMessages)) { grantUsageAlignmentBypass(runtime.chatJid, alignmentHold.until); if (isRoomPausedOnlyForAlignment(runtime.chatJid)) { releaseRoomFromClaudeUsagePause(runtime.chatJid); } runtime.log.info( { until: alignmentHold.until.toISOString() }, 'Urgent mention; room bypasses the usage alignment hold', ); } // A stop request still goes through, so the user can drop paused work. if ( isRoomPausedForClaudeUsage(runtime.chatJid) && !findStopRequest(missedMessages) ) { runtime.log.info( { pendingMessages: missedMessages.length }, 'Room is paused by the Claude usage limit; leaving its work for the resume', ); return true; } if (missedMessages.length === 0) { return handleNoMissedMessages(args, runtime, rawMissedMessages); } const pendingTurnOutcome = await runBotOnlyPendingTurn( args, runtime, rawMissedMessages, missedMessages, ); if (pendingTurnOutcome !== null) { return pendingTurnOutcome; } if (shouldSkipBotOnlyCollaboration(runtime.chatJid, missedMessages)) { advancePastBotOnlyCollaboration(args, runtime, missedMessages); return true; } const stopResult = await runStopRequestGate(args, runtime, missedMessages); if (stopResult.stopped) { if (stopResult.hasMessagesAfterStop) continue; return true; } const reviewRequestOutcome = await runReviewRequestGate( args, runtime, missedMessages, ); if (reviewRequestOutcome !== null) { return reviewRequestOutcome; } const reloginOutcome = await runReloginRequiredGate( args, runtime, missedMessages, ); if (reloginOutcome !== null) { return reloginOutcome; } return runQueuedGroupTurn({ chatJid: runtime.chatJid, group: runtime.group, runId: runtime.runId, log: runtime.log, timezone: args.timezone, missedMessages, task: hasReviewerLease(runtime.chatJid) ? (getLatestOpenPairedTaskForChat(runtime.chatJid) ?? null) : undefined, roleToChannel: runtime.roleToChannel, ownerChannel: runtime.channel, lastAgentTimestamps: args.getLastAgentTimestamps(), saveState: args.saveState, executeTurn: args.executeTurn, getFixedRoleChannelName, labelPairedSenders: args.labelPairedSenders, formatMessages, }); } } async function handleNoMissedMessages( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, rawMissedMessages: NewMessage[], ): Promise { const pendingTurnOutcome = await runPendingPairedTurnIfNeeded({ chatJid: runtime.chatJid, group: runtime.group, runId: runtime.runId, log: runtime.log, timezone: args.timezone, task: hasReviewerLease(runtime.chatJid) ? getLatestOpenPairedTaskForChat(runtime.chatJid) : null, rawMissedMessages, saveState: args.saveState, lastAgentTimestamps: args.getLastAgentTimestamps(), executeTurn: args.executeTurn, getFixedRoleChannelName, roleToChannel: runtime.roleToChannel, labelPairedSenders: args.labelPairedSenders, mode: 'idle', }); if (pendingTurnOutcome !== null) { return pendingTurnOutcome; } const lastIgnored = rawMissedMessages[rawMissedMessages.length - 1]; if (lastIgnored) { advanceLastAgentCursor( args.getLastAgentTimestamps(), args.saveState, runtime.chatJid, lastIgnored.timestamp, ); } return true; } function runBotOnlyPendingTurn( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, rawMissedMessages: NewMessage[], missedMessages: NewMessage[], ): Promise { return runPendingPairedTurnIfNeeded({ chatJid: runtime.chatJid, group: runtime.group, runId: runtime.runId, log: runtime.log, timezone: args.timezone, task: hasReviewerLease(runtime.chatJid) ? getLatestOpenPairedTaskForChat(runtime.chatJid) : null, rawMissedMessages, saveState: args.saveState, lastAgentTimestamps: args.getLastAgentTimestamps(), executeTurn: args.executeTurn, getFixedRoleChannelName, roleToChannel: runtime.roleToChannel, labelPairedSenders: args.labelPairedSenders, mode: 'bot-only', missedMessages, }); } function advancePastBotOnlyCollaboration( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, missedMessages: NewMessage[], ): void { const lastMessage = missedMessages[missedMessages.length - 1]; if (lastMessage?.seq != null) { advanceLastAgentCursor( args.getLastAgentTimestamps(), args.saveState, runtime.chatJid, lastMessage.seq, ); } runtime.log.info( 'Skipping bot-only collaboration because no recent human message exists', ); } /** * When Claude OAuth auto-refresh has permanently given up (login lost and the * refresh token is dead — see token-refresh.ts), don't spawn a doomed agent. * Instead reply once, in this chat, asking the user to re-login, then advance * the cursor so a still-logged-out bot doesn't re-notify on every poll. The * next fresh incoming request re-triggers the notice. Recovers automatically * once a manual re-login writes a valid token (isReloginRequired() clears). * * Returns true when the notice was sent (turn handled), null to fall through. */ async function runReloginRequiredGate( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, missedMessages: NewMessage[], ): Promise { // Only claude-code turns depend on the Claude OAuth token. Codex-backed // groups authenticate separately and must not be blocked here. const agentType = runtime.group.agentType ?? 'claude-code'; if (agentType !== 'claude-code') return null; if (!isReloginRequired()) return null; await deliverRoomNotice(args, runtime.chatJid, RELOGIN_REQUIRED_MESSAGE); const lastMessage = missedMessages[missedMessages.length - 1]; if (lastMessage?.seq != null) { advanceLastAgentCursor( args.getLastAgentTimestamps(), args.saveState, runtime.chatJid, lastMessage.seq, ); } runtime.log.warn( 'Claude OAuth login lost (gave up refreshing) — asked user to re-login instead of running the agent', ); return true; } /** * "검토해줘" right after an answer whose review was skipped: run the reviewer * on that answer (the task is reopened) instead of starting a new owner turn. * Returns null when the message is not such a request. */ async function runReviewRequestGate( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, missedMessages: NewMessage[], ): Promise { const task = reopenReviewSkippedTaskForReview({ chatJid: runtime.chatJid, messages: missedMessages, }); if (!task) return null; const lastMessage = missedMessages[missedMessages.length - 1]; if (lastMessage?.seq != null) { advanceLastAgentCursor( args.getLastAgentTimestamps(), args.saveState, runtime.chatJid, lastMessage.seq, ); } const outcome = await runPendingPairedTurnIfNeeded({ chatJid: runtime.chatJid, group: runtime.group, runId: runtime.runId, log: runtime.log, timezone: args.timezone, task, rawMissedMessages: [], saveState: args.saveState, lastAgentTimestamps: args.getLastAgentTimestamps(), executeTurn: args.executeTurn, getFixedRoleChannelName, roleToChannel: runtime.roleToChannel, labelPairedSenders: args.labelPairedSenders, mode: 'idle', }); return outcome ?? true; } /** * A stop request that reaches a queued run without having been handled by the * message loop (e.g. it was pending across a restart) still stops the room's * open paired task instead of being sent to the agent as a prompt. */ async function runStopRequestGate( args: ProcessGroupMessagesDeps, runtime: RuntimeContext, missedMessages: NewMessage[], ): Promise { return stopRoomWorkIfRequested({ chatJid: runtime.chatJid, group: runtime.group, channel: runtime.channel, messages: missedMessages, assistantName: args.assistantName, lastAgentTimestamps: args.getLastAgentTimestamps(), saveState: args.saveState, controls: { // This run is the room's queued work; it has not started an agent yet. hasQueuedWork: () => false, stopRunningAgent: () => false, sendReply: (chatJid, text) => deliverRoomNotice(args, chatJid, text), }, }); } export async function deliverRoomNotice( deps: Pick, chatJid: string, text: string, ): Promise { await deliverCanonicalOutboundMessage( { jid: chatJid, text }, { channels: deps.channels, roomBindings: deps.getRoomBindings, log: logger, }, ); }