@bbigbang/core 0.1.0

package/dist/web/taskThreadFollowups.js

@@ -0,0 +1,599 @@
+import { randomUUID } from 'node:crypto';
+import { log } from '@bbigbang/runtime-acp';
+import { buildChannelSurfaceActivationEnvelope, buildDirectSurfaceActivationEnvelope, } from './activationContext.js';
+import { getExpectedBootstrapStopReason } from './planApprovalState.js';
+import { getBoundTaskForThread, listThreadCollaborationParticipants } from './threadTaskBindings.js';
+export const TASK_THREAD_FOLLOWUP_KIND = 'task_status_reminder';
+export const TASK_THREAD_FOLLOWUP_DELAY_MS = 10 * 60 * 1000;
+export const TASK_THREAD_FOLLOWUP_POLL_INTERVAL_MS = 30 * 1000;
+export const TASK_THREAD_FOLLOWUP_EVENT_METHOD = 'platform/task-thread-followup';
+function nextSyntheticRunEventSeq(db, runId) {
+    const row = db.prepare(`SELECT COALESCE(MAX(seq), 0) as maxSeq
+     FROM events
+     WHERE run_id = ?`).get(runId);
+    return (row?.maxSeq ?? 0) + 1;
+}
+function appendTaskThreadFollowupEvent(db, runId, payload) {
+    if (!runId)
+        return;
+    db.prepare(`INSERT INTO events(run_id, seq, method, payload_json, created_at)
+     VALUES(?, ?, ?, ?, ?)`).run(runId, nextSyntheticRunEventSeq(db, runId), TASK_THREAD_FOLLOWUP_EVENT_METHOD, JSON.stringify(payload), Date.now());
+}
+function isCancelStopReason(stopReason) {
+    return stopReason === 'cancelled' || stopReason === 'canceled';
+}
+function wasRunHandedOff(db, runId) {
+    return Boolean(db.prepare(`SELECT 1
+     FROM events
+     WHERE run_id = ?
+       AND method = 'platform/handoff'
+     LIMIT 1`).get(runId));
+}
+export function getRunSystemFollowupMetadata(db, runId) {
+    if (!runId)
+        return null;
+    const row = db.prepare(`SELECT activation_metadata_json as activationMetadataJson
+     FROM run_debug_inputs
+     WHERE run_id = ?
+     LIMIT 1`).get(runId);
+    if (!row?.activationMetadataJson)
+        return null;
+    try {
+        const parsed = JSON.parse(row.activationMetadataJson);
+        if (parsed?.systemFollowup?.kind === TASK_THREAD_FOLLOWUP_KIND
+            && typeof parsed.systemFollowup.followupId === 'string'
+            && parsed.systemFollowup.followupId.trim()
+            && typeof parsed.systemFollowup.taskId === 'string'
+            && parsed.systemFollowup.taskId.trim()
+            && typeof parsed.systemFollowup.channelId === 'string'
+            && parsed.systemFollowup.channelId.trim()
+            && typeof parsed.systemFollowup.threadRootId === 'string'
+            && parsed.systemFollowup.threadRootId.trim()) {
+            return {
+                kind: TASK_THREAD_FOLLOWUP_KIND,
+                followupId: parsed.systemFollowup.followupId.trim(),
+                taskId: parsed.systemFollowup.taskId.trim(),
+                channelId: parsed.systemFollowup.channelId.trim(),
+                threadRootId: parsed.systemFollowup.threadRootId.trim(),
+                ...(typeof parsed.systemFollowup.delayMs === 'number'
+                    && Number.isFinite(parsed.systemFollowup.delayMs)
+                    && parsed.systemFollowup.delayMs > 0
+                    ? { delayMs: parsed.systemFollowup.delayMs }
+                    : {}),
+                ...(typeof parsed.systemFollowup.baselineThreadSeq === 'number'
+                    && Number.isFinite(parsed.systemFollowup.baselineThreadSeq)
+                    && parsed.systemFollowup.baselineThreadSeq >= 0
+                    ? { baselineThreadSeq: parsed.systemFollowup.baselineThreadSeq }
+                    : {}),
+            };
+        }
+    }
+    catch {
+        // ignore malformed activation metadata
+    }
+    return null;
+}
+function loadLatestThreadSeq(db, params) {
+    const row = db.prepare(`SELECT COALESCE(MAX(seq), 0) as maxSeq
+     FROM channel_messages
+     WHERE channel_id = ? AND thread_root_id = ?`).get(params.channelId, params.threadRootId);
+    return row?.maxSeq ?? 0;
+}
+function resolveTaskThreadChannelId(params) {
+    if (params.threadKind === 'direct' && params.agentId) {
+        return `dm:${params.agentId}`;
+    }
+    return params.conversationChannelId;
+}
+function isBlockedTask(task) {
+    return Boolean(task && (task.blockedAt ?? task.blockedBy ?? task.blockedReason));
+}
+function shouldKeepTaskThreadFollowup(task) {
+    if (!task)
+        return false;
+    if (task.status !== 'todo' && task.status !== 'in_progress')
+        return false;
+    return !isBlockedTask(task);
+}
+function readFollowupDelayMsFromMetadata(metadata) {
+    const delayMs = metadata?.delayMs;
+    return typeof delayMs === 'number' && Number.isFinite(delayMs) && delayMs > 0
+        ? delayMs
+        : TASK_THREAD_FOLLOWUP_DELAY_MS;
+}
+function readFollowupDelayMsFromRow(row) {
+    const derivedDelay = row.scheduledFor - row.updatedAt;
+    return Number.isFinite(derivedDelay) && derivedDelay > 0
+        ? derivedDelay
+        : TASK_THREAD_FOLLOWUP_DELAY_MS;
+}
+function hasExternalThreadActivitySinceBaseline(params) {
+    if (!Number.isFinite(params.baselineThreadSeq))
+        return true;
+    return Boolean(params.db.prepare(`SELECT 1
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND thread_root_id = ?
+       AND seq > ?
+       AND (run_id IS NULL OR run_id != ?)
+     LIMIT 1`).get(params.channelId, params.threadRootId, params.baselineThreadSeq, params.currentRunId));
+}
+export function scheduleTaskThreadFollowupForRun(params) {
+    const { db, conversationId, runId } = params;
+    if (params.error)
+        return;
+    const systemFollowup = getRunSystemFollowupMetadata(db, runId);
+    if (params.stopReason === 'handoff' || isCancelStopReason(params.stopReason)) {
+        if (wasRunHandedOff(db, runId) || getExpectedBootstrapStopReason(db, runId) === 'handoff_bootstrap') {
+            return;
+        }
+        return;
+    }
+    if (params.stopReason === 'handoff_bootstrap')
+        return;
+    const conversation = db.prepare(`SELECT channel_id as channelId,
+            thread_kind as threadKind,
+            agent_id as agentId,
+            thread_root_id as threadRootId
+     FROM conversations
+     WHERE id = ?
+     LIMIT 1`).get(conversationId);
+    if (!conversation?.threadRootId)
+        return;
+    const taskThreadChannelId = resolveTaskThreadChannelId({
+        conversationChannelId: conversation.channelId,
+        threadKind: conversation.threadKind,
+        agentId: conversation.agentId,
+    });
+    const boundTask = getBoundTaskForThread(db, {
+        channelId: taskThreadChannelId,
+        threadRootId: conversation.threadRootId,
+    });
+    if (!boundTask || !shouldKeepTaskThreadFollowup(boundTask))
+        return;
+    const delayMs = systemFollowup?.kind === TASK_THREAD_FOLLOWUP_KIND
+        ? (hasExternalThreadActivitySinceBaseline({
+            db,
+            channelId: taskThreadChannelId,
+            threadRootId: conversation.threadRootId,
+            baselineThreadSeq: systemFollowup.baselineThreadSeq,
+            currentRunId: runId,
+        })
+            ? TASK_THREAD_FOLLOWUP_DELAY_MS
+            : readFollowupDelayMsFromMetadata(systemFollowup) * 2)
+        : TASK_THREAD_FOLLOWUP_DELAY_MS;
+    const now = params.now ?? Date.now();
+    const scheduledFor = now + delayMs;
+    const baselineThreadSeq = loadLatestThreadSeq(db, {
+        channelId: taskThreadChannelId,
+        threadRootId: conversation.threadRootId,
+    });
+    const existing = db.prepare(`SELECT followup_id as followupId
+     FROM task_thread_followups
+     WHERE kind = ? AND channel_id = ? AND thread_root_id = ?
+     LIMIT 1`).get(TASK_THREAD_FOLLOWUP_KIND, taskThreadChannelId, conversation.threadRootId);
+    const followupId = existing?.followupId ?? randomUUID();
+    db.prepare(`INSERT INTO task_thread_followups(
+       followup_id, kind, task_id, channel_id, thread_root_id, source_conversation_id,
+       created_by_run_id, baseline_thread_seq, scheduled_for, created_at, updated_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(kind, channel_id, thread_root_id) DO UPDATE SET
+       task_id = excluded.task_id,
+       source_conversation_id = excluded.source_conversation_id,
+       created_by_run_id = excluded.created_by_run_id,
+       baseline_thread_seq = excluded.baseline_thread_seq,
+       scheduled_for = excluded.scheduled_for,
+       updated_at = excluded.updated_at`).run(followupId, TASK_THREAD_FOLLOWUP_KIND, boundTask.taskId, taskThreadChannelId, conversation.threadRootId, conversationId, runId, baselineThreadSeq, scheduledFor, now, now);
+    appendTaskThreadFollowupEvent(db, runId, {
+        followupId,
+        state: 'scheduled',
+        kind: TASK_THREAD_FOLLOWUP_KIND,
+        taskId: boundTask.taskId,
+        channelId: taskThreadChannelId,
+        threadRootId: conversation.threadRootId,
+        sourceConversationId: conversationId,
+        baselineThreadSeq,
+        delayMs,
+        scheduledFor,
+    });
+}
+export function deleteTaskThreadFollowupsForTask(db, taskId) {
+    return db.prepare(`DELETE FROM task_thread_followups
+     WHERE task_id = ?`).run(taskId).changes;
+}
+function loadOpenTask(db, taskId) {
+    const row = db.prepare(`SELECT task_id as taskId,
+            channel_id as channelId,
+            task_number as taskNumber,
+            title,
+            description,
+            status,
+            claimed_by_agent_id as claimedByAgentId,
+            claimed_by_name as claimedByName,
+            blocked_reason as blockedReason,
+            blocked_at as blockedAt,
+            blocked_by as blockedBy
+     FROM tasks
+     WHERE task_id = ?
+     LIMIT 1`).get(taskId);
+    return row ?? null;
+}
+function deleteFollowup(db, followupId) {
+    db.prepare('DELETE FROM task_thread_followups WHERE followup_id = ?').run(followupId);
+}
+function buildTaskBoardTarget(replyTarget) {
+    if (replyTarget.startsWith('dm:@')) {
+        const parts = replyTarget.split(':');
+        return parts.length >= 3 ? parts.slice(0, 2).join(':') : replyTarget;
+    }
+    if (replyTarget.startsWith('#')) {
+        const idx = replyTarget.lastIndexOf(':');
+        return idx > 0 ? replyTarget.slice(0, idx) : replyTarget;
+    }
+    return replyTarget;
+}
+function formatFollowupDelayLabel(delayMs) {
+    const roundedMinutes = Math.round(delayMs / 60_000);
+    if (roundedMinutes > 0 && roundedMinutes % 60 === 0) {
+        const hours = roundedMinutes / 60;
+        return `${hours} hour${hours === 1 ? '' : 's'}`;
+    }
+    return `${roundedMinutes} minute${roundedMinutes === 1 ? '' : 's'}`;
+}
+function buildTaskThreadFollowupPrompt(params) {
+    const boardTarget = buildTaskBoardTarget(params.replyTarget);
+    return [
+        '[System: Task-thread follow-up]',
+        `It has been ${formatFollowupDelayLabel(params.delayMs)} since your last run on this task thread ended, and the task is still open.`,
+        '',
+        '[Current conversation target]',
+        `reply_target: ${params.replyTarget}`,
+        `Task: #${params.task.taskNumber} ${params.task.title}`,
+        `Current task status: ${params.task.status}`,
+        '',
+        'Rules:',
+        `- If the substantive result is ready, send it in this thread and run bigbang task update --channel "${boardTarget}" --number ${params.task.taskNumber} --status in_review.`,
+        '- If the work is still ongoing, continue the task and send a progress update in this thread.',
+        '- If you are blocked on user input, approval, or missing context, ask the user exactly what you need in this thread.',
+        '- If the latest visible state is already waiting on the user or reviewer and you have nothing new to add, do not repeat the waiting message; update memory/notes only if needed, then stop.',
+        '- Do not send a redundant second completion-summary after the substantive final result.',
+    ].join('\n');
+}
+function canAttemptFollowupDispatch(db, nodeRegistry, conversationId) {
+    const row = db.prepare(`SELECT session_key as sessionKey,
+            node_id as nodeId,
+            status
+     FROM conversations
+     WHERE id = ?
+     LIMIT 1`).get(conversationId);
+    if (!row?.nodeId)
+        return false;
+    if (nodeRegistry && !nodeRegistry.getNode(row.nodeId))
+        return false;
+    if (row.status === 'queued' || row.status === 'active' || row.status === 'recovering' || row.status === 'awaiting_approval') {
+        return false;
+    }
+    return !db.prepare(`SELECT 1
+     FROM runs
+     WHERE session_key = ? AND ended_at IS NULL
+     LIMIT 1`).get(row.sessionKey);
+}
+function resolveDmConversation(db, conversationManager, row) {
+    const expectedAgentId = row.channelId.startsWith('dm:')
+        ? row.channelId.slice(3)
+        : null;
+    const sourceConversation = row.sourceConversationId
+        ? conversationManager.getConversation(row.sourceConversationId)
+        : null;
+    if (sourceConversation
+        && sourceConversation.threadKind === 'direct'
+        && sourceConversation.threadRootId === row.threadRootId
+        && (!expectedAgentId || sourceConversation.agentId === expectedAgentId)) {
+        return sourceConversation;
+    }
+    const existing = db.prepare(`SELECT id
+     FROM conversations
+     WHERE thread_kind = 'direct'
+       AND thread_root_id = ?
+       AND (? IS NULL OR agent_id = ?)
+     ORDER BY updated_at DESC
+     LIMIT 1`).get(row.threadRootId, expectedAgentId, expectedAgentId);
+    return existing ? conversationManager.getConversation(existing.id) : null;
+}
+function resolveChannelConversation(conversationManager, task, row) {
+    if (task.claimedByAgentId) {
+        const ownerConversation = conversationManager.openAgentChannelThread(task.claimedByAgentId, row.channelId, row.threadRootId);
+        if (ownerConversation)
+            return ownerConversation;
+    }
+    const recentParticipants = listThreadCollaborationParticipants(conversationManager.getDb(), {
+        channelId: row.channelId,
+        threadRootId: row.threadRootId,
+    });
+    const fallbackParticipant = recentParticipants.find((participant) => Boolean(conversationManager.getAgent(participant.agentId)));
+    if (!fallbackParticipant)
+        return null;
+    return conversationManager.openAgentChannelThread(fallbackParticipant.agentId, row.channelId, row.threadRootId);
+}
+function deleteLatestQueuedFollowupPrompt(db, params) {
+    db.prepare(`DELETE FROM conversation_prompt_queue
+     WHERE queue_id IN (
+       SELECT queue_id
+       FROM conversation_prompt_queue
+       WHERE conversation_id = ?
+         AND prompt_text = ?
+         AND record_as_user_message = 0
+         AND created_at >= ?
+       ORDER BY queue_id DESC
+       LIMIT 1
+     )`).run(params.conversationId, params.promptText, params.createdAfter);
+}
+function restoreIdleStatusAfterQueuedFollowupRemoval(db, conversationId) {
+    const row = db.prepare(`SELECT session_key as sessionKey,
+            status
+     FROM conversations
+     WHERE id = ?
+     LIMIT 1`).get(conversationId);
+    if (!row || row.status !== 'queued')
+        return;
+    const hasQueuedPrompt = Boolean(db.prepare(`SELECT 1
+	     FROM conversation_prompt_queue
+	     WHERE conversation_id = ?
+	       AND COALESCE(dispatch_kind, '') != 'legacy_unknown'
+	     LIMIT 1`).get(conversationId));
+    if (hasQueuedPrompt)
+        return;
+    const hasOpenRun = Boolean(db.prepare(`SELECT 1
+     FROM runs
+     WHERE session_key = ? AND ended_at IS NULL
+     LIMIT 1`).get(row.sessionKey));
+    if (hasOpenRun)
+        return;
+    db.prepare(`UPDATE conversations
+     SET status = 'idle', updated_at = ?
+     WHERE id = ? AND status = 'queued'`).run(Date.now(), conversationId);
+}
+function buildFollowupOptions(params) {
+    const conversation = params.conversationManager.getConversation(params.conversationId);
+    if (!conversation?.agentId || !conversation.replyTarget)
+        return null;
+    const activationMetadata = {
+        systemFollowup: {
+            kind: TASK_THREAD_FOLLOWUP_KIND,
+            followupId: params.followupId,
+            taskId: params.task.taskId,
+            channelId: params.channelId,
+            threadRootId: params.threadRootId,
+            delayMs: params.delayMs,
+            baselineThreadSeq: params.triggerSeq - 1,
+        },
+    };
+    if (conversation.threadKind === 'direct') {
+        const envelope = buildDirectSurfaceActivationEnvelope(params.db, {
+            agentId: conversation.agentId,
+            channelId: params.channelId,
+            replyTarget: conversation.replyTarget,
+            triggerSeq: params.triggerSeq,
+            threadRootId: params.threadRootId,
+            forceTaskNotes: true,
+        });
+        return {
+            promptText: buildTaskThreadFollowupPrompt({
+                replyTarget: conversation.replyTarget,
+                task: params.task,
+                delayMs: params.delayMs,
+            }),
+            options: {
+                recordAsUserMessage: false,
+                activationContextText: envelope.activationContextText,
+                activationContextSections: envelope.activationContextSections,
+                activationContextMode: 'resume_only',
+                resumeContextText: envelope.resumeContextText,
+                resumeContextSections: envelope.resumeContextSections,
+                replayOverlapRecentMessages: envelope.replayOverlapRecentMessages,
+                activationMetadata,
+            },
+        };
+    }
+    const channel = params.conversationManager.getChannel(params.channelId);
+    const envelope = buildChannelSurfaceActivationEnvelope(params.db, {
+        agentId: conversation.agentId,
+        channelId: params.channelId,
+        replyTarget: conversation.replyTarget,
+        triggerSeq: params.triggerSeq,
+        threadRootId: params.threadRootId,
+        channelName: channel?.name,
+        reason: 'thread_reply',
+    });
+    return {
+        promptText: buildTaskThreadFollowupPrompt({
+            replyTarget: conversation.replyTarget,
+            task: params.task,
+            delayMs: params.delayMs,
+        }),
+        options: {
+            recordAsUserMessage: false,
+            activationContextText: envelope.activationContextText,
+            activationContextSections: envelope.activationContextSections,
+            activationContextMode: 'resume_only',
+            resumeContextText: envelope.resumeContextText,
+            resumeContextSections: envelope.resumeContextSections,
+            replayOverlapRecentMessages: envelope.replayOverlapRecentMessages,
+            activationMetadata,
+        },
+    };
+}
+async function processFollowupRow(params) {
+    const { db, row, now, conversationManager, nodeRegistry } = params;
+    const task = loadOpenTask(db, row.taskId);
+    if (task && isBlockedTask(task)) {
+        return;
+    }
+    if (!task || !shouldKeepTaskThreadFollowup(task)) {
+        appendTaskThreadFollowupEvent(db, row.createdByRunId, {
+            followupId: row.followupId,
+            state: 'skipped',
+            reason: task ? 'task_closed' : 'task_missing',
+            kind: row.kind,
+            taskId: row.taskId,
+            channelId: row.channelId,
+            threadRootId: row.threadRootId,
+        });
+        deleteFollowup(db, row.followupId);
+        return;
+    }
+    const latestThreadSeq = loadLatestThreadSeq(db, {
+        channelId: row.channelId,
+        threadRootId: row.threadRootId,
+    });
+    if (latestThreadSeq > row.baselineThreadSeq) {
+        appendTaskThreadFollowupEvent(db, row.createdByRunId, {
+            followupId: row.followupId,
+            state: 'cancelled',
+            reason: 'thread_activity',
+            kind: row.kind,
+            taskId: row.taskId,
+            channelId: row.channelId,
+            threadRootId: row.threadRootId,
+            latestThreadSeq,
+            baselineThreadSeq: row.baselineThreadSeq,
+        });
+        deleteFollowup(db, row.followupId);
+        return;
+    }
+    const conversation = row.channelId.startsWith('dm:')
+        ? resolveDmConversation(db, conversationManager, row)
+        : resolveChannelConversation(conversationManager, task, row);
+    if (!conversation?.id) {
+        appendTaskThreadFollowupEvent(db, row.createdByRunId, {
+            followupId: row.followupId,
+            state: 'skipped',
+            reason: 'no_target_conversation',
+            kind: row.kind,
+            taskId: row.taskId,
+            channelId: row.channelId,
+            threadRootId: row.threadRootId,
+        });
+        deleteFollowup(db, row.followupId);
+        return;
+    }
+    if (!canAttemptFollowupDispatch(db, nodeRegistry, conversation.id)) {
+        return;
+    }
+    const prompt = buildFollowupOptions({
+        db,
+        conversationManager,
+        conversationId: conversation.id,
+        channelId: row.channelId,
+        threadRootId: row.threadRootId,
+        followupId: row.followupId,
+        task,
+        delayMs: readFollowupDelayMsFromRow(row),
+        triggerSeq: Math.max(row.baselineThreadSeq, latestThreadSeq) + 1,
+    });
+    if (!prompt) {
+        appendTaskThreadFollowupEvent(db, row.createdByRunId, {
+            followupId: row.followupId,
+            state: 'skipped',
+            reason: 'target_context_missing',
+            kind: row.kind,
+            taskId: row.taskId,
+            channelId: row.channelId,
+            threadRootId: row.threadRootId,
+        });
+        deleteFollowup(db, row.followupId);
+        return;
+    }
+    const attemptStartedAt = now;
+    try {
+        const result = await conversationManager.submitPrompt(conversation.id, prompt.promptText, prompt.options);
+        if (result.queued) {
+            deleteLatestQueuedFollowupPrompt(db, {
+                conversationId: conversation.id,
+                promptText: prompt.promptText,
+                createdAfter: attemptStartedAt,
+            });
+            restoreIdleStatusAfterQueuedFollowupRemoval(db, conversation.id);
+            return;
+        }
+        appendTaskThreadFollowupEvent(db, row.createdByRunId, {
+            followupId: row.followupId,
+            state: 'dispatched',
+            kind: row.kind,
+            taskId: row.taskId,
+            channelId: row.channelId,
+            threadRootId: row.threadRootId,
+            targetConversationId: conversation.id,
+            reminderRunId: result.runId ?? null,
+        });
+        deleteFollowup(db, row.followupId);
+    }
+    catch (error) {
+        log.warn('[task-thread-followup] dispatch failed; keeping pending follow-up', {
+            followupId: row.followupId,
+            taskId: row.taskId,
+            conversationId: conversation.id,
+            error: String(error?.message ?? error),
+        });
+    }
+}
+export async function processDueTaskThreadFollowups(params) {
+    const now = params.now ?? Date.now();
+    const rows = params.db.prepare(`SELECT followup_id as followupId,
+            kind,
+            task_id as taskId,
+            channel_id as channelId,
+            thread_root_id as threadRootId,
+            source_conversation_id as sourceConversationId,
+            created_by_run_id as createdByRunId,
+            baseline_thread_seq as baselineThreadSeq,
+            scheduled_for as scheduledFor,
+            created_at as createdAt,
+            updated_at as updatedAt
+     FROM task_thread_followups
+     WHERE scheduled_for <= ?
+     ORDER BY scheduled_for ASC, created_at ASC`).all(now);
+    for (const row of rows) {
+        await processFollowupRow({
+            db: params.db,
+            row,
+            now,
+            conversationManager: params.conversationManager,
+            nodeRegistry: params.nodeRegistry,
+        });
+    }
+}
+export function startTaskThreadFollowupService(params) {
+    const intervalMs = Math.max(5_000, params.intervalMs ?? TASK_THREAD_FOLLOWUP_POLL_INTERVAL_MS);
+    let timer = null;
+    let running = false;
+    const tick = async () => {
+        if (running)
+            return;
+        running = true;
+        try {
+            await processDueTaskThreadFollowups({
+                db: params.db,
+                conversationManager: params.conversationManager,
+                nodeRegistry: params.nodeRegistry,
+            });
+        }
+        finally {
+            running = false;
+        }
+    };
+    timer = setInterval(() => {
+        void tick();
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        tick,
+        stop: () => {
+            if (!timer)
+                return;
+            clearInterval(timer);
+            timer = null;
+        },
+    };
+}