@bbigbang/core 0.1.0

package/dist/web/taskThreadRuntimeClosure.js

@@ -0,0 +1,685 @@
+import { log } from '@bbigbang/runtime-acp';
+import { deleteTaskThreadFollowupsForTask } from './taskThreadFollowups.js';
+import { getThreadBindingForTask } from './threadTaskBindings.js';
+import { NOTIFICATION_REASON_MASK, supersedeNotificationRoundsForThreadRoots, } from './notificationRounds.js';
+import { hasEffectiveAgentRuntimeCapability } from './runtimeCapabilities.js';
+const taskThreadClosingStates = new Map();
+const taskThreadReopenedRunBlocks = new Map();
+function listTaskThreadConversations(db, params) {
+    if (params.channelId.startsWith('dm:')) {
+        const agentId = params.channelId.slice(3);
+        const dmUserId = params.dmUserId?.trim() || null;
+        return db.prepare(`SELECT c.id,
+              c.session_key as sessionKey,
+	              c.status,
+	              c.agent_id as agentId,
+	              a.name as agentName,
+	              c.agent_type as agentType,
+                c.node_id as nodeId
+	     FROM conversations c
+	     LEFT JOIN agents a ON a.agent_id = c.agent_id
+	     WHERE c.thread_kind = 'direct'
+	       AND c.thread_root_id = ?
+	       AND c.agent_id = ?
+         AND ${dmUserId ? 'c.user_id = ?' : '1 = 1'}`).all(params.threadRootId, agentId, ...(dmUserId ? [dmUserId] : []));
+    }
+    return db.prepare(`SELECT c.id,
+            c.session_key as sessionKey,
+            c.status,
+            c.agent_id as agentId,
+            a.name as agentName,
+            c.agent_type as agentType,
+            c.node_id as nodeId
+     FROM conversations c
+     LEFT JOIN agents a ON a.agent_id = c.agent_id
+     WHERE c.thread_kind = 'branch'
+       AND c.channel_id = ?
+       AND c.thread_root_id = ?`).all(params.channelId, params.threadRootId);
+}
+function setTaskThreadClosingState(conversationId, state) {
+    taskThreadClosingStates.set(conversationId, state);
+}
+export function getTaskThreadClosingState(conversationId) {
+    if (!conversationId)
+        return null;
+    return taskThreadClosingStates.get(conversationId) ?? null;
+}
+export function getTaskThreadReopenedRunBlock(conversationId) {
+    if (!conversationId)
+        return null;
+    return taskThreadReopenedRunBlocks.get(conversationId) ?? null;
+}
+function findOpenRunForConversation(db, conversationId) {
+    const row = db.prepare(`SELECT r.run_id as runId,
+            r.started_at as startedAt
+       FROM conversations c
+       JOIN runs r
+         ON r.session_key = c.session_key
+        AND r.ended_at IS NULL
+      WHERE c.id = ?
+      ORDER BY r.started_at DESC
+      LIMIT 1`).get(conversationId);
+    return row ?? null;
+}
+function findRunStartedAt(db, conversationId, runId) {
+    const row = db.prepare(`SELECT r.started_at as startedAt
+       FROM conversations c
+       JOIN runs r
+         ON r.session_key = c.session_key
+        AND r.run_id = ?
+      WHERE c.id = ?
+      LIMIT 1`).get(runId, conversationId);
+    return typeof row?.startedAt === 'number' ? row.startedAt : null;
+}
+function findLatestUserReopenEventAt(db, taskId) {
+    const row = db.prepare(`SELECT created_at as createdAt
+       FROM task_events
+      WHERE task_id = ?
+        AND event_type = 'status_changed'
+        AND actor_type = 'user'
+        AND from_status = 'in_review'
+        AND to_status = 'in_progress'
+      ORDER BY created_at DESC
+      LIMIT 1`).get(taskId);
+    return typeof row?.createdAt === 'number' ? row.createdAt : null;
+}
+export function getStaleTaskThreadReopenedRunBlock(db, params) {
+    const conversationId = params.conversationId?.trim();
+    const taskId = params.taskId?.trim();
+    if (!conversationId || !taskId)
+        return null;
+    const openRun = params.runId?.trim()
+        ? {
+            runId: params.runId.trim(),
+            startedAt: findRunStartedAt(db, conversationId, params.runId.trim()),
+        }
+        : findOpenRunForConversation(db, conversationId);
+    if (!openRun?.runId)
+        return null;
+    const memoryBlock = taskThreadReopenedRunBlocks.get(conversationId);
+    if (memoryBlock?.taskId === taskId && memoryBlock.blockedRunId === openRun.runId) {
+        return {
+            taskId,
+            blockedRunId: openRun.runId,
+            source: 'memory',
+            ...(typeof openRun.startedAt === 'number' ? { runStartedAt: openRun.startedAt } : {}),
+        };
+    }
+    if (typeof openRun.startedAt !== 'number')
+        return null;
+    const reopenEventAt = findLatestUserReopenEventAt(db, taskId);
+    if (typeof reopenEventAt !== 'number')
+        return null;
+    if (openRun.startedAt >= reopenEventAt)
+        return null;
+    return {
+        taskId,
+        blockedRunId: openRun.runId,
+        source: 'task_event',
+        reopenEventAt,
+        runStartedAt: openRun.startedAt,
+    };
+}
+function clearTaskThreadClosingStateForConversation(conversationId) {
+    if (!conversationId)
+        return;
+    taskThreadClosingStates.delete(conversationId);
+}
+function clearTaskThreadReopenedRunBlockForConversation(conversationId, runId) {
+    if (!conversationId)
+        return;
+    if (!runId) {
+        taskThreadReopenedRunBlocks.delete(conversationId);
+        return;
+    }
+    const current = taskThreadReopenedRunBlocks.get(conversationId);
+    if (current?.blockedRunId === runId) {
+        taskThreadReopenedRunBlocks.delete(conversationId);
+    }
+}
+export function clearTaskThreadClosingStateForTask(db, taskId) {
+    const binding = getThreadBindingForTask(db, taskId);
+    if (!binding)
+        return;
+    const conversations = listTaskThreadConversations(db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+    });
+    for (const conversation of conversations) {
+        clearTaskThreadClosingStateForConversation(conversation.id);
+    }
+}
+export function clearTaskThreadReopenedRunBlock(conversationId, runId) {
+    clearTaskThreadReopenedRunBlockForConversation(conversationId, runId);
+}
+export function clearTaskThreadReopenedRunBlocksForTask(db, taskId) {
+    const binding = getThreadBindingForTask(db, taskId);
+    if (!binding)
+        return;
+    const conversations = listTaskThreadConversations(db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+    });
+    for (const conversation of conversations) {
+        clearTaskThreadReopenedRunBlockForConversation(conversation.id);
+    }
+}
+export function blockActiveTaskThreadRunsAfterReopen(db, taskId) {
+    const binding = getThreadBindingForTask(db, taskId);
+    if (!binding)
+        return [];
+    const conversations = listTaskThreadConversations(db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+    });
+    const blocked = [];
+    for (const conversation of conversations) {
+        const row = db.prepare(`SELECT run_id as runId
+       FROM runs
+       WHERE session_key = ?
+         AND ended_at IS NULL
+       ORDER BY started_at DESC
+       LIMIT 1`).get(conversation.sessionKey);
+        if (!row?.runId)
+            continue;
+        taskThreadReopenedRunBlocks.set(conversation.id, {
+            taskId,
+            blockedRunId: row.runId,
+        });
+        blocked.push({
+            conversationId: conversation.id,
+            runId: row.runId,
+        });
+    }
+    return blocked;
+}
+export function markTaskThreadClosingFinalSent(conversationId, runId) {
+    const current = getTaskThreadClosingState(conversationId);
+    if (!current)
+        return false;
+    if (!current.allowOneFinal || current.finalSent)
+        return false;
+    if (!current.ownerRunId || current.ownerRunId !== runId)
+        return false;
+    taskThreadClosingStates.set(conversationId, {
+        ...current,
+        allowOneFinal: false,
+        finalSent: true,
+    });
+    return true;
+}
+function restoreIdleConversationStatus(db, conversation) {
+    const hasQueuedPrompt = Boolean(db.prepare(`SELECT 1
+	     FROM conversation_prompt_queue
+	     WHERE conversation_id = ?
+	       AND COALESCE(dispatch_kind, '') != 'legacy_unknown'
+	     LIMIT 1`).get(conversation.id));
+    if (hasQueuedPrompt)
+        return false;
+    const hasOpenRun = Boolean(db.prepare(`SELECT 1
+     FROM runs
+     WHERE session_key = ?
+       AND ended_at IS NULL
+     LIMIT 1`).get(conversation.sessionKey));
+    if (hasOpenRun)
+        return false;
+    const result = db.prepare(`UPDATE conversations
+     SET status = 'idle', updated_at = ?
+     WHERE id = ?
+       AND status IN ('queued', 'active', 'recovering', 'awaiting_approval')`).run(Date.now(), conversation.id);
+    return result.changes > 0;
+}
+function findOpenRunId(db, sessionKey) {
+    const row = db.prepare(`SELECT run_id as runId
+     FROM runs
+     WHERE session_key = ?
+       AND ended_at IS NULL
+     ORDER BY started_at DESC
+     LIMIT 1`).get(sessionKey);
+    return row?.runId ?? null;
+}
+export function findActiveTaskThreadRunForAgent(db, params) {
+    const agentId = params.agentId?.trim();
+    if (!agentId)
+        return null;
+    const binding = getThreadBindingForTask(db, params.taskId);
+    if (!binding)
+        return null;
+    const conversations = listTaskThreadConversations(db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+        dmUserId: params.dmUserId,
+    });
+    for (const conversation of conversations) {
+        if (conversation.agentId !== agentId)
+            continue;
+        const runId = findOpenRunId(db, conversation.sessionKey);
+        if (!runId)
+            continue;
+        return {
+            conversationId: conversation.id,
+            runId,
+            agentId: conversation.agentId,
+        };
+    }
+    return null;
+}
+export function listActiveTaskThreadPeerRuns(db, params) {
+    const binding = getThreadBindingForTask(db, params.taskId);
+    if (!binding)
+        return [];
+    const excludedAgentId = params.excludeAgentId?.trim() || null;
+    const conversations = listTaskThreadConversations(db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+    });
+    const runs = [];
+    for (const conversation of conversations) {
+        if (!conversation.agentId)
+            continue;
+        if (excludedAgentId && conversation.agentId === excludedAgentId)
+            continue;
+        const runId = findOpenRunId(db, conversation.sessionKey);
+        if (!runId)
+            continue;
+        runs.push({
+            conversationId: conversation.id,
+            runId,
+            agentId: conversation.agentId,
+            name: conversation.agentName ?? conversation.agentId,
+        });
+    }
+    return runs;
+}
+export function countQueuedHumanPromptsForTaskThread(db, taskId) {
+    const binding = getThreadBindingForTask(db, taskId);
+    if (!binding)
+        return 0;
+    const conversations = listTaskThreadConversations(db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+    });
+    const conversationIds = conversations.map((conversation) => conversation.id);
+    if (conversationIds.length === 0)
+        return 0;
+    const placeholders = conversationIds.map(() => '?').join(', ');
+    const row = db.prepare(`SELECT COUNT(*) as count
+	     FROM conversation_prompt_queue
+	     WHERE record_as_user_message != 0
+	       AND COALESCE(dispatch_kind, '') != 'legacy_unknown'
+	       AND conversation_id IN (${placeholders})`).get(...conversationIds);
+    return Number(row?.count ?? 0);
+}
+export function countPendingHumanNotificationRoundsForTaskThread(db, taskId) {
+    const binding = getThreadBindingForTask(db, taskId);
+    if (!binding)
+        return 0;
+    const humanChatReasonMask = NOTIFICATION_REASON_MASK.participant_heads_up
+        | NOTIFICATION_REASON_MASK.explicit_agent_mention;
+    const row = db.prepare(`SELECT COUNT(*) as count
+       FROM agent_notification_rounds
+      WHERE channel_id = ?
+        AND surface_thread_key = ?
+        AND status IN ('ready', 'leased', 'delivered')
+        AND acked_at IS NULL
+        AND COALESCE(from_agent_id, '') LIKE 'user:%'
+        AND (reason_mask & ?) != 0`).get(binding.channelId, binding.threadRootId, humanChatReasonMask);
+    return Number(row?.count ?? 0);
+}
+export function closeTaskThreadRuntimeState(params) {
+    const now = Date.now();
+    const binding = getThreadBindingForTask(params.db, params.taskId);
+    clearTaskThreadClosingStateForTask(params.db, params.taskId);
+    clearTaskThreadReopenedRunBlocksForTask(params.db, params.taskId);
+    if (!binding) {
+        return {
+            closed: false,
+            conversationIds: [],
+            cancelledRunIds: [],
+            clearedQueuedPromptCount: 0,
+            clearedAggregateCount: 0,
+            clearedCooldownCount: 0,
+            clearedFollowupCount: 0,
+            idledConversationIds: [],
+        };
+    }
+    const conversations = listTaskThreadConversations(params.db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+    });
+    const cancelledRunIds = [];
+    const idledConversationIds = [];
+    let clearedQueuedPromptCount = 0;
+    for (const conversation of conversations) {
+        const cancelResult = params.conversationManager.cancelConversationRun(conversation.id);
+        if (cancelResult.ok && cancelResult.runId) {
+            cancelledRunIds.push(cancelResult.runId);
+        }
+        else if (cancelResult.message && cancelResult.message !== 'No active run to cancel.') {
+            log.warn('[task-thread-runtime-closure] failed to cancel active run', {
+                taskId: params.taskId,
+                conversationId: conversation.id,
+                reason: params.reason,
+                error: cancelResult.message,
+            });
+        }
+        clearedQueuedPromptCount += params.db.prepare(`DELETE FROM conversation_prompt_queue
+       WHERE conversation_id = ?`).run(conversation.id).changes;
+        if (restoreIdleConversationStatus(params.db, conversation)) {
+            idledConversationIds.push(conversation.id);
+            params.onConversationStatusChange?.(conversation.id, 'idle');
+        }
+    }
+    const clearedAggregateCount = 0;
+    const clearedCooldownCount = 0;
+    const clearedFollowupCount = deleteTaskThreadFollowupsForTask(params.db, params.taskId);
+    supersedeNotificationRoundsForThreadRoots(params.db, {
+        channelId: binding.channelId,
+        threadRootIds: binding.threadRootIds,
+        now,
+        reason: `Task thread closed: ${params.reason}`,
+    });
+    return {
+        closed: true,
+        conversationIds: conversations.map((conversation) => conversation.id),
+        cancelledRunIds,
+        clearedQueuedPromptCount,
+        clearedAggregateCount,
+        clearedCooldownCount,
+        clearedFollowupCount,
+        idledConversationIds,
+    };
+}
+export function sealTaskThreadRuntimeState(params) {
+    const now = Date.now();
+    const binding = getThreadBindingForTask(params.db, params.taskId);
+    if (!binding) {
+        return {
+            sealed: false,
+            conversationIds: [],
+            preservedActiveRuns: [],
+            clearedQueuedPromptCount: 0,
+            clearedAggregateCount: 0,
+            clearedCooldownCount: 0,
+            clearedFollowupCount: 0,
+            idledConversationIds: [],
+        };
+    }
+    const conversations = listTaskThreadConversations(params.db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+        dmUserId: params.dmUserId,
+    });
+    const preservedActiveRuns = [];
+    const idledConversationIds = [];
+    let clearedQueuedPromptCount = 0;
+    const ownerConversationId = params.ownerConversationId ?? null;
+    const ownerRunId = params.ownerRunId ?? null;
+    const ownerAgentId = params.ownerAgentId ?? null;
+    for (const conversation of conversations) {
+        clearTaskThreadClosingStateForConversation(conversation.id);
+        clearTaskThreadReopenedRunBlockForConversation(conversation.id);
+        const openRunId = findOpenRunId(params.db, conversation.sessionKey);
+        const isOwnerConversation = Boolean(params.reason === 'in_review'
+            && ownerConversationId
+            && ownerRunId
+            && conversation.id === ownerConversationId
+            && openRunId === ownerRunId
+            && (!ownerAgentId || conversation.agentId === ownerAgentId));
+        setTaskThreadClosingState(conversation.id, {
+            taskId: params.taskId,
+            channelId: binding.channelId,
+            threadRootId: binding.threadRootId,
+            reason: params.reason,
+            ownerAgentId,
+            ownerRunId,
+            allowOneFinal: isOwnerConversation,
+            finalSent: false,
+        });
+        clearedQueuedPromptCount += params.db.prepare(`DELETE FROM conversation_prompt_queue
+       WHERE conversation_id = ?`).run(conversation.id).changes;
+        if (openRunId) {
+            preservedActiveRuns.push({
+                conversationId: conversation.id,
+                runId: openRunId,
+                agentId: conversation.agentId,
+            });
+        }
+        if (restoreIdleConversationStatus(params.db, conversation)) {
+            idledConversationIds.push(conversation.id);
+            params.onConversationStatusChange?.(conversation.id, 'idle');
+        }
+    }
+    const clearedAggregateCount = 0;
+    const clearedCooldownCount = 0;
+    const clearedFollowupCount = deleteTaskThreadFollowupsForTask(params.db, params.taskId);
+    supersedeNotificationRoundsForThreadRoots(params.db, {
+        channelId: binding.channelId,
+        threadRootIds: binding.threadRootIds,
+        now,
+        reason: `Task thread sealed: ${params.reason}`,
+    });
+    return {
+        sealed: true,
+        conversationIds: conversations.map((conversation) => conversation.id),
+        preservedActiveRuns,
+        clearedQueuedPromptCount,
+        clearedAggregateCount,
+        clearedCooldownCount,
+        clearedFollowupCount,
+        idledConversationIds,
+    };
+}
+export function buildTaskThreadReviewCleanupNotice(params) {
+    return [
+        '[System notice]',
+        `Task #${params.taskNumber} "${params.title}" has moved to in_review.`,
+        'This channel task thread is now closed for user-visible chat.',
+        'Finish any private cleanup now, including MEMORY.md or notes updates if needed, then stop.',
+        'Do not send visible chat, and do not post to this task thread.',
+    ].join('\n');
+}
+export function softCloseTaskThreadForReview(params) {
+    const now = Date.now();
+    const binding = getThreadBindingForTask(params.db, params.taskId);
+    clearTaskThreadClosingStateForTask(params.db, params.taskId);
+    clearTaskThreadReopenedRunBlocksForTask(params.db, params.taskId);
+    if (!binding) {
+        return {
+            closed: false,
+            conversationIds: [],
+            preservedActiveRuns: [],
+            clearedQueuedPromptCount: 0,
+            clearedAggregateCount: 0,
+            clearedCooldownCount: 0,
+            clearedFollowupCount: 0,
+            idledConversationIds: [],
+            preservedConversationId: null,
+            cancelledRunIds: [],
+        };
+    }
+    const conversations = listTaskThreadConversations(params.db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+    });
+    const preservedActiveRuns = [];
+    const cancelledRunIds = [];
+    const idledConversationIds = [];
+    let clearedQueuedPromptCount = 0;
+    const ownerConversationId = params.ownerConversationId ?? null;
+    const ownerRunId = params.ownerRunId ?? null;
+    const ownerAgentId = params.ownerAgentId ?? null;
+    for (const conversation of conversations) {
+        const openRunId = findOpenRunId(params.db, conversation.sessionKey);
+        const isOwnerConversation = Boolean(ownerConversationId
+            && ownerRunId
+            && conversation.id === ownerConversationId
+            && openRunId === ownerRunId
+            && (!ownerAgentId || conversation.agentId === ownerAgentId));
+        setTaskThreadClosingState(conversation.id, {
+            taskId: params.taskId,
+            channelId: binding.channelId,
+            threadRootId: binding.threadRootId,
+            reason: 'in_review',
+            ownerAgentId,
+            ownerRunId,
+            allowOneFinal: isOwnerConversation,
+            finalSent: false,
+        });
+        clearedQueuedPromptCount += params.db.prepare(`DELETE FROM conversation_prompt_queue
+       WHERE conversation_id = ?`).run(conversation.id).changes;
+        if (openRunId && !isOwnerConversation) {
+            if (hasEffectiveAgentRuntimeCapability(params.db, {
+                nodeId: conversation.nodeId,
+                agentType: conversation.agentType,
+                capability: 'activeTurnSteer',
+            })) {
+                preservedActiveRuns.push({
+                    conversationId: conversation.id,
+                    runId: openRunId,
+                    agentId: conversation.agentId,
+                });
+            }
+            else if (params.conversationManager) {
+                const cancelResult = params.conversationManager.cancelConversationRun(conversation.id, openRunId);
+                if (cancelResult.ok && cancelResult.runId) {
+                    cancelledRunIds.push(cancelResult.runId);
+                    const activeResult = params.db.prepare(`UPDATE conversations
+             SET status = 'active', updated_at = ?
+             WHERE id = ?
+               AND status = 'queued'`).run(Date.now(), conversation.id);
+                    if (activeResult.changes > 0) {
+                        params.onConversationStatusChange?.(conversation.id, 'active');
+                    }
+                }
+                else if (cancelResult.message && cancelResult.message !== 'No active run to cancel.') {
+                    log.warn('[task-thread-runtime-closure] failed to cancel non-steerable active run during review soft-close', {
+                        taskId: params.taskId,
+                        conversationId: conversation.id,
+                        error: cancelResult.message,
+                    });
+                }
+            }
+            else {
+                log.warn('[task-thread-runtime-closure] cannot preserve non-steerable active run during review soft-close without a conversation manager', {
+                    taskId: params.taskId,
+                    conversationId: conversation.id,
+                    runId: openRunId,
+                    agentType: conversation.agentType,
+                });
+            }
+        }
+        if (restoreIdleConversationStatus(params.db, conversation)) {
+            idledConversationIds.push(conversation.id);
+            params.onConversationStatusChange?.(conversation.id, 'idle');
+        }
+    }
+    const clearedAggregateCount = 0;
+    const clearedCooldownCount = 0;
+    const clearedFollowupCount = deleteTaskThreadFollowupsForTask(params.db, params.taskId);
+    supersedeNotificationRoundsForThreadRoots(params.db, {
+        channelId: binding.channelId,
+        threadRootIds: binding.threadRootIds,
+        now,
+        reason: 'Task thread soft-closed for review',
+    });
+    return {
+        closed: true,
+        conversationIds: conversations.map((conversation) => conversation.id),
+        preservedActiveRuns,
+        clearedQueuedPromptCount,
+        clearedAggregateCount,
+        clearedCooldownCount,
+        clearedFollowupCount,
+        idledConversationIds,
+        preservedConversationId: ownerConversationId,
+        cancelledRunIds,
+    };
+}
+export function beginTaskThreadClosing(params) {
+    const binding = getThreadBindingForTask(params.db, params.taskId);
+    clearTaskThreadClosingStateForTask(params.db, params.taskId);
+    clearTaskThreadReopenedRunBlocksForTask(params.db, params.taskId);
+    if (!binding) {
+        return {
+            closed: false,
+            conversationIds: [],
+            cancelledRunIds: [],
+            clearedQueuedPromptCount: 0,
+            clearedAggregateCount: 0,
+            clearedCooldownCount: 0,
+            clearedFollowupCount: 0,
+            idledConversationIds: [],
+            preservedConversationId: null,
+        };
+    }
+    const conversations = listTaskThreadConversations(params.db, {
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+    });
+    const ownerConversation = conversations.find((conversation) => conversation.id === params.ownerConversationId);
+    if (!ownerConversation) {
+        return {
+            closed: false,
+            conversationIds: conversations.map((conversation) => conversation.id),
+            cancelledRunIds: [],
+            clearedQueuedPromptCount: 0,
+            clearedAggregateCount: 0,
+            clearedCooldownCount: 0,
+            clearedFollowupCount: 0,
+            idledConversationIds: [],
+            preservedConversationId: null,
+        };
+    }
+    const cancelledRunIds = [];
+    const idledConversationIds = [];
+    let clearedQueuedPromptCount = 0;
+    for (const conversation of conversations) {
+        const isOwnerConversation = conversation.id === params.ownerConversationId;
+        setTaskThreadClosingState(conversation.id, {
+            taskId: params.taskId,
+            channelId: binding.channelId,
+            threadRootId: binding.threadRootId,
+            reason: params.reason,
+            ownerAgentId: params.ownerAgentId ?? null,
+            ownerRunId: params.ownerRunId,
+            allowOneFinal: isOwnerConversation,
+            finalSent: false,
+        });
+        clearedQueuedPromptCount += params.db.prepare(`DELETE FROM conversation_prompt_queue
+       WHERE conversation_id = ?`).run(conversation.id).changes;
+        if (isOwnerConversation) {
+            continue;
+        }
+        const cancelResult = params.conversationManager.cancelConversationRun(conversation.id);
+        if (cancelResult.ok && cancelResult.runId) {
+            cancelledRunIds.push(cancelResult.runId);
+        }
+        else if (cancelResult.message && cancelResult.message !== 'No active run to cancel.') {
+            log.warn('[task-thread-runtime-closure] failed to cancel active run during graceful close', {
+                taskId: params.taskId,
+                conversationId: conversation.id,
+                reason: params.reason,
+                error: cancelResult.message,
+            });
+        }
+        if (restoreIdleConversationStatus(params.db, conversation)) {
+            idledConversationIds.push(conversation.id);
+            params.onConversationStatusChange?.(conversation.id, 'idle');
+        }
+    }
+    const clearedAggregateCount = 0;
+    const clearedCooldownCount = 0;
+    const clearedFollowupCount = deleteTaskThreadFollowupsForTask(params.db, params.taskId);
+    return {
+        closed: true,
+        conversationIds: conversations.map((conversation) => conversation.id),
+        cancelledRunIds,
+        clearedQueuedPromptCount,
+        clearedAggregateCount,
+        clearedCooldownCount,
+        clearedFollowupCount,
+        idledConversationIds,
+        preservedConversationId: params.ownerConversationId,
+    };
+}