Files
EJClaw/src/message-runtime-group-processing.ts
Codex f944f97e54 feat: usage-alignment hold (04-08 KST daily + one-off hold until a set time)
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>
2026-10-16 05:54:39 +09:00

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,
},
);
}