@bbigbang/core 0.1.0

package/dist/web/taskLoops.js

@@ -0,0 +1,732 @@
+import { exec as execCallback } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { promisify } from 'node:util';
+import { buildThreadShortId } from '@bbigbang/protocol';
+import { log } from '@bbigbang/runtime-acp';
+import { z } from 'zod';
+import { appendTaskEvent, buildTaskEventThreadTarget } from './taskEvents.js';
+const execAsync = promisify(execCallback);
+export const TASK_LOOP_POLL_INTERVAL_MS = 5_000;
+export const taskLoopApprovalPolicySchema = z.enum(['none', 'before_start', 'before_each_iteration']);
+export const taskLoopTemplateSchema = z.object({
+    goalPrompt: z.string().trim().min(1).max(20_000).optional(),
+    verifyChecks: z.array(z.string().trim().min(1).max(4_000)).max(20).default([]),
+    maxIterations: z.number().int().min(1).max(50).default(3),
+    maxTimeMs: z.number().int().min(1_000).max(24 * 60 * 60 * 1000).default(15 * 60 * 1000),
+    approvalPolicy: taskLoopApprovalPolicySchema.default('none'),
+}).strict();
+function parseTemplate(templateJson) {
+    return taskLoopTemplateSchema.parse(JSON.parse(templateJson));
+}
+function toTaskLoopInfo(row) {
+    return {
+        loopId: row.loopId,
+        taskId: row.taskId,
+        workerAgentId: row.workerAgentId,
+        rootConversationId: row.rootConversationId,
+        workerConversationId: row.workerConversationId,
+        goalPrompt: row.goalPrompt,
+        verifyChecks: JSON.parse(row.verifyChecksJson),
+        maxIterations: row.maxIterations,
+        maxTimeMs: row.maxTimeMs,
+        approvalPolicy: row.approvalPolicy,
+        status: row.status,
+        stopReason: row.stopReason,
+        currentIteration: row.currentIteration,
+        lastError: row.lastError,
+        template: parseTemplate(row.templateJson),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        startedAt: row.startedAt,
+        completedAt: row.completedAt,
+        stopRequestedAt: row.stopRequestedAt,
+    };
+}
+function toTaskLoopIterationInfo(row) {
+    return {
+        iterationId: row.iterationId,
+        loopId: row.loopId,
+        iterationIndex: row.iterationIndex,
+        status: row.status,
+        workerRunId: row.workerRunId,
+        verifyChecksPassed: row.verifyChecksPassed == null ? null : row.verifyChecksPassed === 1,
+        verifyChecksOutput: row.verifyChecksOutputJson ? JSON.parse(row.verifyChecksOutputJson) : [],
+        failureReason: row.failureReason,
+        decision: row.decision,
+        startedAt: row.startedAt,
+        endedAt: row.endedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function nextTaskLoopEventSeq(db, loopId) {
+    const row = db.prepare(`SELECT COALESCE(MAX(seq), 0) as maxSeq
+     FROM task_loop_events
+     WHERE loop_id = ?`).get(loopId);
+    return (row?.maxSeq ?? 0) + 1;
+}
+export function appendTaskLoopEvent(db, params) {
+    db.prepare(`INSERT INTO task_loop_events(event_id, loop_id, iteration_index, seq, event_type, payload_json, created_at)
+     VALUES(?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), params.loopId, params.iterationIndex ?? null, nextTaskLoopEventSeq(db, params.loopId), params.eventType, params.payload ? JSON.stringify(params.payload) : null, params.createdAt ?? Date.now());
+}
+export function getActiveTaskLoopForTask(db, taskId) {
+    const row = db.prepare(`SELECT l.loop_id as loopId,
+            l.task_id as taskId,
+            l.worker_agent_id as workerAgentId,
+            l.root_conversation_id as rootConversationId,
+            l.worker_conversation_id as workerConversationId,
+            l.goal_prompt as goalPrompt,
+            l.verify_checks_json as verifyChecksJson,
+            l.max_iterations as maxIterations,
+            l.max_time_ms as maxTimeMs,
+            l.approval_policy as approvalPolicy,
+            l.status,
+            l.stop_reason as stopReason,
+            l.current_iteration as currentIteration,
+            l.last_error as lastError,
+            l.template_json as templateJson,
+            l.created_at as createdAt,
+            l.updated_at as updatedAt,
+            l.started_at as startedAt,
+            l.completed_at as completedAt,
+            l.stop_requested_at as stopRequestedAt
+     FROM task_loops l
+     JOIN tasks t ON t.active_loop_id = l.loop_id
+     WHERE t.task_id = ?
+     LIMIT 1`).get(taskId);
+    return row ? toTaskLoopInfo(row) : null;
+}
+export function getTaskLoopById(db, loopId) {
+    const row = db.prepare(`SELECT loop_id as loopId,
+            task_id as taskId,
+            worker_agent_id as workerAgentId,
+            root_conversation_id as rootConversationId,
+            worker_conversation_id as workerConversationId,
+            goal_prompt as goalPrompt,
+            verify_checks_json as verifyChecksJson,
+            max_iterations as maxIterations,
+            max_time_ms as maxTimeMs,
+            approval_policy as approvalPolicy,
+            status,
+            stop_reason as stopReason,
+            current_iteration as currentIteration,
+            last_error as lastError,
+            template_json as templateJson,
+            created_at as createdAt,
+            updated_at as updatedAt,
+            started_at as startedAt,
+            completed_at as completedAt,
+            stop_requested_at as stopRequestedAt
+     FROM task_loops
+     WHERE loop_id = ?
+     LIMIT 1`).get(loopId);
+    return row ? toTaskLoopInfo(row) : null;
+}
+export function listTaskLoopIterations(db, loopId) {
+    const rows = db.prepare(`SELECT iteration_id as iterationId,
+            loop_id as loopId,
+            iteration_index as iterationIndex,
+            status,
+            worker_run_id as workerRunId,
+            verify_checks_passed as verifyChecksPassed,
+            verify_checks_output_json as verifyChecksOutputJson,
+            failure_reason as failureReason,
+            decision,
+            started_at as startedAt,
+            ended_at as endedAt,
+            created_at as createdAt,
+            updated_at as updatedAt
+     FROM task_loop_iterations
+     WHERE loop_id = ?
+     ORDER BY iteration_index ASC`).all(loopId);
+    return rows.map(toTaskLoopIterationInfo);
+}
+export function listTaskLoopEvents(db, loopId) {
+    const rows = db.prepare(`SELECT event_id as eventId,
+            iteration_index as iterationIndex,
+            seq,
+            event_type as eventType,
+            payload_json as payloadJson,
+            created_at as createdAt
+     FROM task_loop_events
+     WHERE loop_id = ?
+     ORDER BY seq ASC`).all(loopId);
+    return rows.map((row) => ({
+        eventId: row.eventId,
+        iterationIndex: row.iterationIndex,
+        seq: row.seq,
+        eventType: row.eventType,
+        payload: row.payloadJson ? JSON.parse(row.payloadJson) : null,
+        createdAt: row.createdAt,
+    }));
+}
+function loadTaskForLoop(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,
+            message_id as messageId,
+            active_loop_id as activeLoopId,
+            execution_mode as executionMode
+     FROM tasks
+     WHERE task_id = ?
+     LIMIT 1`).get(taskId);
+    return row ?? null;
+}
+function getLoopIterationRow(db, loopId, iterationIndex) {
+    const row = db.prepare(`SELECT iteration_id as iterationId,
+            loop_id as loopId,
+            iteration_index as iterationIndex,
+            status,
+            worker_run_id as workerRunId,
+            verify_checks_passed as verifyChecksPassed,
+            verify_checks_output_json as verifyChecksOutputJson,
+            failure_reason as failureReason,
+            decision,
+            started_at as startedAt,
+            ended_at as endedAt,
+            created_at as createdAt,
+            updated_at as updatedAt
+     FROM task_loop_iterations
+     WHERE loop_id = ? AND iteration_index = ?
+     LIMIT 1`).get(loopId, iterationIndex);
+    return row ?? null;
+}
+function ensureLoopIteration(db, loopId, iterationIndex, now) {
+    const existing = getLoopIterationRow(db, loopId, iterationIndex);
+    if (existing)
+        return existing;
+    const iterationId = randomUUID();
+    db.prepare(`INSERT INTO task_loop_iterations(
+       iteration_id, loop_id, iteration_index, status, created_at, updated_at
+     )
+     VALUES(?, ?, ?, 'pending', ?, ?)`).run(iterationId, loopId, iterationIndex, now, now);
+    return getLoopIterationRow(db, loopId, iterationIndex);
+}
+function buildLoopIterationPrompt(params) {
+    const lines = [
+        '[Loop task iteration]',
+        `Task: #${params.task.taskNumber} ${params.task.title}`,
+        `Iteration: ${params.iterationIndex}/${params.loop.maxIterations}`,
+        '',
+        'Goal:',
+        params.loop.goalPrompt,
+    ];
+    if (params.task.description?.trim()) {
+        lines.push('', 'Task brief:', params.task.description.trim());
+    }
+    if (params.previousFailureReason?.trim()) {
+        lines.push('', 'Previous verification failure:', params.previousFailureReason.trim());
+    }
+    if (params.loop.verifyChecks.length > 0) {
+        lines.push('', 'Verification checks that must pass:');
+        for (const check of params.loop.verifyChecks) {
+            lines.push(`- ${check}`);
+        }
+    }
+    lines.push('', 'Rules:', '- Continue working in this task thread.', '- When the task is ready, the platform will run verification checks automatically.', '- Do not mark the task done yourself; the platform will move it to in_review after successful verification.');
+    return lines.join('\n');
+}
+function canAttemptLoopDispatch(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 loadRun(db, runId) {
+    const row = db.prepare(`SELECT ended_at as endedAt, stop_reason as stopReason, error
+     FROM runs
+     WHERE run_id = ?
+     LIMIT 1`).get(runId);
+    return row ?? null;
+}
+function isCancelStopReason(stopReason) {
+    return stopReason === 'cancelled' || stopReason === 'canceled';
+}
+function shouldRetry(loop, iterationIndex, startedAt, now) {
+    if (iterationIndex >= loop.maxIterations)
+        return false;
+    if (startedAt != null && now - startedAt >= loop.maxTimeMs)
+        return false;
+    return true;
+}
+function needsIterationApproval(loop) {
+    return loop.approvalPolicy === 'before_each_iteration';
+}
+async function runVerifyChecks(params) {
+    const results = [];
+    for (const command of params.commands) {
+        try {
+            const { stdout, stderr } = await execAsync(command, {
+                cwd: params.cwd,
+                shell: '/bin/bash',
+                maxBuffer: 1024 * 1024,
+            });
+            results.push({
+                command,
+                passed: true,
+                exitCode: 0,
+                stdout,
+                stderr,
+            });
+        }
+        catch (error) {
+            const execError = error;
+            const exitCode = typeof execError.code === 'number' ? execError.code : null;
+            const stdout = execError.stdout ?? '';
+            const stderr = execError.stderr ?? execError.message ?? '';
+            results.push({
+                command,
+                passed: false,
+                exitCode,
+                stdout,
+                stderr,
+            });
+            return {
+                passed: false,
+                results,
+                failureReason: `Verify check failed: ${command}`,
+            };
+        }
+    }
+    return { passed: true, results, failureReason: null };
+}
+function resolveLoopCheckCwd(db, conversationId) {
+    const row = db.prepare(`SELECT c.workspace_path as workspacePath,
+            c.active_project_id as activeProjectId,
+            p.root_path as activeProjectRoot
+     FROM conversations c
+     LEFT JOIN projects p ON p.project_id = c.active_project_id
+     WHERE c.id = ?
+     LIMIT 1`).get(conversationId);
+    return row?.activeProjectRoot ?? row?.workspacePath ?? null;
+}
+function updateLoopStatus(db, params) {
+    db.prepare(`UPDATE task_loops
+     SET status = ?,
+         stop_reason = ?,
+         last_error = ?,
+         started_at = COALESCE(?, started_at),
+         completed_at = ?,
+         stop_requested_at = ?,
+         current_iteration = COALESCE(?, current_iteration),
+         worker_conversation_id = COALESCE(?, worker_conversation_id),
+         worker_agent_id = COALESCE(?, worker_agent_id),
+         updated_at = ?
+     WHERE loop_id = ?`).run(params.status, params.stopReason ?? null, params.lastError ?? null, params.startedAt ?? null, params.completedAt ?? null, params.stopRequestedAt ?? null, params.currentIteration ?? null, params.workerConversationId ?? null, params.workerAgentId ?? null, Date.now(), params.loopId);
+}
+function resolveWorkerConversation(db, manager, task) {
+    if (!task.claimedByAgentId || !task.messageId)
+        return null;
+    const threadRootId = buildThreadShortId(task.messageId);
+    const conversation = manager.openAgentChannelThread(task.claimedByAgentId, task.channelId, threadRootId);
+    if (!conversation)
+        return null;
+    return {
+        conversationId: conversation.id,
+        replyTarget: conversation.replyTarget ?? null,
+    };
+}
+async function processRunningLoop(params) {
+    const { db, conversationManager, nodeRegistry, loop, task, now } = params;
+    let statusLifecycleEvent = null;
+    if (task.status === 'done') {
+        updateLoopStatus(db, {
+            loopId: loop.loopId,
+            status: 'cancelled',
+            stopReason: 'task_done',
+            completedAt: now,
+            lastError: null,
+        });
+        appendTaskLoopEvent(db, {
+            loopId: loop.loopId,
+            eventType: 'loop.cancelled',
+            payload: { reason: 'task_done' },
+            createdAt: now,
+        });
+        params.onLoopChanged?.(task.channelId);
+        return;
+    }
+    if (!task.claimedByAgentId) {
+        updateLoopStatus(db, {
+            loopId: loop.loopId,
+            status: 'stopped',
+            stopReason: 'task_unclaimed',
+            completedAt: now,
+            lastError: null,
+        });
+        appendTaskLoopEvent(db, {
+            loopId: loop.loopId,
+            eventType: 'loop.stopped',
+            payload: { reason: 'task_unclaimed' },
+            createdAt: now,
+        });
+        params.onLoopChanged?.(task.channelId);
+        return;
+    }
+    const iterationIndex = Math.max(1, loop.currentIteration || 1);
+    const iteration = ensureLoopIteration(db, loop.loopId, iterationIndex, now);
+    const previousIteration = iterationIndex > 1 ? getLoopIterationRow(db, loop.loopId, iterationIndex - 1) : null;
+    if (iteration.status === 'pending') {
+        const workerConversation = resolveWorkerConversation(db, conversationManager, task);
+        if (!workerConversation)
+            return;
+        if (!canAttemptLoopDispatch(db, nodeRegistry, workerConversation.conversationId))
+            return;
+        const promptText = buildLoopIterationPrompt({
+            task,
+            loop,
+            iterationIndex,
+            previousFailureReason: previousIteration?.failureReason ?? null,
+        });
+        try {
+            const result = await conversationManager.submitPrompt(workerConversation.conversationId, promptText, {
+                recordAsUserMessage: false,
+            });
+            if (result.queued || !result.runId)
+                return;
+            db.prepare(`UPDATE task_loop_iterations
+         SET status = 'running',
+             worker_run_id = ?,
+             started_at = ?,
+             updated_at = ?
+         WHERE iteration_id = ?`).run(result.runId, now, now, iteration.iterationId);
+            updateLoopStatus(db, {
+                loopId: loop.loopId,
+                status: 'running',
+                startedAt: loop.startedAt ?? now,
+                currentIteration: iterationIndex,
+                workerConversationId: workerConversation.conversationId,
+                workerAgentId: task.claimedByAgentId,
+            });
+            appendTaskLoopEvent(db, {
+                loopId: loop.loopId,
+                iterationIndex,
+                eventType: 'iteration.started',
+                payload: {
+                    workerRunId: result.runId,
+                    workerConversationId: workerConversation.conversationId,
+                },
+                createdAt: now,
+            });
+            params.onLoopChanged?.(task.channelId);
+        }
+        catch (error) {
+            log.warn('[task-loop] failed to dispatch iteration', {
+                loopId: loop.loopId,
+                taskId: task.taskId,
+                error: String(error?.message ?? error),
+            });
+        }
+        return;
+    }
+    if (iteration.status !== 'running' || !iteration.workerRunId)
+        return;
+    const run = loadRun(db, iteration.workerRunId);
+    if (!run?.endedAt)
+        return;
+    if (run.error) {
+        db.prepare(`UPDATE task_loop_iterations
+       SET status = 'failed',
+           failure_reason = ?,
+           decision = 'stop',
+           ended_at = ?,
+           updated_at = ?
+       WHERE iteration_id = ?`).run(run.error, now, now, iteration.iterationId);
+        updateLoopStatus(db, {
+            loopId: loop.loopId,
+            status: 'failed',
+            stopReason: 'worker_error',
+            lastError: run.error,
+            completedAt: now,
+        });
+        appendTaskLoopEvent(db, {
+            loopId: loop.loopId,
+            iterationIndex,
+            eventType: 'iteration.failed',
+            payload: {
+                reason: run.error,
+                source: 'worker_error',
+            },
+            createdAt: now,
+        });
+        params.onLoopChanged?.(task.channelId);
+        return;
+    }
+    if (isCancelStopReason(run.stopReason)) {
+        db.prepare(`UPDATE task_loop_iterations
+       SET status = 'cancelled',
+           failure_reason = ?,
+           decision = 'stop',
+           ended_at = ?,
+           updated_at = ?
+       WHERE iteration_id = ?`).run('Worker run was cancelled', now, now, iteration.iterationId);
+        updateLoopStatus(db, {
+            loopId: loop.loopId,
+            status: 'cancelled',
+            stopReason: 'worker_cancelled',
+            lastError: null,
+            completedAt: now,
+        });
+        appendTaskLoopEvent(db, {
+            loopId: loop.loopId,
+            iterationIndex,
+            eventType: 'loop.cancelled',
+            payload: {
+                reason: 'worker_cancelled',
+            },
+            createdAt: now,
+        });
+        params.onLoopChanged?.(task.channelId);
+        return;
+    }
+    const checkCwd = loop.workerConversationId ? resolveLoopCheckCwd(db, loop.workerConversationId) : null;
+    const verification = loop.verifyChecks.length === 0
+        ? { passed: true, results: [], failureReason: null }
+        : await runVerifyChecks({
+            commands: loop.verifyChecks,
+            cwd: checkCwd ?? process.cwd(),
+        });
+    if (verification.passed) {
+        db.transaction(() => {
+            db.prepare(`UPDATE task_loop_iterations
+         SET status = 'succeeded',
+             verify_checks_passed = 1,
+             verify_checks_output_json = ?,
+             decision = 'finish',
+             ended_at = ?,
+             updated_at = ?
+         WHERE iteration_id = ?`).run(JSON.stringify(verification.results), now, now, iteration.iterationId);
+            updateLoopStatus(db, {
+                loopId: loop.loopId,
+                status: 'succeeded',
+                stopReason: 'passed',
+                lastError: null,
+                completedAt: now,
+            });
+            if (task.status === 'in_progress') {
+                db.prepare(`UPDATE tasks
+           SET status = 'in_review', updated_at = ?
+           WHERE task_id = ?`).run(now, task.taskId);
+                appendTaskEvent(db, {
+                    taskId: task.taskId,
+                    agentTaskRef: null,
+                    channelId: task.channelId,
+                    taskNumber: task.taskNumber,
+                    eventType: 'status_changed',
+                    actorType: 'system',
+                    actorName: 'system',
+                    fromStatus: task.status,
+                    toStatus: 'in_review',
+                    claimedByAgentIdAfter: task.claimedByAgentId,
+                    claimedByNameAfter: task.claimedByName,
+                    messageId: task.messageId,
+                    threadTarget: buildTaskEventThreadTarget({
+                        sourceTarget: `#${conversationManager.getChannel(task.channelId)?.name ?? task.channelId}`,
+                        messageId: task.messageId,
+                    }),
+                    createdAt: now,
+                });
+                statusLifecycleEvent = {
+                    channelId: task.channelId,
+                    taskId: task.taskId,
+                    taskNumber: task.taskNumber,
+                    title: task.title,
+                    taskStatus: 'in_review',
+                    taskAssigneeName: task.claimedByName,
+                    fromStatus: task.status,
+                    toStatus: 'in_review',
+                    actorName: 'system',
+                };
+            }
+        })();
+        appendTaskLoopEvent(db, {
+            loopId: loop.loopId,
+            iterationIndex,
+            eventType: 'loop.succeeded',
+            payload: {
+                verifyChecks: verification.results,
+            },
+            createdAt: now,
+        });
+        params.onTaskStatusChanged?.(task.channelId);
+        if (statusLifecycleEvent) {
+            params.onTaskStatusLifecycle?.(statusLifecycleEvent);
+        }
+        params.onLoopChanged?.(task.channelId);
+        return;
+    }
+    const nextIterationIndex = iterationIndex + 1;
+    const canRetry = shouldRetry(loop, iterationIndex, loop.startedAt, now);
+    const requiresApprovalForNextIteration = canRetry && needsIterationApproval(loop);
+    db.transaction(() => {
+        db.prepare(`UPDATE task_loop_iterations
+       SET status = 'failed',
+           verify_checks_passed = 0,
+           verify_checks_output_json = ?,
+           failure_reason = ?,
+           decision = ?,
+           ended_at = ?,
+           updated_at = ?
+       WHERE iteration_id = ?`).run(JSON.stringify(verification.results), verification.failureReason, canRetry ? 'retry' : 'stop', now, now, iteration.iterationId);
+        if (canRetry) {
+            updateLoopStatus(db, {
+                loopId: loop.loopId,
+                status: requiresApprovalForNextIteration ? 'awaiting_approval' : 'running',
+                currentIteration: nextIterationIndex,
+                lastError: verification.failureReason,
+            });
+            ensureLoopIteration(db, loop.loopId, nextIterationIndex, now);
+        }
+        else {
+            const stopReason = loop.startedAt != null && now - loop.startedAt >= loop.maxTimeMs
+                ? 'max_time'
+                : iterationIndex >= loop.maxIterations
+                    ? 'max_iterations'
+                    : 'verify_failed';
+            updateLoopStatus(db, {
+                loopId: loop.loopId,
+                status: 'failed',
+                stopReason,
+                lastError: verification.failureReason,
+                completedAt: now,
+            });
+        }
+    })();
+    appendTaskLoopEvent(db, {
+        loopId: loop.loopId,
+        iterationIndex,
+        eventType: canRetry ? 'iteration.retry_scheduled' : 'loop.failed',
+        payload: {
+            reason: verification.failureReason,
+            verifyChecks: verification.results,
+            nextIterationIndex: canRetry ? nextIterationIndex : null,
+            requiresApproval: requiresApprovalForNextIteration,
+        },
+        createdAt: now,
+    });
+    if (requiresApprovalForNextIteration) {
+        appendTaskLoopEvent(db, {
+            loopId: loop.loopId,
+            iterationIndex: nextIterationIndex,
+            eventType: 'loop.awaiting_approval',
+            payload: {
+                approvalPolicy: loop.approvalPolicy,
+                scope: 'iteration',
+                iterationIndex: nextIterationIndex,
+            },
+            createdAt: now,
+        });
+    }
+    params.onLoopChanged?.(task.channelId);
+}
+export async function processDueTaskLoops(params) {
+    const now = params.now ?? Date.now();
+    const rows = params.db.prepare(`SELECT loop_id as loopId,
+            task_id as taskId,
+            worker_agent_id as workerAgentId,
+            root_conversation_id as rootConversationId,
+            worker_conversation_id as workerConversationId,
+            goal_prompt as goalPrompt,
+            verify_checks_json as verifyChecksJson,
+            max_iterations as maxIterations,
+            max_time_ms as maxTimeMs,
+            approval_policy as approvalPolicy,
+            status,
+            stop_reason as stopReason,
+            current_iteration as currentIteration,
+            last_error as lastError,
+            template_json as templateJson,
+            created_at as createdAt,
+            updated_at as updatedAt,
+            started_at as startedAt,
+            completed_at as completedAt,
+            stop_requested_at as stopRequestedAt
+     FROM task_loops
+     WHERE status IN ('pending', 'running')
+       AND started_at IS NOT NULL
+     ORDER BY created_at ASC`).all();
+    for (const row of rows) {
+        const loop = toTaskLoopInfo(row);
+        const task = loadTaskForLoop(params.db, loop.taskId);
+        if (!task) {
+            updateLoopStatus(params.db, {
+                loopId: loop.loopId,
+                status: 'cancelled',
+                stopReason: 'task_deleted',
+                completedAt: now,
+            });
+            appendTaskLoopEvent(params.db, {
+                loopId: loop.loopId,
+                eventType: 'loop.cancelled',
+                payload: { reason: 'task_deleted' },
+                createdAt: now,
+            });
+            continue;
+        }
+        await processRunningLoop({
+            db: params.db,
+            conversationManager: params.conversationManager,
+            nodeRegistry: params.nodeRegistry,
+            loop,
+            task,
+            now,
+            onTaskStatusChanged: params.onTaskStatusChanged,
+            onTaskStatusLifecycle: params.onTaskStatusLifecycle,
+            onLoopChanged: params.onLoopChanged,
+        });
+    }
+}
+export function startTaskLoopService(params) {
+    const intervalMs = Math.max(2_000, params.intervalMs ?? TASK_LOOP_POLL_INTERVAL_MS);
+    let timer = null;
+    let running = false;
+    const tick = async () => {
+        if (running)
+            return;
+        running = true;
+        try {
+            await processDueTaskLoops({
+                db: params.db,
+                conversationManager: params.conversationManager,
+                nodeRegistry: params.nodeRegistry,
+                onTaskStatusChanged: params.onTaskStatusChanged,
+                onTaskStatusLifecycle: params.onTaskStatusLifecycle,
+                onLoopChanged: params.onLoopChanged,
+            });
+        }
+        finally {
+            running = false;
+        }
+    };
+    timer = setInterval(() => {
+        void tick();
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        tick,
+        stop: () => {
+            if (!timer)
+                return;
+            clearInterval(timer);
+            timer = null;
+        },
+    };
+}