Bring back the dawn gap that keeps Claude's 5h windows on the primer
slots (08-13, 13-18, 18-23, 23-04): it was dropped by the 2026-06-08
upstream merge (1dd948a).
- usage-alignment-hold.ts: hold during 04:00-08:00 KST, or until the ISO
time in router_state `usage_alignment_hold_until` (ignored once past,
so only the daily gap remains). A one-off end inside the gap runs on to
08:00.
- Claude turns during a hold pause through the existing usage-pause path
(messages kept, room resumed at the hold end) with an alignment notice.
The stored pause is marked alignmentOnly so it does not act as an
account-wide usage limit.
- Due Claude scheduled tasks stay due until the hold ends (Codex and
GitHub CI watchers are not held).
- Urgent bypass like the old gate: a human @-mention lets that room run
until the hold ends.
- Tests stub the wall-clock hold in test/vitest-env.ts so the suite does
not pause when run between 04 and 08 KST.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
585 lines
17 KiB
TypeScript
585 lines
17 KiB
TypeScript
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<GroupQueue, 'enqueueMessageCheck'>;
|
|
getRoomBindings: () => Record<string, RegisteredGroup>;
|
|
getLastAgentTimestamps: () => Record<string, string>;
|
|
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<typeof createScopedLogger>;
|
|
roleToChannel: RoleToChannelMap;
|
|
}
|
|
|
|
interface PendingDeliveryState {
|
|
pendingTask: PairedTask | null;
|
|
openWorkItem: WorkItem | undefined;
|
|
}
|
|
|
|
export function createProcessGroupMessages(
|
|
args: ProcessGroupMessagesDeps,
|
|
): (chatJid: string, context: GroupRunContext) => Promise<boolean> {
|
|
return async (chatJid, context): Promise<boolean> => {
|
|
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<boolean | null> {
|
|
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<boolean> {
|
|
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<boolean> {
|
|
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<boolean | null> {
|
|
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<boolean | null> {
|
|
// 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<boolean | null> {
|
|
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<RoomStopResult> {
|
|
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<ProcessGroupMessagesDeps, 'channels' | 'getRoomBindings'>,
|
|
chatJid: string,
|
|
text: string,
|
|
): Promise<void> {
|
|
await deliverCanonicalOutboundMessage(
|
|
{ jid: chatJid, text },
|
|
{
|
|
channels: deps.channels,
|
|
roomBindings: deps.getRoomBindings,
|
|
log: logger,
|
|
},
|
|
);
|
|
}
|