@bbigbang/core 0.1.0

package/dist/execution/executionDispatcher.js

@@ -0,0 +1,3810 @@
+import { randomUUID } from 'node:crypto';
+import os from 'node:os';
+import { getRuntimeDriver, } from '@bbigbang/protocol';
+import { buildAgentSessionSystemPromptText, buildDreamSystemPrompt, loadDreamAnthropicEnv, resolveDreamEnvPath, } from '@bbigbang/memory';
+import { buildDreamContextText, claimDreamRunLock, countAgentMessagesSinceSeq, finalizeDreamRun, listAgentMessagesSinceSeq, releaseDreamRunLock, } from '../services/memoryService.js';
+import { createRun, finishRun, log } from '@bbigbang/runtime-acp';
+import { iterateParsedNodeEvents } from '../nodeEventHistory.js';
+import { buildPlatformAgentSystemPrompt, isPlatformAgentRole, } from '../services/platformAgentPolicy.js';
+import { buildDirectActivationContextSections, buildDirectActivationPrompt, } from '../web/directActivationPrompt.js';
+import { resolveConversationReplyTarget } from '../web/directReplyTargets.js';
+import { allocateNextChannelMessageSeq } from '../web/channelMessageSequences.js';
+import { buildDirectSurfaceActivationEnvelope, } from '../web/activationContext.js';
+import { refreshConversationSummariesForMessageScope } from '../web/conversationSummaries.js';
+import { buildContextBundle, buildRelevantContextHintSection } from '../web/contextBundleResolver.js';
+import { getSnapshotConversationStatus } from '../web/planApprovalState.js';
+import { buildRollingSummaryPromptSection, isCodexRuntimeRotationPending, } from '../web/rollingConversationSummary.js';
+import { extractRelevantContextStrongSignals, shouldPreinjectRelevantContextHint } from '../web/surfaceActivationPolicy.js';
+import { sanitizePromptHistoryContent } from '../web/promptHistorySanitizer.js';
+import { EXACT_TARGET_HISTORY_SECTION_KINDS, createPromptContextSection, inferPromptContextSections, isPromptContextSectionKind, renderPromptContextSections, } from '../web/promptContextSections.js';
+import { buildActiveProjectSection, buildDefaultDirectMemoryHints, buildWorkspaceMemoryReminder, getCurrentISOWeek, } from '../web/workspaceMemoryHints.js';
+import { buildSurfaceSystemStatusSection } from '../web/surfaceSystemStatus.js';
+import { hasEffectiveAgentRuntimeCapability } from '../web/runtimeCapabilities.js';
+import { buildUiPanelGuidancePromptSection } from '../web/uiPanelPromptGuidance.js';
+import { buildLibraryDocumentGuidancePromptSection } from '../web/libraryDocumentPromptGuidance.js';
+import { buildWorkspaceToolGuidancePromptSection } from '../web/workspaceToolPromptGuidance.js';
+import { conversationBuiltinSkillRootsForSlashCommand, normalizeConversationBuiltinSkillRoots, parseConversationBuiltinSkillRoots, serializeConversationBuiltinSkillRoots, } from '../web/conversationBuiltinSkillRoots.js';
+import { isLayoutPlanPromptSlashCommandName, isPanelPromptSlashCommandName, isWorkspaceToolPromptSlashCommandName, normalizePromptSlashCommandName, } from '../web/promptSlashCommands.js';
+function mergeDispatchSkillRoots(skillRoots, builtinSkillRoots) {
+    const merged = [...builtinSkillRoots];
+    for (const root of skillRoots ?? []) {
+        const normalized = root.trim();
+        if (!normalized || merged.includes(normalized))
+            continue;
+        merged.push(normalized);
+    }
+    return merged.length > 0 ? merged : undefined;
+}
+function normalizeDispatchEnabledSkillPaths(paths) {
+    if (!paths)
+        return undefined;
+    const seen = new Set();
+    const normalized = [];
+    for (const value of paths) {
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        normalized.push(trimmed);
+    }
+    return normalized.length > 0 ? normalized : [];
+}
+function buildTurnReplyContract(today = getCurrentISOWeek(), agentSurfaceMode = 'bigbang') {
+    if (agentSurfaceMode === 'mcp') {
+        return [
+            '[Reply contract]',
+            `Current date (Beijing / UTC+8): ${today.week} (${today.date})`,
+            'Reply only via `mcp__chat__send_message`. Do not output user-visible text directly.',
+            'Use `mcp__chat__send_message(content="...", kind="progress")` only while work is ongoing. Before the run ends, send one final user-visible message with `mcp__chat__send_message(content="...", kind="final")`.',
+            'If there is no visible or peer-visible value to add, do not send a message. On shared channels/threads, leave peer_delivery unset for coordination-relevant updates so peers receive the default batch delivery; use peer_delivery="silent" only for visible no-action status, local bookkeeping, duplicate presence, or waiting updates that should not ordinary-notify peers. If unsure, prefer default batch. Do not set peer delivery in DMs.',
+            '- Use `mcp__chat__get_self_state` only for a broad agent-wide work overview across surfaces.',
+            '- Use `mcp__chat__get_runtime_presence` only for node / host / runtime facts.',
+            '- Use `mcp__chat__inspect_workspace` only for current workspace git / directory facts.',
+            '- Use `mcp__chat__list_my_conversations` to rediscover surfaces in bulk, and `mcp__chat__get_conversation_summary` for one known surface.',
+            '- Use `mcp__chat__get_relevant_context_bundle` only to narrow among related surfaces, tasks, or handoffs before deeper inspection or handoff; it is not the canonical state source.',
+            '- Use `mcp__chat__list_my_tasks` to rediscover tasks in bulk, `mcp__chat__get_task_status` for one known task\'s current state, and `mcp__chat__get_task_history` only when lifecycle details matter.',
+            '- Do not call broad state tools by default when the current activation context or exact-target history already answers the request.',
+            'If the request requires trackable work beyond replying, claim or create a task before starting. Prefer `mcp__chat__claim_tasks`; use `mcp__chat__create_tasks` only when you genuinely need a new task.',
+            'On shared task threads, if collaborator work is explicitly part of the task, wait for the collaborator result or a clear user instruction to stop waiting before sending the final result or moving the task to in_review/done.',
+            'If this run produced durable user, project, or task knowledge, proactively update MEMORY.md and relevant notes before ending the run.',
+        ].join('\n');
+    }
+    return [
+        '[Reply contract]',
+        `Current date (Beijing / UTC+8): ${today.week} (${today.date})`,
+        'Reply only via `bigbang message send`. Do not output user-visible text directly.',
+        'Use `bigbang message send --kind progress` only while work is ongoing. Before the run ends, send one final user-visible message with `bigbang message send --kind final`.',
+        'If there is no visible or peer-visible value to add, do not send a message. On shared channels/threads, leave `--peer-delivery` unset for coordination-relevant updates so peers receive the default batch delivery; use `--peer-delivery silent` only for visible no-action status, local bookkeeping, duplicate presence, or waiting updates that should not ordinary-notify peers. If unsure, prefer default batch. Do not set peer delivery in DMs.',
+        '- Use `bigbang self state` only for a broad agent-wide work overview across surfaces.',
+        '- Use `bigbang runtime presence` only for node / host / runtime facts.',
+        '- Use `bigbang workspace inspect` only for current workspace git / directory facts.',
+        '- Use `bigbang conversation list` to rediscover surfaces in bulk, and `bigbang conversation summary` for one known surface.',
+        '- Use `bigbang context bundle` only to narrow among related surfaces, tasks, or handoffs before deeper inspection or handoff; it is not the canonical state source.',
+        '- Use `bigbang task my` to rediscover tasks in bulk, `bigbang task status` for one known task\'s current state, and `bigbang task history` only when lifecycle details matter.',
+        '- Do not call broad state tools by default when the current activation context or exact-target history already answers the request.',
+        'If the request requires trackable work beyond replying, claim or create a task before starting. Prefer `bigbang task claim`; use `bigbang task create` only when you genuinely need a new task.',
+        'On shared task threads, if collaborator work is explicitly part of the task, wait for the collaborator result or a clear user instruction to stop waiting before sending the final result or moving the task to in_review/done.',
+        'If this run produced durable user, project, or task knowledge, proactively update MEMORY.md and relevant notes before ending the run.',
+    ].join('\n');
+}
+const ACTIVE_TURN_STEER_RESPONSE_TIMEOUT_MS = 35_000;
+const CLAUDE_SDK_ACTIVE_TURN_STEER_RESPONSE_TIMEOUT_MS = 6 * 60_000;
+const MAX_PROCESSED_STEER_RESULT_REQUEST_IDS = 10_000;
+const ORPHANED_QUEUE_ATTEMPT_STALE_MS = 5 * 60_000;
+function inferPlatformRunMode(recordAsUserMessage) {
+    return recordAsUserMessage ? 'debug' : 'workflow';
+}
+function isPlatformWorkflowType(value) {
+    return value === 'planner_suggestions' || value === 'library_curate';
+}
+function normalizePlatformRunMetadata(value) {
+    if (!value || typeof value.definitionId !== 'string' || !value.definitionId.trim())
+        return undefined;
+    if (!isPlatformWorkflowType(value.workflowType))
+        return undefined;
+    if (value.mode !== 'workflow' && value.mode !== 'debug')
+        return undefined;
+    return {
+        definitionId: value.definitionId.trim(),
+        workflowType: value.workflowType,
+        mode: value.mode,
+    };
+}
+function normalizeOwnerAwarenessMetadata(value) {
+    if (!value || value.mode !== 'collaborator_only_thread_reply' || !Number.isFinite(value.triggerSeq)) {
+        return undefined;
+    }
+    const mentionedAgentIds = Array.isArray(value.mentionedAgentIds)
+        ? [...new Set(value.mentionedAgentIds
+                .filter((agentId) => typeof agentId === 'string' && agentId.trim().length > 0)
+                .map((agentId) => agentId.trim()))]
+        : [];
+    if (mentionedAgentIds.length === 0)
+        return undefined;
+    return {
+        mode: 'collaborator_only_thread_reply',
+        triggerSeq: Math.floor(value.triggerSeq),
+        mentionedAgentIds,
+    };
+}
+function resolvePlatformRunContext(db, agentRole, agentId) {
+    if (!agentId?.trim())
+        return null;
+    if (agentRole === 'library_curator') {
+        return { definitionId: 'library_curator', workflowType: 'library_curate' };
+    }
+    if (agentRole === 'suggested_planner') {
+        return { definitionId: 'suggested_planner', workflowType: 'planner_suggestions' };
+    }
+    if (agentRole !== 'platform_agent')
+        return null;
+    try {
+        const row = db.prepare(`SELECT pai.definition_id as definitionId,
+              pad.workflow_type as workflowType
+         FROM platform_agent_instances pai
+         JOIN platform_agent_definitions pad ON pad.definition_id = pai.definition_id
+        WHERE pai.agent_id = ?
+        LIMIT 1`).get(agentId);
+        if (!row || !isPlatformWorkflowType(row.workflowType))
+            return null;
+        return row;
+    }
+    catch {
+        // Fall through to legacy builtin config tables below.
+    }
+    try {
+        const planner = db.prepare(`SELECT 1
+         FROM suggested_planner_configs
+        WHERE planner_agent_id = ?
+        LIMIT 1`).get(agentId);
+        if (planner) {
+            return { definitionId: 'suggested_planner', workflowType: 'planner_suggestions' };
+        }
+    }
+    catch {
+        // Ignore missing legacy tables.
+    }
+    try {
+        const curator = db.prepare(`SELECT 1
+         FROM library_curator_configs
+        WHERE curator_agent_id = ?
+        LIMIT 1`).get(agentId);
+        if (curator) {
+            return { definitionId: 'library_curator', workflowType: 'library_curate' };
+        }
+    }
+    catch {
+        // Ignore missing legacy tables.
+    }
+    return null;
+}
+function ensurePlatformRunMetadata(db, agentRole, agentId, metadata, recordAsUserMessage) {
+    if (!isPlatformAgentRole(agentRole))
+        return metadata;
+    const platformRun = normalizePlatformRunMetadata(metadata?.platformRun);
+    const resolved = resolvePlatformRunContext(db, agentRole, agentId);
+    if (!resolved && !platformRun)
+        return {
+            ...(metadata ?? {}),
+            suppressReplyContract: true,
+        };
+    return {
+        ...(metadata ?? {}),
+        platformRun: platformRun ?? {
+            definitionId: resolved.definitionId,
+            workflowType: resolved.workflowType,
+            mode: inferPlatformRunMode(recordAsUserMessage),
+        },
+        suppressReplyContract: true,
+    };
+}
+function getPlatformAgentDispatchBlockReason(db, agentRole, agentId, metadata) {
+    if (!agentId || !isPlatformAgentRole(agentRole))
+        return null;
+    const platformRun = normalizePlatformRunMetadata(metadata?.platformRun);
+    const resolved = platformRun ?? resolvePlatformRunContext(db, agentRole, agentId);
+    if (!resolved)
+        return null;
+    try {
+        const row = db.prepare(`SELECT pai.enabled as instanceEnabled,
+              pai.deleted_at as deletedAt,
+              pad.enabled as definitionEnabled
+         FROM platform_agent_instances pai
+         JOIN platform_agent_definitions pad ON pad.definition_id = pai.definition_id
+        WHERE pai.agent_id = ?
+          AND pai.definition_id = ?
+        LIMIT 1`).get(agentId, resolved.definitionId);
+        if (!row)
+            return null;
+        if (row.deletedAt != null)
+            return 'Platform agent instance has been deleted';
+        if (row.definitionEnabled !== 1)
+            return 'Platform definition is disabled';
+        if (row.instanceEnabled !== 1)
+            return 'Platform instance is disabled';
+    }
+    catch {
+        // Legacy schemas may not have generic platform-agent tables yet.
+    }
+    return null;
+}
+const RECOVERABLE_ENDED_RUN_ERRORS = new Set([
+    'Core restarted before run completed',
+    'Node disconnected during dispatch',
+    'Node not connected',
+]);
+function isRecoverableEndedRunError(error) {
+    const normalized = error?.trim();
+    if (!normalized)
+        return false;
+    return RECOVERABLE_ENDED_RUN_ERRORS.has(normalized) || normalized.startsWith('Agent node disconnected: ');
+}
+export class ExecutionDispatcher {
+    db;
+    config;
+    nodeRegistry;
+    getAgentById;
+    pendingDispatchAcceptances = new Map();
+    pendingSteerResponses = new Map();
+    processedSteerResultRequestIds = new Set();
+    steerChains = new Map();
+    queueRetryTimers = new Map();
+    libraryService;
+    constructor(params) {
+        this.db = params.db;
+        this.config = params.config;
+        this.nodeRegistry = params.nodeRegistry;
+        this.getAgentById = params.getAgentById;
+        this.libraryService = params.libraryService;
+    }
+    setLibraryService(libraryService) {
+        this.libraryService = libraryService;
+    }
+    async dispatchDream(agentId) {
+        const agent = this.getAgentById(agentId);
+        if (!agent)
+            throw new Error(`Unknown agent: ${agentId}`);
+        if (!agent.memoryNetworkEnabled)
+            throw new Error('Memory Network is not enabled for this agent');
+        if (!agent.dreamEnabled)
+            throw new Error('Dream is not enabled for this agent');
+        if (!agent.nodeId)
+            throw new Error(`Agent has no node: ${agentId}`);
+        const conversation = this.db.prepare(`SELECT id as conversationId,
+              session_key as sessionKey,
+              workspace_path as workspacePath
+         FROM conversations
+        WHERE agent_id = ?
+          AND thread_kind = 'direct'
+          AND is_primary_thread = 1
+        LIMIT 1`).get(agentId);
+        if (!conversation)
+            throw new Error(`No primary DM conversation for agent: ${agentId}`);
+        const lastDreamSeq = agent.lastDreamSeq ?? null;
+        const dreamMessages = listAgentMessagesSinceSeq(this.db, agentId, lastDreamSeq);
+        const newMessageCount = dreamMessages.length || countAgentMessagesSinceSeq(this.db, agentId, lastDreamSeq);
+        if (newMessageCount <= 0)
+            throw new Error('No new messages for dream');
+        if (!claimDreamRunLock(this.db, agentId))
+            throw new Error(`Dream already in progress: ${agentId}`);
+        const dreamContextText = buildDreamContextText(dreamMessages);
+        const dreamPrompt = buildDreamSystemPrompt({
+            lastDreamAt: agent.lastDreamAt ?? null,
+            newMessageCount,
+        });
+        const runId = randomUUID();
+        const hostKey = `dream:${agentId}:claude_sdk`;
+        const dispatchMode = 'dream';
+        const dreamDisabledToolKinds = ['execute', 'edit', 'delete', 'move'];
+        createRun(this.db, { runId, sessionKey: conversation.sessionKey, promptText: dreamPrompt });
+        upsertPendingRunDebugInput(this.db, {
+            runId,
+            conversationId: conversation.conversationId,
+            sessionKey: conversation.sessionKey,
+            dispatchMode,
+            replyTarget: null,
+            systemPromptText: dreamPrompt,
+            contextText: dreamContextText,
+            promptText: dreamPrompt,
+            dispatchedPromptText: dreamContextText
+                ? `${dreamPrompt}\n\n## 新消息\n${dreamContextText}`
+                : dreamPrompt,
+            agentSurfaceMode: 'bigbang',
+            activationMetadataJson: JSON.stringify({ dreamRun: true, agentId, dreamStartSeq: lastDreamSeq }),
+        });
+        const node = this.nodeRegistry?.getNode(agent.nodeId);
+        if (!node) {
+            releaseDreamRunLock(this.db, agentId);
+            finishRun(this.db, { runId, error: 'Node not connected' });
+            throw new Error(`Node not connected: ${agent.nodeId}`);
+        }
+        if (!node.agentTypes.includes('claude_sdk')) {
+            const errorMessage = 'Node does not support claude_sdk for dream runs';
+            releaseDreamRunLock(this.db, agentId);
+            finishRun(this.db, { runId, error: errorMessage });
+            throw new Error(`${errorMessage}: ${agent.nodeId}`);
+        }
+        const dispatchAgentSurfaceMode = 'bigbang';
+        const nodeSurfaceReadiness = this.loadNodeSurfaceReadiness(agent.nodeId);
+        const failDreamNodeSurfaceReadiness = (errorMessage) => {
+            releaseDreamRunLock(this.db, agentId);
+            finishRun(this.db, { runId, error: errorMessage });
+            throw new Error(`${errorMessage}: ${agent.nodeId}`);
+        };
+        if (!nodeSurfaceReadiness.hasSnapshot) {
+            failDreamNodeSurfaceReadiness('Node surface readiness missing');
+        }
+        if (node.processInstanceId && nodeSurfaceReadiness.processInstanceId !== node.processInstanceId) {
+            failDreamNodeSurfaceReadiness('Node surface readiness stale');
+        }
+        if (nodeSurfaceReadiness.agentSurfaceMode !== dispatchAgentSurfaceMode) {
+            const actual = nodeSurfaceReadiness.agentSurfaceMode ?? 'missing';
+            failDreamNodeSurfaceReadiness(`Node surface mismatch: expected ${dispatchAgentSurfaceMode}, got ${actual}`);
+        }
+        if (dispatchAgentSurfaceMode === 'bigbang' && nodeSurfaceReadiness.bigbangCliAvailable !== true) {
+            failDreamNodeSurfaceReadiness('Bigbang CLI unavailable on node');
+        }
+        const channelBridgeConfig = {
+            agentId,
+            conversationId: conversation.conversationId,
+            serverUrl: this.resolveChannelBridgeServerUrl(agent.nodeId),
+            authToken: this.config.internalAgentAuthToken,
+        };
+        const dreamEnvVars = loadDreamAnthropicEnv(resolveDreamEnvPath());
+        const acceptance = this.waitForDispatchAcceptance(runId, agent.nodeId, conversation.conversationId);
+        const sent = this.nodeRegistry.send(agent.nodeId, {
+            type: 'run.dispatch',
+            runId,
+            conversationId: conversation.conversationId,
+            agentType: 'claude_sdk',
+            agentSurfaceMode: 'bigbang',
+            workspacePath: conversation.workspacePath ?? agent.workspacePath ?? null,
+            agentName: agent.name,
+            envVars: dreamEnvVars,
+            disabledToolKinds: dreamDisabledToolKinds,
+            prompt: dreamPrompt,
+            sessionKey: conversation.sessionKey,
+            hostKey,
+            dispatchMode,
+            systemPromptText: dreamPrompt,
+            contextText: dreamContextText ?? undefined,
+            channelBridgeConfig,
+        });
+        if (!sent) {
+            this.clearPendingDispatchAcceptance(runId);
+            releaseDreamRunLock(this.db, agentId);
+            finishRun(this.db, { runId, error: 'Node disconnected during dispatch' });
+            throw new Error(`Node disconnected: ${agent.nodeId}`);
+        }
+        try {
+            await acceptance;
+        }
+        catch (error) {
+            releaseDreamRunLock(this.db, agentId);
+            finishRun(this.db, { runId, error: String(error?.message ?? error) });
+            throw error;
+        }
+        return { runId };
+    }
+    async dispatchPrompt(conversationId, promptText, options) {
+        const row = this.db.prepare(`SELECT session_key as sessionKey, agent_type as agentType,
+              channel_id as channelId, is_primary_thread as isPrimaryThread,
+              workspace_path as workspacePath, env_vars as envVarsJson,
+              node_id as nodeId, agent_id as agentId, reply_target as replyTarget,
+              thread_kind as threadKind, thread_root_id as threadRootId,
+              active_project_id as activeProjectId, user_id as userId, title
+              , personal_library_enabled as personalLibraryEnabled
+              , builtin_skill_roots as builtinSkillRootsJson
+       FROM conversations WHERE id = ?`).get(conversationId);
+        if (!row)
+            throw new Error(`Unknown conversation: ${conversationId}`);
+        if (!row.nodeId)
+            throw new Error('No agent node assigned. Connect an agent-node first.');
+        const runId = randomUUID();
+        const hostKey = `conversation:${conversationId}:${row.agentType}`;
+        const dispatchMode = this.getDispatchMode(row.sessionKey);
+        const driver = getRuntimeDriver(row.agentType);
+        const recordAsUserMessage = options?.recordAsUserMessage ?? true;
+        const promptAttachments = sanitizeFileRefs(options?.attachments);
+        const configAgentSurfaceMode = normalizeDispatchAgentSurfaceMode(this.config.agentSurfaceMode, 'bigbang');
+        const dispatchAgentSurfaceMode = normalizeDispatchAgentSurfaceMode(options?.agentSurfaceMode, configAgentSurfaceMode);
+        // Persist run and user message BEFORE node connectivity check so they survive
+        // even if the node is offline — the user's message will still be visible after refresh.
+        createRun(this.db, { runId, sessionKey: row.sessionKey, promptText });
+        if (options?.queuedPromptId != null) {
+            this.markQueueDispatchAttempt(options.queuedPromptId, runId, 'dispatch');
+        }
+        let contextText = '';
+        let resumeContextText = '';
+        const contextSections = [];
+        const resumeSections = [];
+        let optionActivationExactHistorySupersedesResumeExact = false;
+        let systemPromptText = '';
+        const activeProject = row.activeProjectId
+            ? this.db.prepare(`SELECT name, backend_type as backendType, root_path as rootPath
+           FROM projects
+          WHERE project_id = ?
+            AND archived_at IS NULL`).get(row.activeProjectId)
+            : undefined;
+        const activeProjectSection = buildActiveProjectSection(activeProject ?? null);
+        const activeProjectContextSection = createPromptContextSection('active_project', activeProjectSection);
+        const dispatchToday = getCurrentISOWeek();
+        let agentEnvVars;
+        let disabledToolKinds;
+        let activationMetadata = options?.activationMetadata
+            ? { ...options.activationMetadata }
+            : undefined;
+        if (options?.suppressReplyContract === true) {
+            activationMetadata = {
+                ...(activationMetadata ?? {}),
+                suppressReplyContract: true,
+            };
+        }
+        if (promptAttachments.length > 0) {
+            activationMetadata = {
+                ...(activationMetadata ?? {}),
+                attachments: promptAttachments,
+            };
+        }
+        const promptAttachmentIds = sanitizeAttachmentIds(options?.attachmentIds);
+        if (promptAttachmentIds.length > 0) {
+            activationMetadata = {
+                ...(activationMetadata ?? {}),
+                attachmentIds: promptAttachmentIds,
+            };
+        }
+        const runtimeOverrides = normalizePromptRuntimeOverrides(options?.runtimeOverrides);
+        if (runtimeOverrides) {
+            activationMetadata = {
+                ...(activationMetadata ?? {}),
+                runtimeOverrides,
+            };
+        }
+        const promptSlashCommandName = activationMetadata?.slashCommand?.name ?? null;
+        const workspaceToolSlashRequested = isWorkspaceToolPromptSlashCommandName(promptSlashCommandName);
+        const suppressDirectMemoryHints = workspaceToolSlashRequested;
+        if (row.agentId) {
+            const agent = this.getAgentById(row.agentId);
+            if (agent) {
+                activationMetadata = ensurePlatformRunMetadata(this.db, agent.agentRole, row.agentId, activationMetadata, recordAsUserMessage);
+                agentEnvVars = agent.envVars;
+                disabledToolKinds = agent.disabledToolKinds;
+                const skipDirectActivationEnvelope = isPlatformAgentRole(agent.agentRole)
+                    && activationMetadata?.platformRun?.mode === 'debug';
+                systemPromptText = isPlatformAgentRole(agent.agentRole)
+                    ? buildPlatformAgentSystemPrompt({
+                        definitionId: activationMetadata?.platformRun?.definitionId ?? 'platform',
+                        workflowType: activationMetadata?.platformRun?.workflowType ?? 'planner_suggestions',
+                        mode: activationMetadata?.platformRun?.mode ?? inferPlatformRunMode(recordAsUserMessage),
+                        agentName: agent.name,
+                        workspacePath: row.workspacePath ?? this.config.workspaceRoot,
+                    })
+                    : buildAgentSessionSystemPromptText({
+                        agentName: agent.name,
+                        agentBio: agent.description || undefined,
+                        agentDescription: agent.systemPrompt || undefined,
+                        workspacePath: row.workspacePath ?? this.config.workspaceRoot,
+                        agentSurfaceMode: dispatchAgentSurfaceMode,
+                        extraCriticalRules: workspaceToolSlashRequested
+                            ? [
+                                '- For this workspace-tool slash-command run, the slash command body and injected workspace-tool guidance are the startup context. Skip the default Startup sequence memory pre-read; do not read MEMORY.md, notes, work logs, channel history, or library documents before acting unless the user explicitly asks for those files.',
+                                dispatchAgentSurfaceMode === 'mcp'
+                                    ? '- In workspace-tool publish mode, after publish_workspace_tool succeeds, immediately send one final visible reply with `mcp__chat__send_message(content="...", kind="final")` before any other inspection or cleanup.'
+                                    : '- In workspace-tool publish mode, after bigbang tool publish succeeds, immediately send one final visible reply with `bigbang message send --kind final` before any other inspection or cleanup.',
+                            ]
+                            : undefined,
+                    });
+                let replayOverlapMessages = options?.replayOverlapRecentMessages;
+                let directMemoryHints = suppressDirectMemoryHints
+                    ? []
+                    : buildDefaultDirectMemoryHints({
+                        threadRootId: row.threadRootId,
+                        currentWeek: dispatchToday.week,
+                    });
+                let dmChannelId = null;
+                let humanUserName = null;
+                let dmReplyTarget = null;
+                let msgSeq = null;
+                let directPromptContent = null;
+                let directMessageContentOverride = null;
+                if (recordAsUserMessage && row.threadKind === 'direct') {
+                    const persistedMessage = this.persistDirectUserMessageForConversation({
+                        conversationId,
+                        conversation: {
+                            agentId: row.agentId,
+                            replyTarget: row.replyTarget,
+                            threadKind: row.threadKind,
+                            threadRootId: row.threadRootId,
+                        },
+                        promptText,
+                        options,
+                        attachments: promptAttachments,
+                        attachmentIds: promptAttachmentIds,
+                    });
+                    dmChannelId = persistedMessage.channelId;
+                    humanUserName = persistedMessage.senderName;
+                    dmReplyTarget = persistedMessage.replyTarget;
+                    msgSeq = persistedMessage.seq;
+                    activationMetadata = {
+                        ...(activationMetadata ?? {}),
+                        triggerMessage: {
+                            messageId: persistedMessage.messageId,
+                            seq: msgSeq,
+                            target: dmReplyTarget,
+                        },
+                    };
+                    directPromptContent = buildDispatchPromptContentForDirectMessage({
+                        promptText,
+                        slashCommand: activationMetadata?.slashCommand,
+                    });
+                    directMessageContentOverride = buildDisplayContentOverrideForDirectMessage({
+                        slashCommand: activationMetadata?.slashCommand,
+                    });
+                    if (skipDirectActivationEnvelope) {
+                        promptText = directPromptContent ?? promptText;
+                    }
+                    else {
+                        promptText = buildDirectActivationPrompt({
+                            agentName: agent.name,
+                            senderName: humanUserName,
+                            replyTarget: dmReplyTarget,
+                            content: directPromptContent,
+                            memoryHints: directMemoryHints,
+                            today: dispatchToday,
+                        });
+                    }
+                    if (!skipDirectActivationEnvelope && dispatchMode !== 'cold_start' && dmReplyTarget && msgSeq != null && directPromptContent != null) {
+                        const claudeSdkRootDmResume = agent.agentType === 'claude_sdk'
+                            && !row.threadRootId
+                            && dmReplyTarget.startsWith('dm:@');
+                        const envelope = buildDirectSurfaceActivationEnvelope(this.db, {
+                            agentId: row.agentId,
+                            channelId: dmChannelId,
+                            replyTarget: dmReplyTarget,
+                            triggerSeq: msgSeq,
+                            threadRootId: row.threadRootId,
+                            ...(directMessageContentOverride
+                                ? {
+                                    messageContentOverrides: {
+                                        [persistedMessage.messageId]: directMessageContentOverride,
+                                    },
+                                }
+                                : {}),
+                            today: dispatchToday,
+                        });
+                        replayOverlapMessages = envelope.replayOverlapRecentMessages;
+                        const directPolicy = envelope.policy.surfaceKind === 'direct' ? envelope.policy : null;
+                        const isRootDirectThread = !row.threadRootId;
+                        const suppressExactTargetHistoryForAppServerRootDm = agent.agentType === 'codex_app_server'
+                            && isRootDirectThread
+                            && dmReplyTarget.startsWith('dm:@');
+                        promptText = buildDirectActivationPrompt({
+                            agentName: agent.name,
+                            senderName: humanUserName,
+                            replyTarget: dmReplyTarget,
+                            content: directPromptContent,
+                            memoryHints: directMemoryHints,
+                            today: dispatchToday,
+                        });
+                        const envelopeResumeContextSections = stripWorkspaceMemoryReminderSections(envelope.resumeContextSections, workspaceToolSlashRequested);
+                        const claudeSdkResumeSupplementSections = claudeSdkRootDmResume
+                            ? [
+                                ...(suppressDirectMemoryHints
+                                    ? []
+                                    : [
+                                        createPromptContextSection('workspace_memory_reminder', `[Workspace memory reminder]
+${buildWorkspaceMemoryReminder(directMemoryHints, dispatchToday)}`),
+                                    ]),
+                                ...buildDirectActivationContextSections({
+                                    target: dmReplyTarget,
+                                    recentMessages: [],
+                                    olderUnreadCount: 0,
+                                    rootMessage: envelope.activationContext.rootMessage,
+                                    dmContextSnapshot: envelope.activationContext.dmContextSnapshot,
+                                    dmActiveTaskThreads: envelope.activationContext.dmActiveTaskThreads,
+                                    dmActiveTaskThreadCount: envelope.activationContext.dmActiveTaskThreadCount,
+                                }, {
+                                    includeDmContextSnapshot: directPolicy?.promptIncludeDmSnapshotByDefault ?? false,
+                                    historyLimit: 0,
+                                    dmActiveTaskThreadsMode: directPolicy?.dmTaskThreadPresence.renderMode ?? 'off',
+                                    includeRootMessage: true,
+                                }),
+                            ].filter((section) => Boolean(section))
+                            : envelopeResumeContextSections;
+                        if (claudeSdkRootDmResume) {
+                            if (claudeSdkResumeSupplementSections?.length) {
+                                resumeSections.push(...claudeSdkResumeSupplementSections);
+                            }
+                        }
+                        else {
+                            const envelopeActivationContextSections = stripSurfaceSystemStatusSections(envelope.activationContextSections);
+                            const activationContextSplit = splitExactTargetHistorySections(envelopeActivationContextSections);
+                            const liveUnreadEnvelope = buildDirectSurfaceActivationEnvelope(this.db, {
+                                agentId: row.agentId,
+                                channelId: dmChannelId,
+                                replyTarget: dmReplyTarget,
+                                triggerSeq: msgSeq,
+                                threadRootId: row.threadRootId,
+                                constrainRecentMessagesToUnread: true,
+                                excludeRecentMessageSenderId: row.agentId,
+                                ...(directMessageContentOverride
+                                    ? {
+                                        messageContentOverrides: {
+                                            [persistedMessage.messageId]: directMessageContentOverride,
+                                        },
+                                    }
+                                    : {}),
+                                today: dispatchToday,
+                            });
+                            const liveUnreadExactTargetSections = extractExactTargetHistorySections(stripSurfaceSystemStatusSections(liveUnreadEnvelope.activationContextSections));
+                            const nonSnapshotActivationSections = (activationContextSplit.nonExact ?? [])
+                                .filter((section) => section.kind !== 'dm_context_snapshot');
+                            const activationContextSections = [
+                                ...nonSnapshotActivationSections.filter(shouldKeepResumeOnlyActivationSectionLive),
+                                ...(row.threadRootId && !suppressExactTargetHistoryForAppServerRootDm ? liveUnreadExactTargetSections : []),
+                            ];
+                            const resumeOnlyActivationSections = nonSnapshotActivationSections
+                                .filter((section) => !shouldKeepResumeOnlyActivationSectionLive(section));
+                            const resumeContextSections = stripSurfaceSystemStatusSections(claudeSdkResumeSupplementSections);
+                            if (activationContextSections.length) {
+                                contextSections.push(...activationContextSections);
+                            }
+                            else if (!envelopeActivationContextSections?.length && envelope.activationContextText?.trim()) {
+                                const inferredActivationSections = inferPromptContextSections(envelope.activationContextText);
+                                if (inferredActivationSections.length > 0) {
+                                    const split = splitResumeOnlyActivationSections(inferredActivationSections);
+                                    contextSections.push(...split.live);
+                                    resumeSections.push(...split.resume);
+                                }
+                            }
+                            resumeSections.push(...resumeOnlyActivationSections);
+                            resumeSections.push(...activationContextSplit.exact);
+                            if (resumeContextSections?.length) {
+                                resumeSections.push(...resumeContextSections);
+                            }
+                            else if (envelope.resumeContextText?.trim()) {
+                                resumeSections.push(...inferPromptContextSections(envelope.resumeContextText)
+                                    .filter((section) => shouldKeepIncomingPromptContextSection(section, {
+                                    suppressWorkspaceMemoryReminder: workspaceToolSlashRequested,
+                                })));
+                            }
+                        }
+                    }
+                }
+                const relevantContextBundle = buildContextBundle(this.db, agent, conversationId, {
+                    maxSurfaces: 1,
+                    maxTasks: 1,
+                    maxHandoffs: 1,
+                });
+                const relevantContextHintText = shouldPreinjectRelevantContextHint({
+                    target: row.replyTarget ?? '',
+                    strongSignals: extractRelevantContextStrongSignals(relevantContextBundle),
+                })
+                    ? buildRelevantContextHintSection(relevantContextBundle)
+                    : '';
+                const slashCommandName = promptSlashCommandName;
+                const uiPanelRequested = isPanelPromptSlashCommandName(slashCommandName);
+                const uiPanelGuidanceSection = uiPanelRequested
+                    ? createPromptContextSection('ui_panel_guidance', buildUiPanelGuidancePromptSection({
+                        layoutPlan: isLayoutPlanPromptSlashCommandName(slashCommandName),
+                    }))
+                    : null;
+                if (uiPanelGuidanceSection) {
+                    contextSections.push(uiPanelGuidanceSection);
+                }
+                const workspaceToolRequested = isWorkspaceToolPromptSlashCommandName(slashCommandName);
+                const workspaceToolGuidanceSection = workspaceToolRequested
+                    ? createPromptContextSection('workspace_tool_guidance', buildWorkspaceToolGuidancePromptSection({
+                        layoutPlan: isLayoutPlanPromptSlashCommandName(slashCommandName),
+                    }))
+                    : null;
+                if (workspaceToolGuidanceSection) {
+                    contextSections.push(workspaceToolGuidanceSection);
+                }
+                const documentLibraryRequested = activationMetadata?.slashCommand?.name === 'document';
+                const documentGuidanceSection = documentLibraryRequested
+                    ? createPromptContextSection('library_document_guidance', buildLibraryDocumentGuidancePromptSection())
+                    : null;
+                if (documentGuidanceSection) {
+                    contextSections.push(documentGuidanceSection);
+                }
+                if (options?.activationContextSections?.length || options?.activationContextText?.trim()) {
+                    // Keep live context limited to external surface state. Exact history
+                    // belongs in resume/recovery context unless it is an unread delta
+                    // assembled from the current activation path.
+                    const activationContextSections = stripWorkspaceMemoryReminderSections(stripSurfaceSystemStatusSections(options.activationContextSections), workspaceToolSlashRequested);
+                    const useResumeOnlyActivationContext = options.activationContextMode === 'resume_only'
+                        && dispatchMode !== 'cold_start';
+                    const includeExactTargetHistoryInLiveContext = activationMetadata?.liveContextIncludeExactTargetHistory === true;
+                    if (activationContextSections?.length) {
+                        if (useResumeOnlyActivationContext) {
+                            const split = splitResumeOnlyActivationSections(activationContextSections, {
+                                includeExactTargetHistory: includeExactTargetHistoryInLiveContext,
+                            });
+                            if (split.live.length > 0) {
+                                contextSections.push(...split.live);
+                            }
+                            if (split.resume.length > 0) {
+                                resumeSections.push(...split.resume);
+                            }
+                            optionActivationExactHistorySupersedesResumeExact = extractExactTargetHistorySections([
+                                ...split.live,
+                                ...split.resume,
+                            ]).length > 0;
+                        }
+                        else {
+                            const split = splitExactTargetHistorySections(activationContextSections);
+                            contextSections.push(...split.nonExact);
+                            if (dispatchMode === 'cold_start') {
+                                contextSections.push(...split.exact);
+                            }
+                            else if (includeExactTargetHistoryInLiveContext) {
+                                contextSections.push(...split.exact);
+                                optionActivationExactHistorySupersedesResumeExact = split.exact.length > 0;
+                            }
+                            else {
+                                resumeSections.push(...split.exact);
+                                optionActivationExactHistorySupersedesResumeExact = split.exact.length > 0;
+                            }
+                        }
+                    }
+                    else {
+                        const activationSections = inferPromptContextSections(stripSurfaceSystemStatusText(options.activationContextText))
+                            .filter((section) => shouldKeepIncomingPromptContextSection(section, {
+                            suppressWorkspaceMemoryReminder: workspaceToolSlashRequested,
+                        }));
+                        if (activationSections.length > 0) {
+                            if (useResumeOnlyActivationContext) {
+                                const split = splitResumeOnlyActivationSections(activationSections, {
+                                    includeExactTargetHistory: includeExactTargetHistoryInLiveContext,
+                                });
+                                contextSections.push(...split.live);
+                                resumeSections.push(...split.resume);
+                                optionActivationExactHistorySupersedesResumeExact = extractExactTargetHistorySections([
+                                    ...split.live,
+                                    ...split.resume,
+                                ]).length > 0;
+                            }
+                            else if (dispatchMode !== 'cold_start') {
+                                const split = splitExactTargetHistorySections(activationSections);
+                                if (split.nonExact.length > 0) {
+                                    contextSections.push(...split.nonExact);
+                                    // Text-only activation context is a legacy queued-dispatch fallback.
+                                    // Keep its exact recent window live so reused runtime sessions can
+                                    // see the queued turn's target-local delta, while still suppressing
+                                    // stale exact history from resumeContextText below.
+                                    contextSections.push(...split.exact);
+                                    optionActivationExactHistorySupersedesResumeExact = split.exact.length > 0;
+                                }
+                                else if (includeExactTargetHistoryInLiveContext) {
+                                    contextSections.push(...split.exact);
+                                    optionActivationExactHistorySupersedesResumeExact = split.exact.length > 0;
+                                }
+                                else {
+                                    resumeSections.push(...split.exact);
+                                    optionActivationExactHistorySupersedesResumeExact = split.exact.length > 0;
+                                }
+                            }
+                            else {
+                                contextSections.push(...activationSections);
+                            }
+                        }
+                    }
+                }
+                const latestSurfaceSystemStatusSection = buildSurfaceSystemStatusSection(this.db, {
+                    channelId: row.threadKind === 'direct' && row.agentId ? `dm:${row.agentId}` : row.channelId,
+                    replyTarget: (dmReplyTarget ?? row.replyTarget ?? '').trim(),
+                    threadRootId: row.threadRootId,
+                });
+                if (latestSurfaceSystemStatusSection) {
+                    contextSections.push(latestSurfaceSystemStatusSection);
+                }
+                const savedAcpSessionId = getSessionAcpSessionId(this.db, row.sessionKey);
+                const willStartFreshRuntimeSession = dispatchMode === 'cold_start'
+                    || (agent.agentType === 'codex_app_server' && !savedAcpSessionId);
+                if (willStartFreshRuntimeSession) {
+                    const rollingSummarySectionText = buildRollingSummaryPromptSection(this.db, conversationId);
+                    const rollingSummarySection = createPromptContextSection('conversation_rolling_summary', rollingSummarySectionText);
+                    if (rollingSummarySection) {
+                        contextSections.push(rollingSummarySection);
+                    }
+                }
+                if (relevantContextHintText) {
+                    const relevantContextSection = createPromptContextSection('relevant_context_hint', relevantContextHintText);
+                    if (dispatchMode === 'cold_start') {
+                        if (relevantContextSection) {
+                            contextSections.push(relevantContextSection);
+                        }
+                    }
+                    else if (relevantContextSection) {
+                        // Fresh resume wake-ups merge resumeContextText + contextText, so resume-only hints
+                        // must live in exactly one field to avoid duplicate prompt sections.
+                        resumeSections.push(relevantContextSection);
+                    }
+                }
+                if (options?.resumeContextSections?.length || options?.resumeContextText?.trim()) {
+                    const resumeContextSections = stripWorkspaceMemoryReminderSections(stripSurfaceSystemStatusSections(options.resumeContextSections), workspaceToolSlashRequested);
+                    if (resumeContextSections?.length) {
+                        const sections = optionActivationExactHistorySupersedesResumeExact
+                            ? stripExactTargetHistorySections(resumeContextSections)
+                            : resumeContextSections;
+                        if (sections?.length) {
+                            resumeSections.push(...sections);
+                        }
+                    }
+                    else {
+                        const resumeSectionsFromText = inferPromptContextSections(stripSurfaceSystemStatusText(options.resumeContextText))
+                            .filter((section) => shouldKeepIncomingPromptContextSection(section, {
+                            suppressWorkspaceMemoryReminder: workspaceToolSlashRequested,
+                        }));
+                        for (const resumeSection of resumeSectionsFromText) {
+                            if (optionActivationExactHistorySupersedesResumeExact
+                                && EXACT_TARGET_HISTORY_SECTION_KINDS.has(resumeSection.kind)) {
+                                // Activation text is the live exact-history fallback for this
+                                // queued dispatch; skip stale resume exact history.
+                            }
+                            else {
+                                resumeSections.push(resumeSection);
+                            }
+                        }
+                    }
+                }
+                const composedBeforeReplay = composePromptContextTexts({
+                    contextSections: [
+                        ...(activeProjectContextSection ? [activeProjectContextSection] : []),
+                        ...contextSections,
+                    ],
+                    resumeSections,
+                });
+                if (dispatchMode !== 'cold_start') {
+                    const replayText = this.buildConversationReplayText(conversationId, row.sessionKey, runId, replayOverlapMessages, composedBeforeReplay.hasVisibleRecentWindow);
+                    if (replayText) {
+                        const continuitySection = createPromptContextSection('continuity', replayText);
+                        if (continuitySection) {
+                            resumeSections.push(continuitySection);
+                        }
+                    }
+                }
+                const composedContextTexts = composePromptContextTexts({
+                    contextSections: [
+                        ...(activeProjectContextSection ? [activeProjectContextSection] : []),
+                        ...contextSections,
+                    ],
+                    resumeSections,
+                });
+                contextText = composedContextTexts.contextText;
+                resumeContextText = composedContextTexts.resumeContextText;
+            }
+        }
+        const dispatchAgent = row.agentId ? this.getAgentById(row.agentId) : null;
+        const dispatchAgentIsCodexAppServer = dispatchAgent?.agentType === 'codex_app_server';
+        const dispatchRuntimeOverrides = normalizePromptRuntimeOverrides(options?.runtimeOverrides);
+        const dispatchPlanMode = dispatchRuntimeOverrides?.planMode === true || dispatchRuntimeOverrides?.codexMode === 'plan';
+        const nodeRuntimeOverrides = dispatchRuntimeOverrides && dispatchAgentIsCodexAppServer && dispatchPlanMode
+            ? { ...dispatchRuntimeOverrides, codexMode: 'plan' }
+            : dispatchRuntimeOverrides;
+        const shouldSkipReplyContract = options?.suppressReplyContract === true
+            || activationMetadata?.suppressReplyContract === true
+            || (dispatchAgentIsCodexAppServer && dispatchPlanMode);
+        const surfacePromptText = adaptPromptTextForAgentSurface(promptText, dispatchAgentSurfaceMode);
+        const surfaceContextText = contextText
+            ? adaptPromptTextForAgentSurface(contextText, dispatchAgentSurfaceMode)
+            : contextText;
+        const surfaceResumeContextText = resumeContextText
+            ? adaptPromptTextForAgentSurface(resumeContextText, dispatchAgentSurfaceMode)
+            : resumeContextText;
+        const dispatchedPrompt = shouldSkipReplyContract
+            ? surfacePromptText
+            : prependTurnReplyContract(surfacePromptText, dispatchToday, dispatchAgentSurfaceMode);
+        const candidateSystemPromptText = dispatchMode === 'cold_start'
+            ? systemPromptText
+            : getSessionSystemPromptText(this.db, row.sessionKey) || systemPromptText;
+        upsertPendingRunDebugInput(this.db, {
+            runId,
+            conversationId,
+            sessionKey: row.sessionKey,
+            dispatchMode,
+            replyTarget: row.replyTarget?.trim() || null,
+            systemPromptText: candidateSystemPromptText || null,
+            contextText: surfaceContextText || null,
+            promptText,
+            dispatchedPromptText: dispatchedPrompt,
+            agentSurfaceMode: dispatchAgentSurfaceMode,
+            activationMetadataJson: serializePromptActivationMetadata(activationMetadata),
+        });
+        const node = this.nodeRegistry?.getNode(row.nodeId);
+        if (!node) {
+            this.clearQueueDispatchAttempt(options?.queuedPromptId, runId);
+            finishRun(this.db, { runId, error: 'Node not connected' });
+            this.updateStatus(conversationId, 'idle');
+            log.warn('[dispatcher] node not connected', { nodeId: row.nodeId, conversationId });
+            throw new Error(`Node not connected: ${row.nodeId}`);
+        }
+        if (!node.agentTypes.includes(row.agentType)) {
+            const errorMessage = `Node does not support agent type ${row.agentType}`;
+            this.clearQueueDispatchAttempt(options?.queuedPromptId, runId);
+            finishRun(this.db, { runId, error: errorMessage });
+            this.updateStatus(conversationId, 'idle');
+            log.warn('[dispatcher] node does not support requested agent type', {
+                nodeId: row.nodeId,
+                conversationId,
+                agentType: row.agentType,
+                supportedAgentTypes: node.agentTypes,
+            });
+            throw new Error(`${errorMessage}: ${row.nodeId}`);
+        }
+        const nodeSurfaceReadiness = this.loadNodeSurfaceReadiness(row.nodeId);
+        const failNodeSurfaceReadiness = (errorMessage, details) => {
+            this.clearQueueDispatchAttempt(options?.queuedPromptId, runId);
+            finishRun(this.db, { runId, error: errorMessage });
+            this.updateStatus(conversationId, 'idle');
+            log.warn('[dispatcher] node agent surface readiness failed', {
+                nodeId: row.nodeId,
+                conversationId,
+                runId,
+                ...details,
+            });
+            throw new Error(`${errorMessage}: ${row.nodeId}`);
+        };
+        if (!nodeSurfaceReadiness.hasSnapshot) {
+            failNodeSurfaceReadiness('Node surface readiness missing', {
+                expectedAgentSurfaceMode: dispatchAgentSurfaceMode,
+            });
+        }
+        if (node.processInstanceId && nodeSurfaceReadiness.processInstanceId !== node.processInstanceId) {
+            failNodeSurfaceReadiness('Node surface readiness stale', {
+                expectedProcessInstanceId: node.processInstanceId,
+                snapshotProcessInstanceId: nodeSurfaceReadiness.processInstanceId,
+            });
+        }
+        if (nodeSurfaceReadiness.agentSurfaceMode !== dispatchAgentSurfaceMode) {
+            const actual = nodeSurfaceReadiness.agentSurfaceMode ?? 'missing';
+            failNodeSurfaceReadiness(`Node surface mismatch: expected ${dispatchAgentSurfaceMode}, got ${actual}`, {
+                expectedAgentSurfaceMode: dispatchAgentSurfaceMode,
+                actualAgentSurfaceMode: nodeSurfaceReadiness.agentSurfaceMode,
+            });
+        }
+        if (dispatchAgentSurfaceMode === 'bigbang' && nodeSurfaceReadiness.bigbangCliAvailable !== true) {
+            failNodeSurfaceReadiness('Bigbang CLI unavailable on node', {
+                bigbangCliAvailable: nodeSurfaceReadiness.bigbangCliAvailable,
+            });
+        }
+        log.info('[dispatcher] dispatching prompt', {
+            nodeId: row.nodeId,
+            conversationId,
+            runId,
+            dispatchMode,
+            hostKey,
+            agentSurfaceMode: dispatchAgentSurfaceMode,
+        });
+        let channelBridgeConfig;
+        if (row.agentId) {
+            const serverUrl = this.resolveChannelBridgeServerUrl(row.nodeId);
+            channelBridgeConfig = {
+                agentId: row.agentId,
+                conversationId,
+                serverUrl,
+                authToken: this.config.internalAgentAuthToken,
+            };
+        }
+        if (this.libraryService) {
+            try {
+                const personalLibraryRequested = activationMetadata?.slashCommand?.name === 'document';
+                if (personalLibraryRequested) {
+                    this.libraryService.enablePersonalLibraryForConversation(conversationId);
+                }
+                await this.libraryService.prepareRunLibraryMirror({
+                    runId,
+                    conversationId,
+                    userId: row.userId,
+                    nodeId: row.nodeId,
+                    workspacePath: row.workspacePath,
+                    personalEnabled: personalLibraryRequested || row.personalLibraryEnabled === 1,
+                });
+            }
+            catch (error) {
+                this.clearQueueDispatchAttempt(options?.queuedPromptId, runId);
+                finishRun(this.db, { runId, error: String(error?.message ?? error) });
+                this.updateStatus(conversationId, 'failed');
+                throw error;
+            }
+        }
+        const requestedBuiltinSkillRoots = conversationBuiltinSkillRootsForSlashCommand(activationMetadata?.slashCommand?.name);
+        const acceptance = this.waitForDispatchAcceptance(runId, row.nodeId, conversationId, options?.queuedPromptId);
+        const dispatchBuiltinSkillRoots = normalizeConversationBuiltinSkillRoots([
+            ...parseConversationBuiltinSkillRoots(row.builtinSkillRootsJson),
+            ...requestedBuiltinSkillRoots,
+        ]);
+        const dispatchEnabledSkillPaths = dispatchAgent?.skillSelectionMode === 'explicit'
+            ? normalizeDispatchEnabledSkillPaths(dispatchAgent.enabledSkillPaths)
+            : undefined;
+        const dispatchSkillRoots = mergeDispatchSkillRoots(dispatchAgent?.skillRoots, dispatchBuiltinSkillRoots);
+        const sent = this.nodeRegistry.send(row.nodeId, {
+            type: 'run.dispatch',
+            runId,
+            conversationId,
+            agentType: row.agentType,
+            agentSurfaceMode: dispatchAgentSurfaceMode,
+            ...(dispatchAgent?.model ? { model: dispatchAgent.model } : {}),
+            ...(dispatchAgent?.reasoningEffort ? { reasoningEffort: dispatchAgent.reasoningEffort } : {}),
+            ...(dispatchAgent?.agentType === 'claude_sdk' && dispatchAgent.claudePermissionMode ? { claudePermissionMode: dispatchAgent.claudePermissionMode } : {}),
+            ...(dispatchAgentIsCodexAppServer && dispatchPlanMode ? { codexMode: 'plan' } : {}),
+            ...(dispatchAgentIsCodexAppServer && !dispatchPlanMode && dispatchRuntimeOverrides?.codexMode ? { codexMode: dispatchRuntimeOverrides.codexMode } : {}),
+            ...(dispatchAgentIsCodexAppServer && dispatchAgent?.codexServiceTier ? { codexServiceTier: dispatchAgent.codexServiceTier } : {}),
+            workspacePath: row.workspacePath,
+            ...(dispatchAgent?.name ? { agentName: dispatchAgent.name } : {}),
+            ...(dispatchSkillRoots && dispatchSkillRoots.length > 0 ? { skillRoots: dispatchSkillRoots } : {}),
+            ...(dispatchEnabledSkillPaths !== undefined ? { enabledSkillPaths: dispatchEnabledSkillPaths } : {}),
+            envVars: {
+                ...(agentEnvVars ?? {}),
+                ...(parseEnvVars(row.envVarsJson) ?? {}),
+                ...(driver.defaultEnv ?? {}),
+            },
+            disabledToolKinds,
+            prompt: dispatchedPrompt,
+            ...(promptAttachments.length > 0 ? { attachments: promptAttachments } : {}),
+            ...(nodeRuntimeOverrides ? { runtimeOverrides: nodeRuntimeOverrides } : {}),
+            sessionKey: row.sessionKey,
+            hostKey,
+            dispatchMode,
+            systemPromptText: systemPromptText || undefined,
+            contextText: surfaceContextText || undefined,
+            resumeContextText: surfaceResumeContextText || undefined,
+            ...(options?.notificationDelivery ? { delivery: options.notificationDelivery } : {}),
+            channelBridgeConfig,
+        });
+        if (!sent) {
+            this.libraryService?.abortRunLibraryMirror(runId);
+            this.clearPendingDispatchAcceptance(runId);
+            this.clearQueueDispatchAttempt(options?.queuedPromptId, runId);
+            finishRun(this.db, { runId, error: 'Node disconnected during dispatch' });
+            this.updateStatus(conversationId, 'idle');
+            throw new Error(`Node disconnected: ${row.nodeId}`);
+        }
+        this.markQueueDispatchSent(options?.queuedPromptId, runId);
+        try {
+            await acceptance;
+        }
+        catch (error) {
+            this.libraryService?.abortRunLibraryMirror(runId);
+            this.clearQueueDispatchAttempt(options?.queuedPromptId, runId);
+            finishRun(this.db, { runId, error: String(error?.message ?? error) });
+            this.updateStatus(conversationId, 'failed');
+            throw error;
+        }
+        return { runId, dispatchMode, hostKey };
+    }
+    async submitPrompt(conversationId, promptText, options) {
+        const row = this.db.prepare(`SELECT agent_id as agentId,
+              agent_type as agentType,
+              node_id as nodeId,
+              channel_id as channelId,
+              reply_target as replyTarget,
+              thread_kind as threadKind,
+              thread_root_id as threadRootId
+       FROM conversations
+       WHERE id = ?`).get(conversationId);
+        if (!row)
+            throw new Error(`Unknown conversation: ${conversationId}`);
+        const agent = row.agentId ? this.getAgentById(row.agentId) : null;
+        const recordAsUserMessage = options?.recordAsUserMessage ?? true;
+        const normalizedActivationMetadata = ensurePlatformRunMetadata(this.db, agent?.agentRole, agent?.agentId, options?.activationMetadata, recordAsUserMessage);
+        const normalizedOptions = normalizedActivationMetadata === options?.activationMetadata
+            ? options
+            : {
+                ...(options ?? {}),
+                ...(normalizedActivationMetadata ? { activationMetadata: normalizedActivationMetadata } : {}),
+            };
+        const platformBlockReason = getPlatformAgentDispatchBlockReason(this.db, agent?.agentRole, agent?.agentId, normalizedOptions?.activationMetadata);
+        if (platformBlockReason) {
+            throw new Error(platformBlockReason);
+        }
+        if (!row.agentId) {
+            const dispatched = await this.dispatchPrompt(conversationId, promptText, normalizedOptions);
+            return { queued: false, runId: dispatched.runId };
+        }
+        let effectiveOptions = normalizedOptions;
+        let queuedFallbackId;
+        this.deleteAcceptedQueueHeads(conversationId);
+        if (isCodexRuntimeRotationPending(this.db, conversationId)) {
+            if (normalizedOptions?.allowQueue === false) {
+                return { queued: true };
+            }
+            effectiveOptions = this.persistDirectUserMessageForQueuedPromptIfNeeded(conversationId, row, promptText, normalizedOptions);
+            this.enqueuePrompt(row.agentId, conversationId, promptText, effectiveOptions);
+            this.updateStatus(conversationId, 'queued');
+            return { queued: true };
+        }
+        const blocking = this.findBlockingConversation(conversationId);
+        if (blocking) {
+            if (row.threadKind === 'direct' && recordAsUserMessage) {
+                const persistedMessage = this.persistDirectUserMessageForConversation({
+                    conversationId,
+                    conversation: {
+                        agentId: row.agentId,
+                        replyTarget: row.replyTarget,
+                        threadKind: row.threadKind,
+                        threadRootId: row.threadRootId,
+                    },
+                    promptText,
+                    options: normalizedOptions,
+                    attachments: sanitizeFileRefs(options?.attachments),
+                    attachmentIds: sanitizeAttachmentIds(options?.attachmentIds),
+                });
+                effectiveOptions = {
+                    ...normalizedOptions,
+                    clientMessageId: persistedMessage.messageId,
+                    persistedDirectUserMessage: persistedMessage,
+                    activationMetadata: {
+                        ...(normalizedOptions?.activationMetadata ?? {}),
+                        triggerMessage: {
+                            messageId: persistedMessage.messageId,
+                            seq: persistedMessage.seq,
+                            target: persistedMessage.replyTarget,
+                        },
+                    },
+                };
+                if (normalizedOptions?.allowQueue !== false) {
+                    queuedFallbackId = this.enqueuePrompt(row.agentId, conversationId, promptText, effectiveOptions);
+                    effectiveOptions = {
+                        ...effectiveOptions,
+                        queuedPromptId: queuedFallbackId,
+                    };
+                }
+            }
+            if (normalizedOptions?.allowActiveSteer !== false) {
+                const steered = await this.trySteerActiveRun({
+                    conversationId,
+                    promptText,
+                    options: effectiveOptions,
+                    conversation: row,
+                    blocking,
+                });
+                if (steered) {
+                    if (queuedFallbackId != null) {
+                        this.deleteQueuedPrompt(queuedFallbackId);
+                    }
+                    return { queued: false, runId: steered.runId, steered: true };
+                }
+            }
+            if (this.findBlockingConversation(conversationId)) {
+                if (normalizedOptions?.allowQueue === false) {
+                    return { queued: true };
+                }
+                if (queuedFallbackId == null) {
+                    queuedFallbackId = this.enqueuePrompt(row.agentId, conversationId, promptText, effectiveOptions);
+                }
+                this.updateStatus(conversationId, 'queued');
+                if (hasEffectiveAgentRuntimeCapability(this.db, {
+                    nodeId: row.nodeId,
+                    agentType: row.agentType,
+                    capability: 'activeTurnSteer',
+                })
+                    && row.threadRootId
+                    && (effectiveOptions?.recordAsUserMessage ?? true)
+                    && blocking.runId
+                    && row.nodeId) {
+                    const sent = this.nodeRegistry?.send(row.nodeId, {
+                        type: 'run.cancel',
+                        runId: blocking.runId,
+                    });
+                    if (!sent) {
+                        log.warn('[dispatcher] failed to preempt active Codex task-thread run for queued human prompt', {
+                            nodeId: row.nodeId,
+                            conversationId,
+                            runId: blocking.runId,
+                        });
+                    }
+                }
+                return { queued: true };
+            }
+            const dispatched = await this.dispatchPrompt(conversationId, promptText, effectiveOptions);
+            if (queuedFallbackId != null) {
+                this.deleteQueuedPrompt(queuedFallbackId);
+            }
+            return { queued: false, runId: dispatched.runId };
+        }
+        const pendingQueueHead = this.getConversationQueueHead(conversationId);
+        if (pendingQueueHead) {
+            if (normalizedOptions?.allowQueue === false) {
+                this.scheduleQueueRetryForHead(conversationId, pendingQueueHead);
+                return { queued: true };
+            }
+            if (row.threadKind === 'direct' && recordAsUserMessage) {
+                const persistedMessage = this.persistDirectUserMessageForConversation({
+                    conversationId,
+                    conversation: {
+                        agentId: row.agentId,
+                        replyTarget: row.replyTarget,
+                        threadKind: row.threadKind,
+                        threadRootId: row.threadRootId,
+                    },
+                    promptText,
+                    options: normalizedOptions,
+                    attachments: sanitizeFileRefs(options?.attachments),
+                    attachmentIds: sanitizeAttachmentIds(options?.attachmentIds),
+                });
+                effectiveOptions = {
+                    ...normalizedOptions,
+                    clientMessageId: persistedMessage.messageId,
+                    persistedDirectUserMessage: persistedMessage,
+                    activationMetadata: {
+                        ...(normalizedOptions?.activationMetadata ?? {}),
+                        triggerMessage: {
+                            messageId: persistedMessage.messageId,
+                            seq: persistedMessage.seq,
+                            target: persistedMessage.replyTarget,
+                        },
+                    },
+                };
+            }
+            this.enqueuePrompt(row.agentId, conversationId, promptText, effectiveOptions);
+            this.updateStatus(conversationId, 'queued');
+            this.scheduleQueueRetryForHead(conversationId, pendingQueueHead);
+            return { queued: true };
+        }
+        const dispatched = await this.dispatchPrompt(conversationId, promptText, normalizedOptions);
+        return { queued: false, runId: dispatched.runId };
+    }
+    async trySteerActiveRun(params) {
+        const { conversation, blocking, conversationId, options } = params;
+        if (!hasEffectiveAgentRuntimeCapability(this.db, {
+            nodeId: conversation.nodeId,
+            agentType: conversation.agentType,
+            capability: 'activeTurnSteer',
+        }))
+            return null;
+        if (blocking.status !== 'active' || !blocking.runId)
+            return null;
+        if (!conversation.agentId || !conversation.nodeId)
+            return null;
+        const runtimeOverrides = normalizePromptRuntimeOverrides(options?.runtimeOverrides);
+        if (runtimeOverrides?.planMode === true || runtimeOverrides?.codexMode === 'plan')
+            return null;
+        return this.withSteerSerial(blocking.runId, async () => {
+            const latestBlocking = this.findBlockingConversation(conversationId);
+            if (!latestBlocking || latestBlocking.status !== 'active' || latestBlocking.runId !== blocking.runId) {
+                return null;
+            }
+            if (!this.getAgentById(conversation.agentId))
+                return null;
+            const shouldPersistDirectUserMessage = (conversation.threadKind === 'direct'
+                && (options?.recordAsUserMessage ?? true) === true);
+            const promptAttachments = sanitizeFileRefs(options?.attachments);
+            const dmChannelId = `dm:${conversation.agentId}`;
+            const humanUserName = options?.senderName ?? this.config.humanUserName;
+            const surfaceChannelId = conversation.threadKind === 'direct'
+                ? dmChannelId
+                : conversation.channelId;
+            const replyTarget = conversation.threadKind === 'direct'
+                ? resolveConversationReplyTarget(this.db, conversationId, humanUserName) ?? conversation.replyTarget?.trim() ?? `dm:@${humanUserName}`
+                : conversation.replyTarget?.trim() ?? '';
+            if (!replyTarget)
+                return null;
+            let steerPrompt;
+            let activeSteerContextSectionsForMetadata = {};
+            if (shouldPersistDirectUserMessage) {
+                const latestSurfaceSystemStatusSection = buildSurfaceSystemStatusSection(this.db, {
+                    channelId: surfaceChannelId,
+                    replyTarget,
+                    threadRootId: conversation.threadRootId,
+                });
+                activeSteerContextSectionsForMetadata = {
+                    activation: latestSurfaceSystemStatusSection ? [latestSurfaceSystemStatusSection] : [],
+                };
+                steerPrompt = joinSteerPromptParts(latestSurfaceSystemStatusSection
+                    ? renderPromptContextSections([latestSurfaceSystemStatusSection])
+                    : null, buildMinimalDirectFollowupSteerPrompt(params.promptText));
+            }
+            else {
+                const strippedActivationSections = stripSurfaceSystemStatusSections(options?.activationContextSections);
+                const includeExactTargetHistoryInActiveSteer = options?.activationMetadata?.activeSteerIncludeExactTargetHistory === true;
+                const priorActivationSections = options?.activationContextMode === 'resume_only'
+                    ? strippedActivationSections?.filter((section) => shouldKeepResumeOnlyActivationSectionLive(section)
+                        || (includeExactTargetHistoryInActiveSteer && EXACT_TARGET_HISTORY_SECTION_KINDS.has(section.kind)))
+                    : strippedActivationSections;
+                const latestSurfaceSystemStatusSection = buildSurfaceSystemStatusSection(this.db, {
+                    channelId: surfaceChannelId,
+                    replyTarget,
+                    threadRootId: conversation.threadRootId,
+                });
+                const actualActivationSections = [
+                    ...(latestSurfaceSystemStatusSection ? [latestSurfaceSystemStatusSection] : []),
+                    ...(priorActivationSections ?? []),
+                ];
+                activeSteerContextSectionsForMetadata = {
+                    activation: actualActivationSections,
+                };
+                const fallbackActivationContextText = options?.activationContextMode === 'resume_only'
+                    ? undefined
+                    : stripSurfaceSystemStatusText(options?.activationContextText);
+                const steerActivationContextText = actualActivationSections.length
+                    ? renderPromptContextSections(actualActivationSections)
+                    : fallbackActivationContextText;
+                const joinedSteerPrompt = joinSteerPromptParts(steerActivationContextText, params.promptText);
+                const activeRunAgentSurfaceMode = this.getRunDebugInputAgentSurfaceMode(blocking.runId)
+                    ?? normalizeDispatchAgentSurfaceMode(this.config.agentSurfaceMode, 'bigbang');
+                const surfaceJoinedSteerPrompt = adaptPromptTextForAgentSurface(joinedSteerPrompt, activeRunAgentSurfaceMode);
+                steerPrompt = options?.suppressReplyContract === true
+                    || options?.activationMetadata?.suppressReplyContract === true
+                    ? surfaceJoinedSteerPrompt
+                    : prependTurnReplyContract(surfaceJoinedSteerPrompt, getCurrentISOWeek(), activeRunAgentSurfaceMode);
+            }
+            const requestId = randomUUID();
+            if (options?.queuedPromptId != null) {
+                this.markQueueDispatchAttempt(options.queuedPromptId, blocking.runId, 'steer', requestId);
+            }
+            let restoreRunDebugInputAfterFailedSteer = null;
+            const response = this.waitForSteerResponse(requestId, conversation.nodeId, blocking.runId, conversationId, options?.queuedPromptId, conversation.agentType === 'claude_sdk'
+                ? CLAUDE_SDK_ACTIVE_TURN_STEER_RESPONSE_TIMEOUT_MS
+                : ACTIVE_TURN_STEER_RESPONSE_TIMEOUT_MS);
+            const sent = this.nodeRegistry?.send(conversation.nodeId, {
+                type: 'run.steer',
+                requestId,
+                runId: blocking.runId,
+                conversationId,
+                prompt: steerPrompt,
+                ...(promptAttachments.length > 0 ? { attachments: promptAttachments } : {}),
+                ...(options?.notificationDelivery ? { delivery: options.notificationDelivery } : {}),
+            });
+            if (!sent) {
+                this.clearPendingSteerResponse(requestId);
+                this.clearQueueDispatchAttempt(options?.queuedPromptId, blocking.runId, requestId);
+                log.warn('[dispatcher] active-turn steer send failed; falling back to queue', {
+                    agentType: conversation.agentType,
+                    nodeId: conversation.nodeId,
+                    conversationId,
+                    runId: blocking.runId,
+                });
+                return null;
+            }
+            restoreRunDebugInputAfterFailedSteer = patchRunDebugInputForActiveSteer(this.db, {
+                runId: blocking.runId,
+                promptText: params.promptText,
+                dispatchedPromptText: steerPrompt,
+                activationMetadata: enrichPromptActivationMetadataWithContextSections(options, activeSteerContextSectionsForMetadata),
+            });
+            this.markQueueDispatchSent(options?.queuedPromptId, blocking.runId);
+            try {
+                await response;
+            }
+            catch (error) {
+                restoreRunDebugInputAfterFailedSteer?.();
+                this.clearQueueDispatchAttempt(options?.queuedPromptId, blocking.runId, requestId);
+                log.warn('[dispatcher] active-turn steer failed; falling back to queue', {
+                    agentType: conversation.agentType,
+                    nodeId: conversation.nodeId,
+                    conversationId,
+                    runId: blocking.runId,
+                    error: String(error?.message ?? error),
+                });
+                return null;
+            }
+            return { runId: blocking.runId };
+        });
+    }
+    async handleApproval(conversationId, requestId, decision, selectedActionId, responseText, answers) {
+        const convRow = this.db
+            .prepare('SELECT node_id as nodeId FROM conversations WHERE id = ?')
+            .get(conversationId);
+        if (!convRow)
+            return { ok: false, message: 'Unknown conversation.' };
+        if (!convRow.nodeId)
+            return { ok: false, message: 'No agent node assigned to this conversation.' };
+        const sent = this.nodeRegistry?.send(convRow.nodeId, {
+            type: 'permission.response',
+            requestId,
+            decision,
+            selectedActionId,
+            ...(responseText?.trim() ? { responseText: responseText.trim() } : {}),
+            ...(answers ? { answers } : {}),
+        });
+        if (sent) {
+            this.updateStatus(conversationId, 'active');
+            return { ok: true, message: '' };
+        }
+        return { ok: false, message: 'Node not connected.' };
+    }
+    cancelConversationRun(conversationId, expectedRunId, options) {
+        const row = expectedRunId
+            ? this.db.prepare(`SELECT c.node_id as nodeId,
+                r.run_id as coreRunId,
+                h.current_run_id as snapshotRunId
+         FROM conversations c
+         LEFT JOIN runs r
+           ON r.session_key = c.session_key
+          AND r.ended_at IS NULL
+          AND r.run_id = ?
+         LEFT JOIN node_host_snapshots h
+           ON h.node_id = c.node_id
+          AND h.host_key = 'conversation:' || c.id || ':' || c.agent_type
+          AND h.state = 'active'
+          AND h.current_run_id IS NOT NULL
+         WHERE c.id = ?
+         LIMIT 1`).get(expectedRunId, conversationId)
+            : this.db.prepare(`SELECT c.node_id as nodeId,
+                r.run_id as coreRunId,
+                h.current_run_id as snapshotRunId
+         FROM conversations c
+         LEFT JOIN runs r ON r.session_key = c.session_key AND r.ended_at IS NULL
+         LEFT JOIN node_host_snapshots h
+           ON h.node_id = c.node_id
+          AND h.host_key = 'conversation:' || c.id || ':' || c.agent_type
+         AND h.state = 'active'
+         AND h.current_run_id IS NOT NULL
+         WHERE c.id = ?
+         ORDER BY r.started_at DESC, r.rowid DESC
+         LIMIT 1`).get(conversationId);
+        if (!row)
+            return { ok: false, message: 'Unknown conversation.' };
+        const runId = expectedRunId && options?.strictExpectedRunId
+            ? row.coreRunId ?? (row.snapshotRunId === expectedRunId ? row.snapshotRunId : null)
+            : row.snapshotRunId ?? row.coreRunId;
+        if (!runId)
+            return { ok: false, message: 'No active run to cancel.' };
+        if (!row.nodeId)
+            return { ok: false, message: 'No agent node assigned to this conversation.' };
+        const sent = this.nodeRegistry?.send(row.nodeId, {
+            type: 'run.cancel',
+            runId,
+        });
+        return sent
+            ? { ok: true, message: '', runId }
+            : { ok: false, message: 'Node not connected.' };
+    }
+    persistDirectUserMessageForConversation(params) {
+        const { conversation, conversationId, options } = params;
+        if (conversation.threadKind !== 'direct' || !conversation.agentId) {
+            throw new Error('Direct user message persistence requires a direct agent conversation.');
+        }
+        const existing = options?.persistedDirectUserMessage;
+        if (existing)
+            return existing;
+        const dmChannelId = `dm:${conversation.agentId}`;
+        const humanUserName = options?.senderName ?? this.config.humanUserName;
+        const replyTarget = resolveConversationReplyTarget(this.db, conversationId, humanUserName) ?? conversation.replyTarget?.trim() ?? `dm:@${humanUserName}`;
+        const dmThreadRootId = conversation.threadRootId ?? null;
+        const messageId = options?.clientMessageId ?? randomUUID();
+        const attachNoteIdx = findPromptAttachmentNoteIndex(params.promptText);
+        const displayContent = attachNoteIdx >= 0 ? params.promptText.slice(0, attachNoteIdx) : params.promptText;
+        const attachmentIds = extractPromptAttachmentIds(params.promptText, params.attachments, params.attachmentIds);
+        const existingRow = this.db.prepare(`SELECT message_id as messageId, channel_id as channelId,
+              sender_name as senderName, target as replyTarget,
+              content, seq, thread_root_id as threadRootId,
+              attachment_ids as attachmentIdsJson,
+              panel_ids as panelIdsJson
+       FROM channel_messages
+       WHERE message_id = ?
+       LIMIT 1`).get(messageId);
+        if (existingRow) {
+            const existingAttachmentIds = parseAttachmentIdsJson(existingRow.attachmentIdsJson);
+            if (existingRow.channelId !== dmChannelId
+                || (existingRow.threadRootId ?? null) !== dmThreadRootId
+                || existingRow.replyTarget !== replyTarget) {
+                throw new Error(`Client message id already exists on a different surface: ${messageId}`);
+            }
+            if ((existingRow.senderName ?? humanUserName) !== humanUserName
+                || existingRow.content !== displayContent
+                || !stringArraysEqual(existingAttachmentIds, attachmentIds)) {
+                throw new Error(`Client message id already exists with a different message payload: ${messageId}`);
+            }
+            return {
+                messageId: existingRow.messageId,
+                channelId: existingRow.channelId,
+                replyTarget: existingRow.replyTarget,
+                threadRootId: existingRow.threadRootId ?? null,
+                seq: existingRow.seq,
+                senderName: existingRow.senderName ?? humanUserName,
+                content: existingRow.content,
+                attachmentIds: existingAttachmentIds,
+            };
+        }
+        const msgSeq = allocateNextChannelMessageSeq(this.db, dmChannelId);
+        this.db.prepare(`INSERT INTO channel_messages(message_id, channel_id, sender_id, sender_name, sender_type, target, content, seq, created_at, thread_root_id, attachment_ids)
+       VALUES(?, ?, 'user', ?, 'user', ?, ?, ?, ?, ?, ?)`).run(messageId, dmChannelId, humanUserName, replyTarget, displayContent, msgSeq, Date.now(), dmThreadRootId, attachmentIds.length ? JSON.stringify(attachmentIds) : null);
+        refreshConversationSummariesForMessageScope(this.db, (targetAgentId) => this.getAgentById(targetAgentId), {
+            channelId: dmChannelId,
+            replyTarget,
+            threadRootId: dmThreadRootId,
+        });
+        return {
+            messageId,
+            channelId: dmChannelId,
+            replyTarget,
+            threadRootId: dmThreadRootId,
+            seq: msgSeq,
+            senderName: humanUserName,
+            content: displayContent,
+            attachmentIds,
+        };
+    }
+    async handleConversationSettled(conversationId) {
+        const row = this.db.prepare(`SELECT agent_id as agentId,
+              status
+       FROM conversations
+       WHERE id = ?`).get(conversationId);
+        if (!row?.agentId)
+            return;
+        if (row.status === 'awaiting_approval')
+            return;
+        while (true) {
+            if (isCodexRuntimeRotationPending(this.db, conversationId))
+                return;
+            if (this.findBlockingConversation(conversationId))
+                return;
+            const next = this.db.prepare(`SELECT queue_id as queueId, agent_id as agentId, conversation_id as conversationId,
+                prompt_text as promptText, record_as_user_message as recordAsUserMessage,
+                activation_context_text as activationContextText,
+                activation_context_mode as activationContextMode,
+                resume_context_text as resumeContextText,
+                replay_overlap_recent_messages_json as replayOverlapRecentMessagesJson,
+                activation_metadata_json as activationMetadataJson,
+                agent_surface_mode as agentSurfaceMode,
+                sender_name as senderName,
+                client_message_id as clientMessageId,
+                dispatching_run_id as dispatchingRunId,
+                dispatch_kind as dispatchKind,
+                dispatch_sent_at as dispatchSentAt,
+                dispatch_accepted_at as dispatchAcceptedAt
+         FROM conversation_prompt_queue
+         WHERE conversation_id = ?
+           AND COALESCE(dispatch_kind, '') != 'legacy_unknown'
+         ORDER BY created_at ASC, queue_id ASC
+         LIMIT 1`).get(conversationId);
+            if (!next)
+                return;
+            if (next.dispatchAcceptedAt != null) {
+                this.deleteQueuedPrompt(next.queueId);
+                continue;
+            }
+            if (next.dispatchingRunId) {
+                if (next.dispatchKind == null) {
+                    // Legacy in-flight rows from before dispatch_kind are ambiguous. Do not
+                    // auto-replay them after migration; that can duplicate already-run work.
+                    // Keep a DB-visible marker so operators can inspect the abandoned row.
+                    this.markQueueLegacyUnknown(next.queueId, next.dispatchingRunId);
+                    continue;
+                }
+                if (next.dispatchSentAt != null) {
+                    const retryInMs = next.dispatchSentAt + ORPHANED_QUEUE_ATTEMPT_STALE_MS - Date.now();
+                    if (retryInMs > 0) {
+                        this.scheduleQueueSettledRetry(conversationId, retryInMs);
+                        return;
+                    }
+                    this.clearQueueDispatchAttempt(next.queueId, next.dispatchingRunId);
+                }
+                else {
+                    this.clearQueueDispatchAttempt(next.queueId, next.dispatchingRunId);
+                }
+            }
+            try {
+                const queuedActivationMetadata = parsePromptActivationMetadata(next.activationMetadataJson);
+                await this.dispatchPrompt(next.conversationId, next.promptText, {
+                    recordAsUserMessage: next.recordAsUserMessage !== 0,
+                    activationContextText: next.activationContextText ?? undefined,
+                    activationContextMode: next.activationContextMode === 'resume_only' ? 'resume_only' : undefined,
+                    activationContextSections: queuedActivationMetadata?.promptContextSections?.activation,
+                    resumeContextText: next.resumeContextText ?? undefined,
+                    resumeContextSections: queuedActivationMetadata?.promptContextSections?.resume,
+                    replayOverlapRecentMessages: parseReplayOverlapRecentMessages(next.replayOverlapRecentMessagesJson),
+                    activationMetadata: queuedActivationMetadata,
+                    attachments: queuedActivationMetadata?.attachments,
+                    attachmentIds: queuedActivationMetadata?.attachmentIds,
+                    runtimeOverrides: queuedActivationMetadata?.runtimeOverrides,
+                    agentSurfaceMode: normalizeDispatchAgentSurfaceMode(next.agentSurfaceMode, normalizeDispatchAgentSurfaceMode(this.config.agentSurfaceMode, 'bigbang')),
+                    senderName: next.senderName ?? undefined,
+                    clientMessageId: next.clientMessageId ?? undefined,
+                    suppressReplyContract: queuedActivationMetadata?.suppressReplyContract === true,
+                    queuedPromptId: next.queueId,
+                });
+                this.deleteQueuedPrompt(next.queueId);
+            }
+            catch {
+                this.updateStatus(next.conversationId, 'failed');
+            }
+            return;
+        }
+    }
+    handleRunAccepted(runId, conversationId) {
+        const pending = this.resolvePendingDispatchAcceptance(runId);
+        const acceptedConversationIds = pending?.queuedPromptId != null
+            ? this.markQueueDispatchAccepted(runId, { queueId: pending.queuedPromptId, kind: 'dispatch' })
+            : this.markQueueDispatchAccepted(runId, { kind: 'dispatch' });
+        if (!pending && acceptedConversationIds.length <= 0)
+            return false;
+        const conversationIds = new Set([
+            conversationId,
+            pending?.conversationId,
+            ...acceptedConversationIds,
+        ].filter((id) => !!id));
+        for (const id of conversationIds) {
+            this.enableConversationBuiltinSkillRootsForAcceptedRun(runId, id);
+            this.updateStatus(id, 'active');
+        }
+        return true;
+    }
+    handleNodeHostSnapshotCurrentRun(params) {
+        const runId = typeof params === 'string' ? params : params.runId;
+        const status = getSnapshotConversationStatus(this.db, {
+            runId,
+            hasPendingApproval: typeof params === 'string' ? null : params.hasPendingApproval,
+        });
+        const pending = this.resolvePendingDispatchAcceptance(runId);
+        const conversationIds = pending?.queuedPromptId != null
+            ? this.markQueueDispatchAccepted(runId, { queueId: pending.queuedPromptId, kind: 'dispatch' })
+            : this.markQueueDispatchAccepted(runId, { kind: 'dispatch' });
+        if (pending?.conversationId)
+            conversationIds.push(pending.conversationId);
+        if (typeof params !== 'string') {
+            const reattachedConversationId = this.reattachActiveRunFromHostSnapshot(params);
+            if (reattachedConversationId)
+                conversationIds.push(reattachedConversationId);
+        }
+        const uniqueConversationIds = [...new Set(conversationIds)];
+        for (const conversationId of uniqueConversationIds) {
+            this.enableConversationBuiltinSkillRootsForAcceptedRun(runId, conversationId);
+            this.updateStatus(conversationId, status);
+        }
+        return uniqueConversationIds;
+    }
+    enableConversationBuiltinSkillRootsForAcceptedRun(runId, conversationId) {
+        const requestedBuiltinSkillRoots = this.getConversationBuiltinSkillRootsForAcceptedRun(runId);
+        if (requestedBuiltinSkillRoots.length === 0)
+            return;
+        const row = this.db.prepare(`SELECT builtin_skill_roots as builtinSkillRootsJson
+         FROM conversations
+        WHERE id = ?`).get(conversationId);
+        if (!row)
+            return;
+        const existingBuiltinSkillRoots = parseConversationBuiltinSkillRoots(row.builtinSkillRootsJson);
+        const mergedBuiltinSkillRoots = normalizeConversationBuiltinSkillRoots([
+            ...existingBuiltinSkillRoots,
+            ...requestedBuiltinSkillRoots,
+        ]);
+        if (stringArraysEqual(existingBuiltinSkillRoots, mergedBuiltinSkillRoots))
+            return;
+        this.db.prepare(`UPDATE conversations
+          SET builtin_skill_roots = ?,
+              updated_at = ?
+        WHERE id = ?`).run(serializeConversationBuiltinSkillRoots(mergedBuiltinSkillRoots), Date.now(), conversationId);
+    }
+    getConversationBuiltinSkillRootsForAcceptedRun(runId) {
+        const row = this.db.prepare(`SELECT activation_metadata_json as activationMetadataJson
+         FROM run_debug_inputs
+        WHERE run_id = ?
+        LIMIT 1`).get(runId);
+        const activationMetadata = parsePromptActivationMetadata(row?.activationMetadataJson);
+        return conversationBuiltinSkillRootsForSlashCommand(activationMetadata?.slashCommand?.name);
+    }
+    getRunDebugInputAgentSurfaceMode(runId) {
+        const row = this.db.prepare(`SELECT agent_surface_mode as agentSurfaceMode
+         FROM run_debug_inputs
+        WHERE run_id = ?
+        LIMIT 1`).get(runId);
+        return normalizeDispatchAgentSurfaceMode(row?.agentSurfaceMode, null);
+    }
+    reattachActiveRunFromHostSnapshot(params) {
+        const row = this.db.prepare(`SELECT c.id as conversationId,
+              c.node_id as nodeId,
+              c.agent_type as agentType,
+              c.session_key as conversationSessionKey,
+              r.session_key as runSessionKey,
+              r.ended_at as endedAt,
+              r.stop_reason as stopReason,
+              r.error as error
+       FROM runs r
+       JOIN conversations c ON c.session_key = r.session_key
+       WHERE r.run_id = ?
+       LIMIT 1`).get(params.runId);
+        if (!row)
+            return null;
+        const expectedHostKey = `conversation:${row.conversationId}:${row.agentType}`;
+        if (row.nodeId !== params.nodeId
+            || row.agentType !== params.agentType
+            || row.conversationSessionKey !== params.sessionKey
+            || row.runSessionKey !== params.sessionKey
+            || params.hostKey !== expectedHostKey) {
+            return null;
+        }
+        if (row.endedAt == null) {
+            return row.conversationId;
+        }
+        if (row.stopReason != null || !isRecoverableEndedRunError(row.error)) {
+            return null;
+        }
+        const result = this.db.prepare(`UPDATE runs
+          SET ended_at = NULL,
+              stop_reason = NULL,
+              error = NULL
+        WHERE run_id = ?
+          AND ended_at IS NOT NULL`).run(params.runId);
+        if (result.changes <= 0)
+            return null;
+        log.warn('[dispatcher] reattached active run from node host snapshot', {
+            conversationId: row.conversationId,
+            runId: params.runId,
+            nodeId: params.nodeId,
+            agentType: row.agentType,
+            previousError: row.error,
+        });
+        return row.conversationId;
+    }
+    handleRunFinished(runId, conversationId, options) {
+        const dreamDebug = this.db.prepare(`SELECT dispatch_mode as dispatchMode,
+              activation_metadata_json as activationMetadataJson
+         FROM run_debug_inputs
+        WHERE run_id = ?
+        LIMIT 1`).get(runId);
+        if (dreamDebug?.dispatchMode === 'dream') {
+            let dreamAgentId = null;
+            let dreamStartSeq = null;
+            if (dreamDebug.activationMetadataJson) {
+                try {
+                    const parsed = JSON.parse(dreamDebug.activationMetadataJson);
+                    dreamAgentId = parsed.agentId?.trim() || null;
+                    dreamStartSeq = typeof parsed.dreamStartSeq === 'number' ? parsed.dreamStartSeq : null;
+                }
+                catch {
+                    dreamAgentId = null;
+                    dreamStartSeq = null;
+                }
+            }
+            if (!dreamAgentId) {
+                const conversation = this.db.prepare(`SELECT agent_id as agentId FROM conversations WHERE id = ?`).get(conversationId);
+                dreamAgentId = conversation?.agentId ?? null;
+            }
+            const run = this.db.prepare(`SELECT error, stop_reason as stopReason FROM runs WHERE run_id = ?`).get(runId);
+            let finalized = false;
+            if (dreamAgentId) {
+                finalized = finalizeDreamRun(this.db, dreamAgentId, {
+                    startSeq: dreamStartSeq,
+                    error: options?.error ?? run?.error,
+                    stopReason: options?.stopReason ?? run?.stopReason,
+                });
+            }
+            this.updateStatus(conversationId, 'idle');
+            return finalized;
+        }
+        const pending = this.resolvePendingDispatchAcceptance(runId);
+        const acceptedConversationIds = pending?.queuedPromptId != null
+            ? this.markQueueDispatchAccepted(runId, { queueId: pending.queuedPromptId, kind: 'dispatch' })
+            : this.markQueueDispatchAccepted(runId, { kind: 'dispatch' });
+        if (!pending && acceptedConversationIds.length <= 0)
+            return false;
+        const conversationIds = new Set([
+            conversationId,
+            pending?.conversationId,
+            ...acceptedConversationIds,
+        ].filter((id) => !!id));
+        for (const id of conversationIds) {
+            this.updateStatus(id, 'active');
+        }
+        return true;
+    }
+    close() {
+        for (const timer of this.queueRetryTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.queueRetryTimers.clear();
+    }
+    /** Recover steer acks that were persisted to the events table but whose
+     *  pendingSteerResponses Map entry was lost across a core restart.
+     *
+     *  Scans events for orphan `run.steer.result` events, matches them to
+     *  pending queue entries with `dispatch_kind = 'steer'`, and either:
+     *  - ack:  marks the queue entry as accepted (ok=true)
+     *  - fallback: clears the steer attempt and marks as dispatch (ok=false)
+     */
+    recoverSteerAcks() {
+        // 1. Collect all steer result events from the events table
+        const steerResultRows = this.db.prepare(`SELECT run_id as runId,
+              seq,
+              payload_json as payloadJson,
+              created_at as createdAt
+       FROM events
+       WHERE method = 'node/event'
+         AND json_valid(payload_json)
+         AND json_extract(payload_json, '$.type') = 'run.steer.result'
+       ORDER BY created_at ASC, seq ASC`).all();
+        if (steerResultRows.length === 0)
+            return;
+        const steerResults = [];
+        for (const row of steerResultRows) {
+            try {
+                const payload = JSON.parse(row.payloadJson);
+                if (typeof payload.requestId === 'string'
+                    && typeof payload.runId === 'string'
+                    && typeof payload.ok === 'boolean') {
+                    steerResults.push({
+                        requestId: payload.requestId,
+                        runId: payload.runId,
+                        ok: payload.ok,
+                        createdAt: row.createdAt,
+                    });
+                }
+            }
+            catch {
+                // skip malformed payloads
+            }
+        }
+        if (steerResults.length === 0)
+            return;
+        // 2. Collect pending steer queue entries (not yet accepted)
+        const pendingSteerQueueRows = this.db.prepare(`SELECT q.queue_id as queueId,
+              q.dispatching_run_id as dispatchingRunId,
+              q.dispatch_request_id as dispatchRequestId,
+              q.dispatch_sent_at as dispatchSentAt,
+              r.ended_at as runEndedAt,
+              q.created_at as createdAt
+       FROM conversation_prompt_queue q
+       JOIN runs r ON r.run_id = q.dispatching_run_id
+       WHERE q.dispatch_kind = 'steer'
+         AND q.dispatch_accepted_at IS NULL
+         AND q.dispatching_run_id IS NOT NULL
+         AND q.dispatch_request_id IS NOT NULL
+       ORDER BY q.created_at ASC, q.queue_id ASC`).all();
+        if (pendingSteerQueueRows.length === 0)
+            return;
+        // 3. Group steer results and queue entries by exact request id.
+        const steerResultsByRequestId = new Map();
+        for (const sr of steerResults) {
+            steerResultsByRequestId.set(sr.requestId, sr);
+        }
+        const queueEntriesByRequestId = new Map();
+        for (const qe of pendingSteerQueueRows) {
+            queueEntriesByRequestId.set(qe.dispatchRequestId, qe);
+        }
+        // 4. Recover only exact request-id matches. Chronological run matching can
+        // attach a late ack to a different follow-up on the same long-running turn.
+        let recoveredCount = 0;
+        for (const [requestId, result] of steerResultsByRequestId) {
+            const entry = queueEntriesByRequestId.get(requestId);
+            if (!entry || entry.dispatchingRunId !== result.runId)
+                continue;
+            if (entry.runEndedAt != null) {
+                this.clearQueueDispatchAttempt(entry.queueId, result.runId, result.requestId);
+                this.markSteerResultRequestProcessed(result.requestId);
+                recoveredCount++;
+                log.warn('[dispatcher] ignored steer ack for ended run during recovery; queued prompt will fallback to dispatch', {
+                    runId: result.runId,
+                    queueId: entry.queueId,
+                    requestId: result.requestId,
+                });
+                continue;
+            }
+            if (result.ok) {
+                // ok steers: mark queue entry as accepted so handleConversationSettled will delete it
+                this.db.prepare(`UPDATE conversation_prompt_queue
+             SET dispatch_accepted_at = ?, updated_at = ?
+             WHERE queue_id = ?`).run(Date.now(), Date.now(), entry.queueId);
+                log.info('[dispatcher] recovered steer ack (ok) from events table', {
+                    runId: result.runId,
+                    queueId: entry.queueId,
+                    requestId: result.requestId,
+                });
+            }
+            else {
+                // failed steers: fall back to queue dispatch
+                this.db.prepare(`UPDATE conversation_prompt_queue
+	             SET dispatch_kind = 'dispatch',
+	                 dispatching_run_id = NULL,
+	                 dispatch_request_id = NULL,
+	                 dispatch_sent_at = NULL,
+	                 dispatch_accepted_at = NULL,
+                 updated_at = ?
+             WHERE queue_id = ?`).run(Date.now(), entry.queueId);
+                log.info('[dispatcher] recovered steer ack (fail → fallback to dispatch) from events table', {
+                    runId: result.runId,
+                    queueId: entry.queueId,
+                    requestId: result.requestId,
+                });
+            }
+            this.markSteerResultRequestProcessed(result.requestId);
+            recoveredCount++;
+        }
+        if (recoveredCount > 0) {
+            log.info('[dispatcher] steer ack recovery complete', { recoveredCount });
+        }
+    }
+    recoverOrphanedSteerResult(params) {
+        const entry = this.db.prepare(`SELECT q.queue_id as queueId,
+              r.ended_at as runEndedAt
+       FROM conversation_prompt_queue q
+       JOIN runs r ON r.run_id = q.dispatching_run_id
+       WHERE q.conversation_id = ?
+         AND q.dispatching_run_id = ?
+         AND q.dispatch_request_id = ?
+         AND q.dispatch_kind = 'steer'
+         AND q.dispatch_accepted_at IS NULL
+       ORDER BY q.created_at ASC, q.queue_id ASC
+       LIMIT 1`).get(params.conversationId, params.runId, params.requestId);
+        if (!entry)
+            return false;
+        const now = Date.now();
+        if (entry.runEndedAt != null) {
+            this.clearQueueDispatchAttempt(entry.queueId, params.runId, params.requestId);
+            log.warn('[dispatcher] ignored live orphan steer ack for ended run; queued prompt will fallback to dispatch', {
+                requestId: params.requestId,
+                runId: params.runId,
+                conversationId: params.conversationId,
+                queueId: entry.queueId,
+            });
+            return true;
+        }
+        if (params.ok) {
+            const result = this.db.prepare(`UPDATE conversation_prompt_queue
+         SET dispatch_accepted_at = ?, updated_at = ?
+         WHERE queue_id = ?
+           AND conversation_id = ?
+           AND dispatching_run_id = ?
+           AND dispatch_request_id = ?
+           AND dispatch_kind = 'steer'
+           AND dispatch_accepted_at IS NULL`).run(now, now, entry.queueId, params.conversationId, params.runId, params.requestId);
+            if (result.changes <= 0)
+                return false;
+            log.info('[dispatcher] recovered live orphan steer ack', {
+                requestId: params.requestId,
+                runId: params.runId,
+                conversationId: params.conversationId,
+                queueId: entry.queueId,
+            });
+            return true;
+        }
+        const result = this.db.prepare(`UPDATE conversation_prompt_queue
+       SET dispatch_kind = 'dispatch',
+           dispatching_run_id = NULL,
+           dispatch_request_id = NULL,
+           dispatch_sent_at = NULL,
+           dispatch_accepted_at = NULL,
+           updated_at = ?
+       WHERE queue_id = ?
+         AND conversation_id = ?
+         AND dispatching_run_id = ?
+         AND dispatch_request_id = ?
+         AND dispatch_kind = 'steer'
+         AND dispatch_accepted_at IS NULL`).run(now, entry.queueId, params.conversationId, params.runId, params.requestId);
+        if (result.changes <= 0)
+            return false;
+        log.info('[dispatcher] recovered live orphan failed steer ack for queue fallback', {
+            requestId: params.requestId,
+            runId: params.runId,
+            conversationId: params.conversationId,
+            queueId: entry.queueId,
+            error: params.error,
+        });
+        return true;
+    }
+    markSteerResultRequestProcessed(requestId) {
+        this.processedSteerResultRequestIds.add(requestId);
+        if (this.processedSteerResultRequestIds.size <= MAX_PROCESSED_STEER_RESULT_REQUEST_IDS)
+            return;
+        const first = this.processedSteerResultRequestIds.values().next().value;
+        if (first)
+            this.processedSteerResultRequestIds.delete(first);
+    }
+    handleRunSteerResult(params) {
+        const pending = this.pendingSteerResponses.get(params.requestId);
+        if (!pending) {
+            if (this.processedSteerResultRequestIds.has(params.requestId))
+                return false;
+            const recovered = this.recoverOrphanedSteerResult(params);
+            if (recovered)
+                this.markSteerResultRequestProcessed(params.requestId);
+            return recovered;
+        }
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        this.pendingSteerResponses.delete(params.requestId);
+        this.markSteerResultRequestProcessed(params.requestId);
+        if (pending.runId !== params.runId || pending.conversationId !== params.conversationId) {
+            pending.reject(new Error('Node steer response did not match the pending request.'));
+            return true;
+        }
+        if (!params.ok) {
+            pending.reject(new Error(params.error?.trim() || 'Active runtime turn is not steerable.'));
+            return true;
+        }
+        this.markQueueDispatchAccepted(params.runId, pending.queuedPromptId != null
+            ? { queueId: pending.queuedPromptId, kind: 'steer' }
+            : { kind: 'steer' });
+        pending.resolve();
+        return true;
+    }
+    async sendBestEffortSystemNoticeToActiveRun(params) {
+        const row = this.db.prepare(`SELECT agent_id as agentId,
+              agent_type as agentType,
+              node_id as nodeId
+       FROM conversations
+       WHERE id = ?`).get(params.conversationId);
+        if (!row?.agentId || !row.nodeId || !hasEffectiveAgentRuntimeCapability(this.db, {
+            nodeId: row.nodeId,
+            agentType: row.agentType,
+            capability: 'activeTurnSteer',
+        }))
+            return false;
+        if (this.steerChains.has(params.runId))
+            return false;
+        let resolveAttempt = null;
+        let attemptSettled = false;
+        const attemptPromise = new Promise((resolve) => {
+            resolveAttempt = resolve;
+        });
+        const settleAttempt = (value) => {
+            if (attemptSettled)
+                return;
+            attemptSettled = true;
+            resolveAttempt?.(value);
+        };
+        void this.withSteerSerial(params.runId, async () => {
+            const active = this.db.prepare(`SELECT 1
+         FROM conversations c
+         JOIN runs r ON r.session_key = c.session_key
+         WHERE c.id = ?
+           AND r.run_id = ?
+           AND r.ended_at IS NULL
+         LIMIT 1`).get(params.conversationId, params.runId);
+            if (!active) {
+                settleAttempt(false);
+                return;
+            }
+            const requestId = randomUUID();
+            const response = this.waitForSteerResponse(requestId, row.nodeId, params.runId, params.conversationId, undefined, ACTIVE_TURN_STEER_RESPONSE_TIMEOUT_MS);
+            const sent = this.nodeRegistry?.send(row.nodeId, {
+                type: 'run.steer',
+                requestId,
+                runId: params.runId,
+                conversationId: params.conversationId,
+                prompt: params.promptText,
+            });
+            if (!sent) {
+                this.clearPendingSteerResponse(requestId);
+                settleAttempt(false);
+                log.warn('[dispatcher] source handoff notice steer send failed', {
+                    nodeId: row.nodeId,
+                    conversationId: params.conversationId,
+                    runId: params.runId,
+                });
+                return;
+            }
+            try {
+                await response;
+                settleAttempt(true);
+            }
+            catch (error) {
+                settleAttempt(false);
+                log.warn('[dispatcher] source handoff notice steer failed', {
+                    nodeId: row.nodeId,
+                    conversationId: params.conversationId,
+                    runId: params.runId,
+                    error: String(error?.message ?? error),
+                });
+            }
+        }).catch((error) => {
+            settleAttempt(false);
+            log.warn('[dispatcher] source handoff notice steer crashed', {
+                conversationId: params.conversationId,
+                runId: params.runId,
+                error: String(error?.message ?? error),
+            });
+        });
+        return attemptPromise;
+    }
+    rejectPendingDispatchesForNode(nodeId, errorMessage) {
+        for (const [runId, pending] of this.pendingDispatchAcceptances.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new Error(errorMessage));
+            this.pendingDispatchAcceptances.delete(runId);
+        }
+    }
+    rejectPendingSteersForNode(nodeId, errorMessage) {
+        for (const [requestId, pending] of this.pendingSteerResponses.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new Error(errorMessage));
+            this.pendingSteerResponses.delete(requestId);
+        }
+    }
+    rejectPendingSteersForRun(runId, conversationId, errorMessage) {
+        this.clearQueueSteerAttemptsForRun(runId, conversationId);
+        for (const [requestId, pending] of this.pendingSteerResponses.entries()) {
+            if (pending.runId !== runId || pending.conversationId !== conversationId)
+                continue;
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new Error(errorMessage));
+            this.pendingSteerResponses.delete(requestId);
+        }
+    }
+    ensureConversationSessionAgent(agentType) {
+        const driver = getRuntimeDriver(agentType);
+        return { command: driver.command, args: [...driver.args] };
+    }
+    isIgnorableReplayAssistantText(text) {
+        return text.includes(`Empty response: {'content':`)
+            || text.trim() === '[stop_reason] handoff'
+            || text.trim() === '[stop_reason] handoff_bootstrap';
+    }
+    compactReplayFailureSummary(error) {
+        const compact = sanitizePromptHistoryContent(error, 'agent')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (compact.length <= 300)
+            return compact;
+        return `${compact.slice(0, 297).trimEnd()}...`;
+    }
+    getDispatchMode(sessionKey) {
+        const row = this.db
+            .prepare('SELECT COUNT(*) as count FROM runs WHERE session_key = ?')
+            .get(sessionKey);
+        return row.count > 0 ? 'resume' : 'cold_start';
+    }
+    loadNodeSurfaceReadiness(nodeId) {
+        const row = this.db.prepare(`SELECT process_instance_id as processInstanceId,
+              capabilities_json as capabilitiesJson
+         FROM node_runtime_snapshots
+        WHERE node_id = ?
+        LIMIT 1`).get(nodeId);
+        if (!row) {
+            return {
+                hasSnapshot: false,
+                processInstanceId: null,
+                agentSurfaceMode: null,
+                bigbangCliAvailable: null,
+            };
+        }
+        let capabilities;
+        try {
+            capabilities = row.capabilitiesJson ? JSON.parse(row.capabilitiesJson) : {};
+        }
+        catch {
+            capabilities = {};
+        }
+        const record = capabilities && typeof capabilities === 'object' && !Array.isArray(capabilities)
+            ? capabilities
+            : {};
+        const agentSurfaceMode = normalizeDispatchAgentSurfaceMode(record.agentSurfaceMode, null);
+        return {
+            hasSnapshot: true,
+            processInstanceId: row.processInstanceId,
+            agentSurfaceMode,
+            bigbangCliAvailable: typeof record.bigbangCliAvailable === 'boolean' ? record.bigbangCliAvailable : null,
+        };
+    }
+    /**
+     * Rebuild recent conversation history from core's DB (content.delta events) so that
+     * a freshly restarted ACP process can recover context it would otherwise have lost.
+     */
+    buildConversationReplayText(conversationId, sessionKey, excludeRunId, overlapRecentMessages, hasVisibleRecentWindow = false) {
+        if (!this.config.contextReplayEnabled || this.config.contextReplayRuns <= 0)
+            return '';
+        const conversationAgentName = getConversationAgentName(this.db, conversationId);
+        const resetRow = this.db.prepare(`SELECT history_reset_at as historyResetAt
+       FROM conversations
+       WHERE id = ?`).get(conversationId);
+        const historyResetAt = resetRow?.historyResetAt ?? null;
+        const runs = this.db.prepare(`SELECT run_id as runId, prompt_text as promptText, stop_reason as stopReason, error
+       FROM runs
+       WHERE session_key = ?
+         AND run_id != ?
+         AND ended_at IS NOT NULL
+         AND (? IS NULL OR started_at >= ?)
+       ORDER BY started_at DESC
+       LIMIT ?`).all(sessionKey, excludeRunId, historyResetAt, historyResetAt, this.config.contextReplayRuns);
+        const chronological = runs.slice().reverse();
+        const blocks = [];
+        for (const run of chronological) {
+            const visibleAgentMessages = this.db.prepare(`SELECT content, message_kind as messageKind, sender_name as senderName
+         FROM channel_messages
+         WHERE run_id = ?
+           AND sender_type = 'agent'
+         ORDER BY created_at ASC, seq ASC`).all(run.runId);
+            let assistantLine = '';
+            const finalMessage = [...visibleAgentMessages].reverse().find((row) => row.messageKind === 'final');
+            const lastVisibleMessage = visibleAgentMessages.length > 0
+                ? visibleAgentMessages[visibleAgentMessages.length - 1]
+                : undefined;
+            const hasVisibleAgentMessage = Boolean(finalMessage?.content?.trim() || lastVisibleMessage?.content?.trim());
+            if (finalMessage?.content?.trim()) {
+                assistantLine = sanitizePromptHistoryContent(finalMessage.content, 'agent');
+            }
+            else if (lastVisibleMessage?.content?.trim()) {
+                assistantLine = sanitizePromptHistoryContent(lastVisibleMessage.content, 'agent');
+            }
+            let hasAssistantDelta = false;
+            if (!assistantLine) {
+                let assistantText = '';
+                for (const ev of iterateParsedNodeEvents(this.db, {
+                    runId: run.runId,
+                    types: ['content.delta'],
+                })) {
+                    if (ev.event?.type === 'content.delta') {
+                        assistantText += ev.event.text;
+                    }
+                }
+                const cleanedAssistantText = assistantText.trim();
+                hasAssistantDelta = Boolean(cleanedAssistantText && !this.isIgnorableReplayAssistantText(cleanedAssistantText));
+                assistantLine = cleanedAssistantText && !this.isIgnorableReplayAssistantText(cleanedAssistantText)
+                    ? cleanedAssistantText
+                    : run.error
+                        ? `[error] ${run.error}`
+                        : run.stopReason && !this.isIgnorableReplayAssistantText(`[stop_reason] ${run.stopReason}`)
+                            ? `[stop_reason] ${run.stopReason}`
+                            : '';
+            }
+            if (!hasVisibleAgentMessage && !hasAssistantDelta && run.error?.trim()) {
+                const assistantBlock = createReplayRenderableBlock({
+                    speaker: 'agent',
+                    renderLabel: conversationAgentName || 'Assistant',
+                    text: `Previous attempt failed before agent response: ${this.compactReplayFailureSummary(run.error)}`,
+                });
+                if (assistantBlock) {
+                    blocks.push(assistantBlock);
+                }
+                continue;
+            }
+            const normalizedUserText = normalizeReplayUserText(run.promptText);
+            if (normalizedUserText) {
+                const userBlock = createReplayRenderableBlock({
+                    speaker: 'user',
+                    renderLabel: 'User',
+                    text: normalizedUserText,
+                });
+                if (userBlock) {
+                    blocks.push(userBlock);
+                }
+            }
+            if (assistantLine) {
+                const assistantLabel = finalMessage?.senderName?.trim()
+                    || lastVisibleMessage?.senderName?.trim()
+                    || conversationAgentName
+                    || 'Assistant';
+                const assistantBlock = createReplayRenderableBlock({
+                    speaker: 'agent',
+                    renderLabel: assistantLabel,
+                    text: assistantLine,
+                });
+                if (assistantBlock) {
+                    blocks.push(assistantBlock);
+                }
+            }
+        }
+        const trimmedBlocks = trimReplayBlocksAgainstRecentMessages(blocks, overlapRecentMessages);
+        const raw = trimmedBlocks.map(renderReplayBlock).join('\n');
+        if (!raw.trim())
+            return '';
+        const header = hasVisibleRecentWindow
+            ? 'Context (older messages from before the recent window, for continuity after restart):\n'
+            : 'Context (previous messages, for continuity after restart):\n';
+        const full = header + raw;
+        if (full.length <= this.config.contextReplayMaxChars)
+            return full;
+        return header + raw.slice(Math.max(0, raw.length - this.config.contextReplayMaxChars));
+    }
+    updateStatus(conversationId, status) {
+        this.db
+            .prepare('UPDATE conversations SET status = ?, updated_at = ? WHERE id = ?')
+            .run(status, Date.now(), conversationId);
+    }
+    findBlockingConversation(conversationId) {
+        const row = this.db.prepare(`SELECT c.id, c.status, r.run_id as runId
+       FROM conversations c
+       LEFT JOIN runs r ON r.session_key = c.session_key AND r.ended_at IS NULL
+       WHERE c.id = ?
+         AND (
+           r.run_id IS NOT NULL
+           OR c.status IN ('active', 'recovering', 'awaiting_approval')
+         )
+       LIMIT 1`).get(conversationId);
+        return row ?? null;
+    }
+    enqueuePrompt(agentId, conversationId, promptText, options) {
+        const now = Date.now();
+        const result = this.db.prepare(`INSERT INTO conversation_prompt_queue(
+         agent_id, conversation_id, prompt_text, record_as_user_message, activation_context_text, activation_context_mode, resume_context_text, replay_overlap_recent_messages_json, activation_metadata_json, agent_surface_mode, sender_name, client_message_id, created_at, updated_at
+       )
+       VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(agentId, conversationId, promptText, (options?.recordAsUserMessage ?? true) ? 1 : 0, options?.activationContextText?.trim() || null, options?.activationContextMode === 'resume_only' ? 'resume_only' : null, options?.resumeContextText?.trim() || null, serializeReplayOverlapRecentMessages(options?.replayOverlapRecentMessages), serializePromptActivationMetadata(enrichPromptActivationMetadataWithContextSections(options)), normalizeDispatchAgentSurfaceMode(options?.agentSurfaceMode, normalizeDispatchAgentSurfaceMode(this.config.agentSurfaceMode, 'bigbang')), options?.senderName ?? null, options?.clientMessageId ?? null, now, now);
+        return Number(result.lastInsertRowid);
+    }
+    persistDirectUserMessageForQueuedPromptIfNeeded(conversationId, conversation, promptText, options) {
+        if (!conversation.agentId || conversation.threadKind !== 'direct' || (options?.recordAsUserMessage ?? true) === false) {
+            return options;
+        }
+        const persistedMessage = this.persistDirectUserMessageForConversation({
+            conversationId,
+            conversation,
+            promptText,
+            options,
+            attachments: sanitizeFileRefs(options?.attachments),
+            attachmentIds: sanitizeAttachmentIds(options?.attachmentIds),
+        });
+        return {
+            ...options,
+            clientMessageId: persistedMessage.messageId,
+            persistedDirectUserMessage: persistedMessage,
+            activationMetadata: {
+                ...(options?.activationMetadata ?? {}),
+                triggerMessage: {
+                    messageId: persistedMessage.messageId,
+                    seq: persistedMessage.seq,
+                    target: persistedMessage.replyTarget,
+                },
+            },
+        };
+    }
+    getConversationQueueHead(conversationId) {
+        return this.db.prepare(`SELECT queue_id as queueId,
+              dispatching_run_id as dispatchingRunId,
+              dispatch_sent_at as dispatchSentAt,
+              dispatch_accepted_at as dispatchAcceptedAt
+	       FROM conversation_prompt_queue
+	       WHERE conversation_id = ?
+	         AND COALESCE(dispatch_kind, '') != 'legacy_unknown'
+	       ORDER BY created_at ASC, queue_id ASC
+	       LIMIT 1`).get(conversationId);
+    }
+    deleteAcceptedQueueHeads(conversationId) {
+        while (true) {
+            const head = this.getConversationQueueHead(conversationId);
+            if (!head || head.dispatchAcceptedAt == null)
+                return;
+            this.deleteQueuedPrompt(head.queueId);
+        }
+    }
+    scheduleQueueRetryForHead(conversationId, head) {
+        if (!head.dispatchingRunId || head.dispatchAcceptedAt != null || head.dispatchSentAt == null)
+            return;
+        const retryInMs = head.dispatchSentAt + ORPHANED_QUEUE_ATTEMPT_STALE_MS - Date.now();
+        this.scheduleQueueSettledRetry(conversationId, Math.max(0, retryInMs));
+    }
+    scheduleQueueSettledRetry(conversationId, delayMs) {
+        if (this.queueRetryTimers.has(conversationId))
+            return;
+        const timer = setTimeout(() => {
+            this.queueRetryTimers.delete(conversationId);
+            void this.handleConversationSettled(conversationId).catch((error) => {
+                log.warn('[dispatcher] queued prompt retry failed', {
+                    conversationId,
+                    error: String(error?.message ?? error),
+                });
+            });
+        }, Math.max(0, delayMs));
+        timer.unref?.();
+        this.queueRetryTimers.set(conversationId, timer);
+    }
+    deleteQueuedPrompt(queueId) {
+        this.db.prepare('DELETE FROM conversation_prompt_queue WHERE queue_id = ?').run(queueId);
+    }
+    markQueueDispatchAttempt(queueId, runId, kind, requestId) {
+        if (queueId == null)
+            return;
+        this.db.prepare(`UPDATE conversation_prompt_queue
+       SET dispatching_run_id = ?,
+           dispatch_kind = ?,
+           dispatch_request_id = ?,
+           dispatch_sent_at = NULL,
+           dispatch_accepted_at = NULL,
+           updated_at = ?
+       WHERE queue_id = ?`).run(runId, kind, kind === 'steer' ? requestId ?? null : null, Date.now(), queueId);
+    }
+    markQueueDispatchSent(queueId, runId) {
+        if (queueId == null)
+            return;
+        this.db.prepare(`UPDATE conversation_prompt_queue
+       SET dispatch_sent_at = ?, updated_at = ?
+	       WHERE queue_id = ? AND dispatching_run_id = ? AND dispatch_accepted_at IS NULL`).run(Date.now(), Date.now(), queueId, runId);
+    }
+    markQueueDispatchAccepted(runId, options) {
+        const now = Date.now();
+        const kind = options?.kind;
+        if (options?.queueId != null) {
+            const kindPredicate = kind === 'dispatch'
+                ? `AND dispatch_kind = 'dispatch'`
+                : kind === 'steer'
+                    ? `AND dispatch_kind = 'steer'`
+                    : '';
+            const result = this.db.prepare(`UPDATE conversation_prompt_queue
+         SET dispatch_accepted_at = ?, updated_at = ?
+         WHERE queue_id = ? AND dispatching_run_id = ?
+         ${kindPredicate}`).run(now, now, options.queueId, runId);
+            if (result.changes <= 0)
+                return [];
+            const row = this.db.prepare(`SELECT conversation_id as conversationId
+         FROM conversation_prompt_queue
+         WHERE queue_id = ?`).get(options.queueId);
+            return row ? [row.conversationId] : [];
+        }
+        const kindPredicate = kind === 'dispatch'
+            ? `AND dispatch_kind = 'dispatch'`
+            : kind === 'steer'
+                ? `AND dispatch_kind = 'steer'`
+                : '';
+        const rows = this.db.prepare(`SELECT DISTINCT conversation_id as conversationId
+       FROM conversation_prompt_queue
+       WHERE dispatching_run_id = ?
+       ${kindPredicate}`).all(runId);
+        if (rows.length === 0)
+            return [];
+        this.db.prepare(`UPDATE conversation_prompt_queue
+       SET dispatch_accepted_at = ?, updated_at = ?
+       WHERE dispatching_run_id = ?
+       ${kindPredicate}`).run(now, now, runId);
+        return rows.map((row) => row.conversationId);
+    }
+    clearQueueDispatchAttempt(queueId, runId, requestId) {
+        if (queueId == null)
+            return;
+        this.db.prepare(`UPDATE conversation_prompt_queue
+       SET dispatching_run_id = NULL,
+           dispatch_kind = NULL,
+           dispatch_request_id = NULL,
+           dispatch_sent_at = NULL,
+           dispatch_accepted_at = NULL,
+           updated_at = ?
+       WHERE queue_id = ?
+         AND dispatching_run_id = ?
+         AND dispatch_accepted_at IS NULL
+         AND (? IS NULL OR dispatch_request_id = ?)`).run(Date.now(), queueId, runId, requestId ?? null, requestId ?? null);
+    }
+    clearQueueSteerAttemptsForRun(runId, conversationId) {
+        this.db.prepare(`UPDATE conversation_prompt_queue
+       SET dispatching_run_id = NULL,
+           dispatch_kind = NULL,
+           dispatch_request_id = NULL,
+           dispatch_sent_at = NULL,
+           dispatch_accepted_at = NULL,
+           updated_at = ?
+       WHERE conversation_id = ?
+         AND dispatching_run_id = ?
+         AND dispatch_kind = 'steer'
+         AND dispatch_accepted_at IS NULL`).run(Date.now(), conversationId, runId);
+    }
+    markQueueLegacyUnknown(queueId, runId) {
+        if (queueId == null)
+            return;
+        this.db.prepare(`UPDATE conversation_prompt_queue
+       SET dispatch_kind = 'legacy_unknown',
+           dispatch_request_id = NULL,
+           dispatch_sent_at = NULL,
+           dispatch_accepted_at = NULL,
+           updated_at = ?
+       WHERE queue_id = ? AND dispatching_run_id = ? AND dispatch_kind IS NULL`).run(Date.now(), queueId, runId);
+    }
+    waitForDispatchAcceptance(runId, nodeId, conversationId, queuedPromptId) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingDispatchAcceptances.delete(runId);
+                reject(new Error('Node did not acknowledge dispatch in time'));
+            }, this.config.nodeDispatchAckTimeoutMs);
+            this.pendingDispatchAcceptances.set(runId, {
+                nodeId,
+                conversationId,
+                queuedPromptId,
+                resolve,
+                reject,
+                timer,
+            });
+        });
+    }
+    waitForSteerResponse(requestId, nodeId, runId, conversationId, queuedPromptId, timeoutMs = ACTIVE_TURN_STEER_RESPONSE_TIMEOUT_MS) {
+        return new Promise((resolve, reject) => {
+            const timer = timeoutMs == null
+                ? undefined
+                : setTimeout(() => {
+                    this.pendingSteerResponses.delete(requestId);
+                    this.clearQueueDispatchAttempt(queuedPromptId, runId, requestId);
+                    this.markSteerResultRequestProcessed(requestId);
+                    reject(new Error('Node did not acknowledge active-turn steer in time'));
+                }, timeoutMs);
+            this.pendingSteerResponses.set(requestId, {
+                nodeId,
+                runId,
+                conversationId,
+                queuedPromptId,
+                resolve,
+                reject,
+                ...(timer ? { timer } : {}),
+            });
+        });
+    }
+    clearPendingDispatchAcceptance(runId) {
+        const pending = this.pendingDispatchAcceptances.get(runId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingDispatchAcceptances.delete(runId);
+    }
+    resolvePendingDispatchAcceptance(runId) {
+        const pending = this.pendingDispatchAcceptances.get(runId);
+        if (!pending)
+            return null;
+        clearTimeout(pending.timer);
+        this.pendingDispatchAcceptances.delete(runId);
+        pending.resolve();
+        return { conversationId: pending.conversationId, queuedPromptId: pending.queuedPromptId };
+    }
+    clearPendingSteerResponse(requestId) {
+        const pending = this.pendingSteerResponses.get(requestId);
+        if (!pending)
+            return;
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        this.pendingSteerResponses.delete(requestId);
+    }
+    async withSteerSerial(runId, task) {
+        const previous = this.steerChains.get(runId) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(task);
+        const tracked = current.catch(() => undefined);
+        this.steerChains.set(runId, tracked);
+        try {
+            return await current;
+        }
+        finally {
+            if (this.steerChains.get(runId) === tracked) {
+                this.steerChains.delete(runId);
+            }
+        }
+    }
+    resolveChannelBridgeServerUrl(nodeId) {
+        const bridgeUrl = this.config.agentBridgeServerUrl?.trim();
+        if (bridgeUrl) {
+            if (this.isLoopbackBridgeUrl(bridgeUrl) && !this.isLocalBridgeNode(nodeId)) {
+                return this.resolveReachableCoreServerUrl();
+            }
+            return bridgeUrl.replace(/\/+$/, '');
+        }
+        return this.resolveReachableCoreServerUrl();
+    }
+    resolveReachableCoreServerUrl() {
+        const legacyPublicUrl = this.config.publicServerUrl?.trim();
+        if (legacyPublicUrl && !this.config.publicBasePath?.trim()) {
+            return legacyPublicUrl.replace(/\/+$/, '');
+        }
+        const host = this.resolveReachableCoreHost();
+        return `http://${host}:${this.config.webPort}`;
+    }
+    resolveReachableCoreHost() {
+        const configuredHost = this.config.webHost?.trim() || '127.0.0.1';
+        if (configuredHost !== '0.0.0.0' && configuredHost !== '::')
+            return configuredHost;
+        for (const entries of Object.values(os.networkInterfaces())) {
+            for (const entry of entries ?? []) {
+                if (entry.family !== 'IPv4' || entry.internal)
+                    continue;
+                if (!entry.address || entry.address === '0.0.0.0')
+                    continue;
+                return entry.address;
+            }
+        }
+        const hostname = os.hostname().trim();
+        return hostname || '127.0.0.1';
+    }
+    isLocalBridgeNode(nodeId) {
+        if (!nodeId)
+            return false;
+        if (nodeId === 'local-node-1')
+            return true;
+        const node = this.nodeRegistry?.getNode(nodeId);
+        const hostname = node?.hostname?.trim();
+        if (!hostname)
+            return false;
+        return hostname === os.hostname() || hostname === os.hostname().split('.')[0];
+    }
+    isLoopbackBridgeUrl(rawUrl) {
+        try {
+            const parsed = new URL(rawUrl);
+            const host = parsed.hostname.toLowerCase();
+            return host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '[::1]';
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function parseEnvVars(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+function joinContextBlocks(parts) {
+    const visibleParts = parts
+        .map((part) => part?.trim() ?? '')
+        .filter(Boolean);
+    return visibleParts.join('\n\n');
+}
+function stripReplyContract(promptText) {
+    const normalized = promptText.trimStart();
+    if (!normalized.startsWith('[Reply contract]'))
+        return promptText;
+    const splitIndex = normalized.indexOf('\n\n');
+    return splitIndex >= 0 ? normalized.slice(splitIndex + 2) : normalized;
+}
+function normalizeComparableReplayText(value) {
+    return (value ?? '').replace(/\s+/g, ' ').trim();
+}
+function detectTaskHandoffPromptKind(promptText) {
+    if (promptText.includes('[DM Task Thread Handoff]'))
+        return 'dm';
+    if (promptText.includes('[Reminder Task Thread Handoff]'))
+        return 'dm';
+    if (promptText.includes('[Channel Task Thread Handoff]'))
+        return 'channel';
+    return null;
+}
+function extractTaskLabel(promptText) {
+    const match = /(?:^|\n)Task:\s*(.+)$/m.exec(promptText);
+    return match?.[1]?.trim() || null;
+}
+function findFinalRulesSectionStart(promptText) {
+    const idx = promptText.lastIndexOf('\n\nRules:\n');
+    return idx >= 0 ? idx : null;
+}
+function findTriggeredMetadataSectionStart(promptText, rulesStart) {
+    const marker = '\n\n[Triggered message metadata]\n';
+    const upperBound = rulesStart ?? promptText.length;
+    let searchFrom = upperBound;
+    while (searchFrom >= 0) {
+        const idx = promptText.lastIndexOf(marker, searchFrom);
+        if (idx < 0)
+            return null;
+        const section = promptText.slice(idx + 2, upperBound).trim();
+        if (/^\[Triggered message metadata\]\n/.test(section)
+            && /\ntarget: /.test(section)
+            && /\nsender: /.test(section)
+            && /\n\n\[Triggered message body\]\n/.test(section)) {
+            return idx;
+        }
+        searchFrom = idx - 1;
+    }
+    return null;
+}
+function isExactTaskAttachmentSection(section) {
+    const lines = section.trim().split('\n');
+    if (lines.length < 3)
+        return false;
+    const header = lines[0];
+    if (header !== '[Task attachment]' && header !== '[Task attachments]')
+        return false;
+    const attachmentIds = [];
+    let index = 1;
+    while (index < lines.length && lines[index].startsWith('attachment_id: ')) {
+        const attachmentId = lines[index].slice('attachment_id: '.length).trim();
+        if (!/^[A-Fa-f0-9-]{36}$/.test(attachmentId))
+            return false;
+        attachmentIds.push(attachmentId);
+        index += 1;
+    }
+    if (attachmentIds.length === 0 || index !== lines.length - 1)
+        return false;
+    const attachmentKinds = ['image', 'file'];
+    for (const attachmentKind of attachmentKinds) {
+        const plural = attachmentIds.length > 1 ? 's' : '';
+        const expectedPlaceholderLine = `Use bigbang attachment view --attachment-id "<one of the IDs above>" to inspect the attached ${attachmentKind}${plural} before acting on this task.`;
+        if (lines[index] === expectedPlaceholderLine)
+            return true;
+        const legacyPlaceholderLine = `Use view_file(attachment_id="<one of the IDs above>") to inspect the attached ${attachmentKind}${plural} before acting on this task.`;
+        if (lines[index] === legacyPlaceholderLine)
+            return true;
+    }
+    if (attachmentIds.length !== 1)
+        return false;
+    return attachmentKinds.some((attachmentKind) => (lines[index] === `Use bigbang attachment view --attachment-id "${attachmentIds[0]}" to inspect the attached ${attachmentKind} before acting on this task.`
+        || lines[index] === `Use view_file(attachment_id="${attachmentIds[0]}") to inspect the attached ${attachmentKind} before acting on this task.`));
+}
+function findTaskAttachmentSectionStart(promptText, sectionEnd) {
+    if (sectionEnd == null)
+        return null;
+    const marker = '\n\n[Task attachment';
+    let searchFrom = sectionEnd;
+    while (searchFrom >= 0) {
+        const idx = promptText.lastIndexOf(marker, searchFrom);
+        if (idx < 0)
+            return null;
+        if (idx >= sectionEnd) {
+            searchFrom = idx - 1;
+            continue;
+        }
+        const section = promptText.slice(idx + 2, sectionEnd).trim();
+        if (isExactTaskAttachmentSection(section)) {
+            return idx;
+        }
+        searchFrom = idx - 1;
+    }
+    return null;
+}
+function extractTaskBriefSection(promptText, kind) {
+    const marker = 'Task brief / goal / done criteria:\n';
+    const start = promptText.indexOf(marker);
+    if (start < 0)
+        return null;
+    const contentStart = start + marker.length;
+    const rulesStart = findFinalRulesSectionStart(promptText);
+    const triggeredStart = kind === 'dm' ? findTriggeredMetadataSectionStart(promptText, rulesStart) : null;
+    const attachmentStart = kind === 'dm'
+        ? findTaskAttachmentSectionStart(promptText, triggeredStart ?? rulesStart)
+        : null;
+    const stopCandidates = [
+        attachmentStart,
+        triggeredStart,
+        rulesStart,
+    ].filter((idx) => idx != null && idx >= contentStart);
+    const end = stopCandidates.length > 0 ? Math.min(...stopCandidates) : promptText.length;
+    const body = promptText.slice(contentStart, end).trim();
+    return body || null;
+}
+function extractTaskAttachmentSection(promptText, kind) {
+    if (kind !== 'dm')
+        return null;
+    const rulesStart = findFinalRulesSectionStart(promptText);
+    const triggeredStart = findTriggeredMetadataSectionStart(promptText, rulesStart);
+    const start = findTaskAttachmentSectionStart(promptText, triggeredStart ?? rulesStart);
+    if (start == null)
+        return null;
+    const sectionEnd = triggeredStart ?? rulesStart ?? promptText.length;
+    const section = promptText.slice(start + 2, sectionEnd).trim();
+    return section || null;
+}
+function extractTriggeredMessageBody(promptText) {
+    const marker = '[Triggered message body]\n';
+    const start = promptText.indexOf(marker);
+    if (start < 0)
+        return null;
+    const remainder = promptText.slice(start + marker.length);
+    // DM task handoff prompts append a Rules block after the original trigger text.
+    // Keep ordinary user messages intact even if they literally contain "Rules:".
+    const rulesIndex = detectTaskHandoffPromptKind(promptText) === 'dm'
+        ? remainder.lastIndexOf('\n\nRules:\n')
+        : -1;
+    const body = (rulesIndex >= 0 ? remainder.slice(0, rulesIndex) : remainder).trim();
+    return body || null;
+}
+function buildTaskHandoffReplayUserText(promptText) {
+    const kind = detectTaskHandoffPromptKind(promptText);
+    if (!kind)
+        return null;
+    const triggerBody = extractTriggeredMessageBody(promptText);
+    const taskBrief = extractTaskBriefSection(promptText, kind);
+    const attachmentSection = extractTaskAttachmentSection(promptText, kind);
+    const taskLabel = extractTaskLabel(promptText);
+    if (!taskBrief && !attachmentSection && !taskLabel)
+        return triggerBody;
+    const sameBriefAsTrigger = taskBrief
+        && triggerBody
+        && normalizeComparableReplayText(taskBrief) === normalizeComparableReplayText(triggerBody);
+    if (sameBriefAsTrigger) {
+        return attachmentSection
+            ? [triggerBody, attachmentSection].filter(Boolean).join('\n\n')
+            : triggerBody;
+    }
+    const parts = [];
+    if (!taskBrief && !triggerBody && taskLabel) {
+        parts.push(`Task bootstrap: ${taskLabel}`);
+    }
+    if (taskBrief)
+        parts.push(`Task brief / goal / done criteria:\n${taskBrief}`);
+    if (attachmentSection)
+        parts.push(attachmentSection);
+    if (triggerBody)
+        parts.push(`Original trigger:\n${triggerBody}`);
+    return parts.length > 0 ? parts.join('\n\n') : null;
+}
+function normalizeReplayUserText(promptText) {
+    const stripped = stripReplyContract(promptText).trim();
+    return buildTaskHandoffReplayUserText(stripped) ?? extractTriggeredMessageBody(stripped) ?? stripped;
+}
+function getConversationAgentName(db, conversationId) {
+    const row = db.prepare(`SELECT a.name as agentName
+     FROM conversations c
+     LEFT JOIN agents a ON a.agent_id = c.agent_id
+     WHERE c.id = ?`).get(conversationId);
+    return row?.agentName?.trim() || null;
+}
+function trimReplayBlocksAgainstRecentMessages(replayBlocks, recentMessages) {
+    if (!recentMessages?.length || replayBlocks.length === 0)
+        return replayBlocks;
+    const recentReplayBlocks = recentMessages
+        .map(formatReplayBlockForRecentMessage)
+        .filter((block) => Boolean(block));
+    if (recentReplayBlocks.length === 0)
+        return replayBlocks;
+    let replayIndex = replayBlocks.length - 1;
+    let recentIndex = recentReplayBlocks.length - 1;
+    let matchedCount = 0;
+    while (replayIndex >= 0 && recentIndex >= 0) {
+        const replayBlock = replayBlocks[replayIndex];
+        const recentBlock = recentReplayBlocks[recentIndex];
+        if (replayBlock.speaker === recentBlock.speaker
+            && replayBlock.comparableText === recentBlock.comparableText) {
+            matchedCount += 1;
+            replayIndex -= 1;
+            recentIndex -= 1;
+            continue;
+        }
+        recentIndex -= 1;
+    }
+    if (matchedCount <= 0)
+        return replayBlocks;
+    return replayBlocks.slice(0, replayBlocks.length - matchedCount);
+}
+function formatReplayBlockForRecentMessage(message) {
+    const content = sanitizePromptHistoryContent(message.content, message.senderType);
+    if (!content)
+        return null;
+    return {
+        speaker: message.senderType === 'agent' ? 'agent' : 'user',
+        comparableText: normalizeComparableReplayText(content),
+    };
+}
+function serializeReplayOverlapRecentMessages(messages) {
+    if (!messages?.length)
+        return null;
+    return JSON.stringify(messages);
+}
+function parseReplayOverlapRecentMessages(raw) {
+    if (!raw?.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return undefined;
+        return parsed.filter(isActivationContextMessage);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isActivationContextMessage(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return typeof row.messageId === 'string'
+        && typeof row.seq === 'number'
+        && typeof row.target === 'string'
+        && typeof row.senderName === 'string'
+        && (row.senderType === 'user' || row.senderType === 'agent')
+        && typeof row.content === 'string'
+        && typeof row.createdAt === 'number';
+}
+function createReplayRenderableBlock(params) {
+    const text = params.text.trim();
+    if (!text)
+        return null;
+    return {
+        speaker: params.speaker,
+        comparableText: normalizeComparableReplayText(text),
+        renderLabel: params.renderLabel,
+        text,
+    };
+}
+function renderReplayBlock(block) {
+    return `${block.renderLabel}: ${block.text}`;
+}
+function composePromptContextTexts(params) {
+    const dedupedContextSections = dedupePromptContextSections(params.contextSections);
+    const contextSeenText = new Set(dedupedContextSections.map((section) => section.text));
+    const dedupedResumeSections = [];
+    const resumeSeenText = new Set();
+    for (const section of normalizePromptContextSections(params.resumeSections)) {
+        if (resumeSeenText.has(section.text))
+            continue;
+        if (contextSeenText.has(section.text))
+            continue;
+        if (section.kind === 'active_project'
+            && dedupedContextSections.some((contextSection) => contextSection.kind === 'active_project')) {
+            continue;
+        }
+        resumeSeenText.add(section.text);
+        dedupedResumeSections.push(section);
+    }
+    return {
+        contextText: renderPromptContextSections(dedupedContextSections),
+        resumeContextText: renderPromptContextSections(dedupedResumeSections),
+        hasVisibleRecentWindow: [...dedupedContextSections, ...dedupedResumeSections]
+            .some((section) => EXACT_TARGET_HISTORY_SECTION_KINDS.has(section.kind)),
+    };
+}
+function stripExactTargetHistorySections(sections) {
+    if (!sections?.length)
+        return undefined;
+    const stripped = sections.filter((section) => !EXACT_TARGET_HISTORY_SECTION_KINDS.has(section.kind));
+    return stripped.length > 0 ? stripped : undefined;
+}
+function extractExactTargetHistorySections(sections) {
+    return (sections ?? []).filter((section) => EXACT_TARGET_HISTORY_SECTION_KINDS.has(section.kind));
+}
+function splitExactTargetHistorySections(sections) {
+    const exact = [];
+    const nonExact = [];
+    for (const section of sections ?? []) {
+        if (EXACT_TARGET_HISTORY_SECTION_KINDS.has(section.kind)) {
+            exact.push(section);
+        }
+        else {
+            nonExact.push(section);
+        }
+    }
+    return { exact, nonExact };
+}
+function shouldKeepResumeOnlyActivationSectionLive(section) {
+    if (EXACT_TARGET_HISTORY_SECTION_KINDS.has(section.kind))
+        return false;
+    return ![
+        'workspace_memory_reminder',
+        'bound_task_dm_thread',
+        'dm_context_snapshot',
+        'dm_active_task_threads',
+        'dm_active_task_thread_hint',
+        'continuity',
+    ].includes(section.kind);
+}
+function splitResumeOnlyActivationSections(sections, options) {
+    const live = [];
+    const resume = [];
+    for (const section of sections ?? []) {
+        if (shouldKeepResumeOnlyActivationSectionLive(section)
+            || (options?.includeExactTargetHistory === true && EXACT_TARGET_HISTORY_SECTION_KINDS.has(section.kind))) {
+            live.push(section);
+        }
+        else {
+            resume.push(section);
+        }
+    }
+    return { live, resume };
+}
+function stripSurfaceSystemStatusSections(sections) {
+    if (!sections?.length)
+        return undefined;
+    const stripped = sections.filter((section) => section.kind !== 'surface_system_status');
+    return stripped.length > 0 ? stripped : undefined;
+}
+function stripWorkspaceMemoryReminderSections(sections, suppressWorkspaceMemoryReminder) {
+    if (!sections?.length)
+        return undefined;
+    if (!suppressWorkspaceMemoryReminder)
+        return sections;
+    const stripped = sections.filter((section) => section.kind !== 'workspace_memory_reminder');
+    return stripped.length > 0 ? stripped : undefined;
+}
+function shouldKeepIncomingPromptContextSection(section, options) {
+    if (section.kind === 'surface_system_status')
+        return false;
+    if (section.kind === 'reminder_guidance'
+        || section.kind === 'ui_panel_guidance'
+        || section.kind === 'workspace_tool_guidance'
+        || section.kind === 'library_document_guidance') {
+        return false;
+    }
+    if (options?.suppressWorkspaceMemoryReminder === true && section.kind === 'workspace_memory_reminder')
+        return false;
+    return true;
+}
+function stripSurfaceSystemStatusText(text) {
+    const normalizedText = text?.trim();
+    if (!normalizedText)
+        return undefined;
+    const firstLine = normalizedText.split('\n', 1)[0]?.trim();
+    if (firstLine === '[Recent messages on this exact target]'
+        || firstLine === '[History cursor]'
+        || firstLine === '[Recent summary]'
+        || firstLine === '[Unread summary]'
+        || firstLine === '[Inbox]') {
+        return normalizedText;
+    }
+    return normalizedText
+        .split(/\n{2,}/u)
+        .map((part) => part.trim())
+        .filter((part) => part && part.split('\n', 1)[0]?.trim() !== '[System status messages on this surface]')
+        .join('\n\n')
+        .trim() || undefined;
+}
+function normalizePromptContextSections(sections) {
+    return sections
+        .map((section) => {
+        const normalizedText = section.text.trim();
+        return normalizedText
+            ? {
+                kind: section.kind,
+                text: normalizedText,
+            }
+            : null;
+    })
+        .filter((section) => Boolean(section));
+}
+function dedupePromptContextSections(sections) {
+    const dedupedSections = [];
+    const seenTexts = new Set();
+    for (const section of normalizePromptContextSections(sections)) {
+        if (seenTexts.has(section.text))
+            continue;
+        seenTexts.add(section.text);
+        dedupedSections.push(section);
+    }
+    return dedupedSections;
+}
+function escapeMcpHintString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+export function adaptPromptTextForAgentSurface(promptText, agentSurfaceMode) {
+    if (agentSurfaceMode !== 'mcp')
+        return promptText;
+    return promptText
+        .replace(/bigbang message read --channel "([^"]+)" --around "([^"]+)" --limit (\d+) --include-root/g, 'read_history(channel="$1", around="$2", limit=$3, include_root=true)')
+        .replace(/bigbang message read --channel "([^"]+)" --around "([^"]+)" --limit (\d+)/g, 'read_history(channel="$1", around="$2", limit=$3)')
+        .replace(/bigbang message read --channel "([^"]+)" --around (\d+) --limit (\d+) --include-root/g, 'read_history(channel="$1", around=$2, limit=$3, include_root=true)')
+        .replace(/bigbang message read --channel "([^"]+)" --around (\d+) --limit (\d+)/g, 'read_history(channel="$1", around=$2, limit=$3)')
+        .replace(/bigbang message read --channel "([^"]+)" --after (\d+) --limit (\d+)/g, 'read_history(channel="$1", after=$2, limit=$3)')
+        .replace(/bigbang message read --channel "([^"]+)" --before (\d+) --limit (\d+)/g, 'read_history(channel="$1", before=$2, limit=$3)')
+        .replace(/bigbang message read --channel "([^"]+)" --around "([^"]+)"/g, 'read_history(channel="$1", around="$2")')
+        .replace(/bigbang message read --channel "([^"]+)" --around (\d+)/g, 'read_history(channel="$1", around=$2)')
+        .replace(/bigbang message read --channel "([^"]+)" --after (\d+)/g, 'read_history(channel="$1", after=$2)')
+        .replace(/bigbang message read --channel "([^"]+)" --before (\d+)/g, 'read_history(channel="$1", before=$2)')
+        .replace(/bigbang attachment view --attachment-id "([^"]+)"/g, 'view_file(attachment_id="$1")')
+        .replace(/bigbang handoff create <<'EOF'\s*\n(\{[^\n]+\})\nEOF/g, (_match, payload) => {
+        try {
+            const parsed = JSON.parse(payload);
+            const target = typeof parsed.target === 'string' ? parsed.target : '';
+            const mode = parsed.mode === 'delegate_only' || parsed.mode === 'continue_there' || parsed.mode === 'collab'
+                ? parsed.mode
+                : 'delegate_only';
+            const goal = typeof parsed.goal === 'string' && parsed.goal.trim().length > 0
+                ? parsed.goal
+                : `Continue this work on ${target}.`;
+            if (!target)
+                return _match;
+            return `handoff_to_target(target="${escapeMcpHintString(target)}", mode="${mode}", goal="${escapeMcpHintString(goal)}")`;
+        }
+        catch {
+            return _match;
+        }
+    })
+        .replace(/bigbang handoff create --target "([^"]+)"/g, (_match, target) => (`handoff_to_target(target="${escapeMcpHintString(target)}", mode="collab", goal="${escapeMcpHintString(`Continue this work on ${target}.`)}")`))
+        .replace(/bigbang task update --channel "([^"]+)" --number (\d+) --status ([a-z_]+)/g, 'update_task_status(channel="$1", task_number=$2, status="$3")')
+        .replace(/bigbang panel patch --panel-id ([^\s.,)]+)/g, 'patch_panel(panel_id=$1)')
+        .replace(/bigbang panel read-rows --panel-id ([^\s.,)]+)/g, 'read_panel_rows(panel_id=$1)')
+        .replace(/`bigbang message send --kind progress`/g, '`mcp__chat__send_message(content="...", kind="progress")`')
+        .replace(/`bigbang message send --kind final`/g, '`mcp__chat__send_message(content="...", kind="final")`')
+        .replace(/`bigbang message send`/g, '`mcp__chat__send_message`')
+        .replace(/\bbigbang inbox check\b/g, 'check_messages()')
+        .replace(/\bbigbang message check\b/g, 'check_messages()')
+        .replace(/\bbigbang message read\b/g, 'read_history')
+        .replace(/\bbigbang task list\b/g, 'list_tasks()')
+        .replace(/\bbigbang task my\b/g, 'list_my_tasks()')
+        .replace(/\bbigbang task claim\b/g, 'claim_tasks(...)')
+        .replace(/\bbigbang task create\b/g, 'create_tasks(...)')
+        .replace(/\bbigbang task update\b/g, 'update_task_status(...)')
+        .replace(/\bbigbang task history\b/g, 'get_task_history(...)')
+        .replace(/\bbigbang context bundle --format json\b/g, 'mcp__chat__get_relevant_context_bundle()')
+        .replace(/\bbigbang context bundle\b/g, 'get_relevant_context_bundle')
+        .replace(/\bbigbang conversation list\b/g, 'list_my_conversations()')
+        .replace(/\bbigbang conversation summary\b/g, 'get_conversation_summary')
+        .replace(/\bbigbang self state\b/g, 'get_self_state')
+        .replace(/\bbigbang runtime presence\b/g, 'get_runtime_presence')
+        .replace(/\bbigbang workspace inspect\b/g, 'inspect_workspace')
+        .replace(/\bbigbang tool publish\b/g, 'publish_workspace_tool')
+        .replace(/\bbigbang panel components\b/g, 'list_ui_components')
+        .replace(/\bbigbang panel create\b/g, 'render_panel')
+        .replace(/\bbigbang panel patch\b/g, 'patch_panel')
+        .replace(/\bbigbang panel upsert\b/g, 'upsert_panel(handle=...)')
+        .replace(/\bbigbang panel read-rows\b/g, 'read_panel_rows')
+        .replace(/\bbigbang reminder submit-for-review\b/g, 'submit_reminder_occurrence_for_review')
+        .replace(/Bigbang CLI commands/g, 'MCP tools')
+        .replace(/Bigbang commands/g, 'MCP tools')
+        .replace(/Bigbang/g, 'MCP');
+}
+function prependTurnReplyContract(promptText, today = getCurrentISOWeek(), agentSurfaceMode = 'bigbang') {
+    if (promptText.trimStart().startsWith('[Reply contract]'))
+        return promptText;
+    return `${buildTurnReplyContract(today, agentSurfaceMode)}\n\n${promptText}`;
+}
+function normalizeDispatchAgentSurfaceMode(value, fallback) {
+    if (value === 'bigbang' || value === 'mcp')
+        return value;
+    return fallback;
+}
+function joinSteerPromptParts(...parts) {
+    return parts
+        .map((part) => part?.trim())
+        .filter((part) => Boolean(part))
+        .join('\n\n');
+}
+function buildMinimalDirectFollowupSteerPrompt(promptText) {
+    return `[Triggered message body]\n${promptText}`;
+}
+function getSessionSystemPromptText(db, sessionKey) {
+    const row = db.prepare('SELECT system_prompt_text as systemPromptText FROM sessions WHERE session_key = ?').get(sessionKey);
+    return row?.systemPromptText ?? null;
+}
+function getSessionAcpSessionId(db, sessionKey) {
+    const row = db.prepare('SELECT acp_session_id as acpSessionId FROM sessions WHERE session_key = ?').get(sessionKey);
+    return row?.acpSessionId?.trim() || null;
+}
+function upsertPendingRunDebugInput(db, params) {
+    const now = Date.now();
+    db.prepare(`INSERT INTO run_debug_inputs(
+       run_id, conversation_id, session_key, dispatch_mode, reply_target,
+       system_prompt_text, context_text, prompt_text, dispatched_prompt_text, agent_surface_mode, activation_metadata_json,
+       created_at, updated_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(run_id) DO UPDATE SET
+       conversation_id = excluded.conversation_id,
+       session_key = excluded.session_key,
+       dispatch_mode = excluded.dispatch_mode,
+       reply_target = excluded.reply_target,
+       system_prompt_text = excluded.system_prompt_text,
+       context_text = excluded.context_text,
+       prompt_text = excluded.prompt_text,
+       dispatched_prompt_text = excluded.dispatched_prompt_text,
+       agent_surface_mode = excluded.agent_surface_mode,
+       activation_metadata_json = excluded.activation_metadata_json,
+       updated_at = excluded.updated_at`).run(params.runId, params.conversationId, params.sessionKey, params.dispatchMode, params.replyTarget, params.systemPromptText, params.contextText, params.promptText, params.dispatchedPromptText, params.agentSurfaceMode, params.activationMetadataJson, now, now);
+}
+function patchRunDebugInputForActiveSteer(db, params) {
+    const previous = db.prepare(`SELECT prompt_text as promptText,
+            dispatched_prompt_text as dispatchedPromptText,
+            activation_metadata_json as activationMetadataJson
+       FROM run_debug_inputs
+      WHERE run_id = ?
+      LIMIT 1`).get(params.runId);
+    if (!previous)
+        return null;
+    const activationMetadataJson = serializePromptActivationMetadata(params.activationMetadata);
+    db.prepare(`UPDATE run_debug_inputs
+        SET prompt_text = ?,
+            dispatched_prompt_text = ?,
+            activation_metadata_json = ?,
+            updated_at = ?
+      WHERE run_id = ?`).run(params.promptText, params.dispatchedPromptText, activationMetadataJson, Date.now(), params.runId);
+    return () => {
+        db.prepare(`UPDATE run_debug_inputs
+          SET prompt_text = ?,
+              dispatched_prompt_text = ?,
+              activation_metadata_json = ?,
+              updated_at = ?
+        WHERE run_id = ?`).run(previous.promptText, previous.dispatchedPromptText, previous.activationMetadataJson, Date.now(), params.runId);
+    };
+}
+function sanitizeFileRefs(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return [];
+    const refs = [];
+    const seen = new Set();
+    for (const item of value) {
+        const uri = typeof item?.uri === 'string'
+            ? item.uri.trim()
+            : '';
+        if (!uri || seen.has(uri))
+            continue;
+        seen.add(uri);
+        const mimeType = typeof item?.mimeType === 'string'
+            ? item.mimeType.trim()
+            : '';
+        refs.push({
+            uri,
+            ...(mimeType ? { mimeType } : {}),
+        });
+    }
+    return refs;
+}
+function sanitizeAttachmentIds(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return [];
+    const ids = [];
+    const seen = new Set();
+    for (const item of value) {
+        const raw = typeof item === 'string' ? item.trim() : '';
+        const id = raw.startsWith('attachment:') ? raw.slice('attachment:'.length).trim() : raw;
+        if (!/^[a-f0-9-]{36}$/i.test(id))
+            continue;
+        const normalized = id.toLowerCase();
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        ids.push(normalized);
+    }
+    return ids;
+}
+function parseAttachmentIdsJson(value) {
+    if (!value)
+        return [];
+    try {
+        return sanitizeAttachmentIds(JSON.parse(value));
+    }
+    catch {
+        return [];
+    }
+}
+function sanitizePanelIds(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return [];
+    const ids = [];
+    const seen = new Set();
+    for (const item of value) {
+        const id = typeof item === 'string' ? item.trim() : '';
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        ids.push(id);
+    }
+    return ids;
+}
+function parsePanelIdsJson(value) {
+    if (!value)
+        return [];
+    try {
+        return sanitizePanelIds(JSON.parse(value));
+    }
+    catch {
+        return [];
+    }
+}
+function stringArraysEqual(left, right) {
+    return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function extractPromptAttachmentIds(_promptText, attachments, explicitAttachmentIds = []) {
+    const ids = new Set();
+    for (const id of explicitAttachmentIds) {
+        ids.add(id);
+    }
+    for (const attachment of attachments) {
+        if (!attachment.uri.startsWith('attachment:'))
+            continue;
+        const id = attachment.uri.slice('attachment:'.length).trim();
+        if (/^[a-f0-9-]{36}$/i.test(id)) {
+            ids.add(id.toLowerCase());
+        }
+    }
+    return [...ids];
+}
+function enrichPromptActivationMetadataWithContextSections(options, contextSectionsOverride) {
+    const activationMetadata = options?.activationMetadata
+        ? { ...options.activationMetadata }
+        : undefined;
+    if (contextSectionsOverride && activationMetadata) {
+        delete activationMetadata.promptContextSections;
+    }
+    const attachments = sanitizeFileRefs(options?.attachments);
+    const attachmentIds = sanitizeAttachmentIds(options?.attachmentIds);
+    const runtimeOverrides = normalizePromptRuntimeOverrides(options?.runtimeOverrides ?? activationMetadata?.runtimeOverrides);
+    const slashCommand = normalizePromptSlashCommand(activationMetadata?.slashCommand);
+    const activationSections = contextSectionsOverride
+        ? contextSectionsOverride.activation
+        : options?.activationContextSections;
+    const resumeSections = contextSectionsOverride
+        ? contextSectionsOverride.resume
+        : options?.resumeContextSections;
+    if (!activationSections?.length && !resumeSections?.length && attachments.length === 0 && attachmentIds.length === 0 && !runtimeOverrides && !slashCommand && options?.suppressReplyContract !== true) {
+        return activationMetadata;
+    }
+    return {
+        ...(activationMetadata ?? {}),
+        ...(options?.suppressReplyContract === true ? { suppressReplyContract: true } : {}),
+        ...(runtimeOverrides ? { runtimeOverrides } : {}),
+        ...(slashCommand ? { slashCommand } : {}),
+        ...(attachments.length > 0 ? { attachments } : {}),
+        ...(attachmentIds.length > 0 ? { attachmentIds } : {}),
+        ...(activationSections?.length || resumeSections?.length
+            ? {
+                promptContextSections: {
+                    ...(activationSections?.length ? { activation: activationSections } : {}),
+                    ...(resumeSections?.length ? { resume: resumeSections } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function serializePromptActivationMetadata(metadata) {
+    if (!metadata)
+        return null;
+    const payload = {};
+    const platformRun = normalizePlatformRunMetadata(metadata.platformRun);
+    if (platformRun) {
+        payload.platformRun = platformRun;
+    }
+    if (metadata.mentionSuppression) {
+        const peerMentionedAgentIds = metadata.mentionSuppression.peerMentionedAgentIds
+            .map((agentId) => agentId.trim())
+            .filter(Boolean);
+        if (peerMentionedAgentIds.length > 0) {
+            payload.mentionSuppression = {
+                mode: metadata.mentionSuppression.mode,
+                triggerSeq: metadata.mentionSuppression.triggerSeq,
+                peerMentionedAgentIds,
+            };
+        }
+    }
+    if (metadata.triggerMessage
+        && typeof metadata.triggerMessage.messageId === 'string'
+        && metadata.triggerMessage.messageId.trim()
+        && Number.isFinite(metadata.triggerMessage.seq)
+        && typeof metadata.triggerMessage.target === 'string'
+        && metadata.triggerMessage.target.trim()) {
+        payload.triggerMessage = {
+            messageId: metadata.triggerMessage.messageId.trim(),
+            seq: metadata.triggerMessage.seq,
+            target: metadata.triggerMessage.target.trim(),
+            ...(typeof metadata.triggerMessage.userId === 'string' && metadata.triggerMessage.userId.trim()
+                ? { userId: metadata.triggerMessage.userId.trim() }
+                : {}),
+        };
+    }
+    if (metadata.expectedTermination?.kind === 'dm_handoff_bootstrap'
+        && metadata.expectedTermination.stopReason === 'handoff_bootstrap') {
+        payload.expectedTermination = {
+            kind: 'dm_handoff_bootstrap',
+            stopReason: 'handoff_bootstrap',
+        };
+    }
+    if (metadata.systemFollowup?.kind === 'task_status_reminder'
+        && typeof metadata.systemFollowup.followupId === 'string'
+        && metadata.systemFollowup.followupId.trim()
+        && typeof metadata.systemFollowup.taskId === 'string'
+        && metadata.systemFollowup.taskId.trim()
+        && typeof metadata.systemFollowup.channelId === 'string'
+        && metadata.systemFollowup.channelId.trim()
+        && typeof metadata.systemFollowup.threadRootId === 'string'
+        && metadata.systemFollowup.threadRootId.trim()) {
+        payload.systemFollowup = {
+            kind: 'task_status_reminder',
+            followupId: metadata.systemFollowup.followupId.trim(),
+            taskId: metadata.systemFollowup.taskId.trim(),
+            channelId: metadata.systemFollowup.channelId.trim(),
+            threadRootId: metadata.systemFollowup.threadRootId.trim(),
+            ...(typeof metadata.systemFollowup.delayMs === 'number'
+                && Number.isFinite(metadata.systemFollowup.delayMs)
+                && metadata.systemFollowup.delayMs > 0
+                ? { delayMs: metadata.systemFollowup.delayMs }
+                : {}),
+            ...(typeof metadata.systemFollowup.baselineThreadSeq === 'number'
+                && Number.isFinite(metadata.systemFollowup.baselineThreadSeq)
+                && metadata.systemFollowup.baselineThreadSeq >= 0
+                ? { baselineThreadSeq: metadata.systemFollowup.baselineThreadSeq }
+                : {}),
+        };
+    }
+    if (metadata.taskPeerUpdate
+        && typeof metadata.taskPeerUpdate.taskId === 'string'
+        && metadata.taskPeerUpdate.taskId.trim()
+        && typeof metadata.taskPeerUpdate.channelId === 'string'
+        && metadata.taskPeerUpdate.channelId.trim()
+        && typeof metadata.taskPeerUpdate.threadRootId === 'string'
+        && metadata.taskPeerUpdate.threadRootId.trim()
+        && typeof metadata.taskPeerUpdate.fromAgentId === 'string'
+        && metadata.taskPeerUpdate.fromAgentId.trim()) {
+        payload.taskPeerUpdate = {
+            taskId: metadata.taskPeerUpdate.taskId.trim(),
+            channelId: metadata.taskPeerUpdate.channelId.trim(),
+            threadRootId: metadata.taskPeerUpdate.threadRootId.trim(),
+            fromAgentId: metadata.taskPeerUpdate.fromAgentId.trim(),
+            ...(typeof metadata.taskPeerUpdate.firstMessageId === 'string' && metadata.taskPeerUpdate.firstMessageId.trim()
+                ? { firstMessageId: metadata.taskPeerUpdate.firstMessageId.trim() }
+                : {}),
+            ...(typeof metadata.taskPeerUpdate.lastMessageId === 'string' && metadata.taskPeerUpdate.lastMessageId.trim()
+                ? { lastMessageId: metadata.taskPeerUpdate.lastMessageId.trim() }
+                : {}),
+            ...(typeof metadata.taskPeerUpdate.messageCount === 'number'
+                && Number.isFinite(metadata.taskPeerUpdate.messageCount)
+                && metadata.taskPeerUpdate.messageCount > 0
+                ? { messageCount: metadata.taskPeerUpdate.messageCount }
+                : {}),
+        };
+    }
+    if (metadata.handoffDispatch
+        && typeof metadata.handoffDispatch.correlationId === 'string'
+        && metadata.handoffDispatch.correlationId.trim()
+        && typeof metadata.handoffDispatch.sourceConversationId === 'string'
+        && metadata.handoffDispatch.sourceConversationId.trim()
+        && typeof metadata.handoffDispatch.targetConversationId === 'string'
+        && metadata.handoffDispatch.targetConversationId.trim()) {
+        payload.handoffDispatch = {
+            correlationId: metadata.handoffDispatch.correlationId.trim(),
+            sourceConversationId: metadata.handoffDispatch.sourceConversationId.trim(),
+            targetConversationId: metadata.handoffDispatch.targetConversationId.trim(),
+        };
+    }
+    if (metadata.peerInboxAggregate
+        && typeof metadata.peerInboxAggregate.aggregateId === 'string'
+        && metadata.peerInboxAggregate.aggregateId.trim()
+        && Array.isArray(metadata.peerInboxAggregate.itemMessageIds)
+        && Number.isFinite(metadata.peerInboxAggregate.firstSeq)
+        && Number.isFinite(metadata.peerInboxAggregate.lastSeq)
+        && Number.isFinite(metadata.peerInboxAggregate.messageCount)
+        && (metadata.peerInboxAggregate.flushPolicy === 'batch' || metadata.peerInboxAggregate.flushPolicy === 'immediate')) {
+        const itemMessageIds = metadata.peerInboxAggregate.itemMessageIds
+            .filter((messageId) => typeof messageId === 'string' && messageId.trim().length > 0)
+            .map((messageId) => messageId.trim());
+        if (itemMessageIds.length > 0) {
+            payload.peerInboxAggregate = {
+                aggregateId: metadata.peerInboxAggregate.aggregateId.trim(),
+                itemMessageIds,
+                firstSeq: metadata.peerInboxAggregate.firstSeq,
+                lastSeq: metadata.peerInboxAggregate.lastSeq,
+                messageCount: metadata.peerInboxAggregate.messageCount,
+                flushPolicy: metadata.peerInboxAggregate.flushPolicy,
+                ...(metadata.peerInboxAggregate.closeSummary === true ? { closeSummary: true } : {}),
+            };
+        }
+    }
+    if (metadata.sharedCollaboration
+        && typeof metadata.sharedCollaboration.capsuleId === 'string'
+        && metadata.sharedCollaboration.capsuleId.trim()
+        && typeof metadata.sharedCollaboration.channelId === 'string'
+        && metadata.sharedCollaboration.channelId.trim()
+        && typeof metadata.sharedCollaboration.threadRootId === 'string'
+        && typeof metadata.sharedCollaboration.originMessageId === 'string'
+        && metadata.sharedCollaboration.originMessageId.trim()
+        && Number.isFinite(metadata.sharedCollaboration.originSeq)
+        && Number.isFinite(metadata.sharedCollaboration.contributionCount)
+        && Number.isFinite(metadata.sharedCollaboration.maxVisibleAgentMessages)) {
+        payload.sharedCollaboration = {
+            capsuleId: metadata.sharedCollaboration.capsuleId.trim(),
+            channelId: metadata.sharedCollaboration.channelId.trim(),
+            threadRootId: metadata.sharedCollaboration.threadRootId.trim(),
+            originMessageId: metadata.sharedCollaboration.originMessageId.trim(),
+            originSeq: Math.max(0, Math.floor(metadata.sharedCollaboration.originSeq)),
+            contributionCount: Math.max(0, Math.floor(metadata.sharedCollaboration.contributionCount)),
+            maxVisibleAgentMessages: Math.max(1, Math.floor(metadata.sharedCollaboration.maxVisibleAgentMessages)),
+        };
+    }
+    const ownerAwareness = normalizeOwnerAwarenessMetadata(metadata.ownerAwareness);
+    if (ownerAwareness) {
+        payload.ownerAwareness = ownerAwareness;
+    }
+    const promptContextSections = serializePromptContextSectionsMetadata(metadata.promptContextSections);
+    if (promptContextSections) {
+        payload.promptContextSections = promptContextSections;
+    }
+    if (metadata.activeSteerIncludeExactTargetHistory === true) {
+        payload.activeSteerIncludeExactTargetHistory = true;
+    }
+    if (metadata.liveContextIncludeExactTargetHistory === true) {
+        payload.liveContextIncludeExactTargetHistory = true;
+    }
+    const runtimeOverrides = normalizePromptRuntimeOverrides(metadata.runtimeOverrides);
+    if (runtimeOverrides) {
+        payload.runtimeOverrides = runtimeOverrides;
+    }
+    const attachments = sanitizeFileRefs(metadata.attachments);
+    if (attachments.length > 0) {
+        payload.attachments = attachments;
+    }
+    const attachmentIds = sanitizeAttachmentIds(metadata.attachmentIds);
+    if (attachmentIds.length > 0) {
+        payload.attachmentIds = attachmentIds;
+    }
+    const slashCommand = normalizePromptSlashCommand(metadata.slashCommand);
+    if (slashCommand) {
+        payload.slashCommand = slashCommand;
+    }
+    if (metadata.suppressReplyContract === true) {
+        payload.suppressReplyContract = true;
+    }
+    if (!payload.platformRun && !payload.mentionSuppression && !payload.triggerMessage && !payload.expectedTermination && !payload.systemFollowup && !payload.taskPeerUpdate && !payload.peerInboxAggregate && !payload.sharedCollaboration && !payload.ownerAwareness && !payload.activeSteerIncludeExactTargetHistory && !payload.liveContextIncludeExactTargetHistory && !payload.handoffDispatch && !payload.promptContextSections && !payload.runtimeOverrides && !payload.attachments && !payload.attachmentIds && !payload.slashCommand && !payload.suppressReplyContract)
+        return null;
+    return JSON.stringify(payload);
+}
+function normalizePromptRuntimeOverrides(value) {
+    if (!value)
+        return undefined;
+    const planMode = value.planMode === true || value.codexMode === 'plan';
+    const codexMode = value.codexMode === 'default' || value.codexMode === 'plan'
+        ? value.codexMode
+        : null;
+    if (!planMode && !codexMode)
+        return undefined;
+    return {
+        ...(planMode ? { planMode: true } : {}),
+        ...(codexMode ? { codexMode } : {}),
+    };
+}
+function parsePromptActivationMetadata(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        const result = {};
+        const platformRun = normalizePlatformRunMetadata(parsed?.platformRun);
+        if (platformRun) {
+            result.platformRun = platformRun;
+        }
+        const mentionSuppression = parsed?.mentionSuppression;
+        if (mentionSuppression) {
+            const peerMentionedAgentIds = Array.isArray(mentionSuppression.peerMentionedAgentIds)
+                ? mentionSuppression.peerMentionedAgentIds.filter((agentId) => typeof agentId === 'string' && agentId.trim().length > 0)
+                : [];
+            if (mentionSuppression.mode === 'root_user_multi_mention' && Number.isFinite(mentionSuppression.triggerSeq) && peerMentionedAgentIds.length > 0) {
+                result.mentionSuppression = {
+                    mode: 'root_user_multi_mention',
+                    triggerSeq: mentionSuppression.triggerSeq,
+                    peerMentionedAgentIds,
+                };
+            }
+        }
+        const triggerMessage = parsed?.triggerMessage;
+        if (triggerMessage
+            && typeof triggerMessage.messageId === 'string'
+            && triggerMessage.messageId.trim()
+            && Number.isFinite(triggerMessage.seq)
+            && typeof triggerMessage.target === 'string'
+            && triggerMessage.target.trim()) {
+            result.triggerMessage = {
+                messageId: triggerMessage.messageId.trim(),
+                seq: triggerMessage.seq,
+                target: triggerMessage.target.trim(),
+                ...(typeof triggerMessage.userId === 'string' && triggerMessage.userId.trim()
+                    ? { userId: triggerMessage.userId.trim() }
+                    : {}),
+            };
+        }
+        if (parsed?.expectedTermination?.kind === 'dm_handoff_bootstrap'
+            && parsed.expectedTermination.stopReason === 'handoff_bootstrap') {
+            result.expectedTermination = {
+                kind: 'dm_handoff_bootstrap',
+                stopReason: 'handoff_bootstrap',
+            };
+        }
+        if (parsed?.systemFollowup?.kind === 'task_status_reminder'
+            && 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()) {
+            result.systemFollowup = {
+                kind: 'task_status_reminder',
+                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 }
+                    : {}),
+            };
+        }
+        if (parsed?.taskPeerUpdate
+            && typeof parsed.taskPeerUpdate.taskId === 'string'
+            && parsed.taskPeerUpdate.taskId.trim()
+            && typeof parsed.taskPeerUpdate.channelId === 'string'
+            && parsed.taskPeerUpdate.channelId.trim()
+            && typeof parsed.taskPeerUpdate.threadRootId === 'string'
+            && parsed.taskPeerUpdate.threadRootId.trim()
+            && typeof parsed.taskPeerUpdate.fromAgentId === 'string'
+            && parsed.taskPeerUpdate.fromAgentId.trim()) {
+            result.taskPeerUpdate = {
+                taskId: parsed.taskPeerUpdate.taskId.trim(),
+                channelId: parsed.taskPeerUpdate.channelId.trim(),
+                threadRootId: parsed.taskPeerUpdate.threadRootId.trim(),
+                fromAgentId: parsed.taskPeerUpdate.fromAgentId.trim(),
+                ...(typeof parsed.taskPeerUpdate.firstMessageId === 'string' && parsed.taskPeerUpdate.firstMessageId.trim()
+                    ? { firstMessageId: parsed.taskPeerUpdate.firstMessageId.trim() }
+                    : {}),
+                ...(typeof parsed.taskPeerUpdate.lastMessageId === 'string' && parsed.taskPeerUpdate.lastMessageId.trim()
+                    ? { lastMessageId: parsed.taskPeerUpdate.lastMessageId.trim() }
+                    : {}),
+                ...(typeof parsed.taskPeerUpdate.messageCount === 'number'
+                    && Number.isFinite(parsed.taskPeerUpdate.messageCount)
+                    && parsed.taskPeerUpdate.messageCount > 0
+                    ? { messageCount: parsed.taskPeerUpdate.messageCount }
+                    : {}),
+            };
+        }
+        if (parsed?.handoffDispatch
+            && typeof parsed.handoffDispatch.correlationId === 'string'
+            && parsed.handoffDispatch.correlationId.trim()
+            && typeof parsed.handoffDispatch.sourceConversationId === 'string'
+            && parsed.handoffDispatch.sourceConversationId.trim()
+            && typeof parsed.handoffDispatch.targetConversationId === 'string'
+            && parsed.handoffDispatch.targetConversationId.trim()) {
+            result.handoffDispatch = {
+                correlationId: parsed.handoffDispatch.correlationId.trim(),
+                sourceConversationId: parsed.handoffDispatch.sourceConversationId.trim(),
+                targetConversationId: parsed.handoffDispatch.targetConversationId.trim(),
+            };
+        }
+        if (parsed?.peerInboxAggregate
+            && typeof parsed.peerInboxAggregate.aggregateId === 'string'
+            && parsed.peerInboxAggregate.aggregateId.trim()
+            && Array.isArray(parsed.peerInboxAggregate.itemMessageIds)
+            && Number.isFinite(parsed.peerInboxAggregate.firstSeq)
+            && Number.isFinite(parsed.peerInboxAggregate.lastSeq)
+            && Number.isFinite(parsed.peerInboxAggregate.messageCount)
+            && (parsed.peerInboxAggregate.flushPolicy === 'batch' || parsed.peerInboxAggregate.flushPolicy === 'immediate')) {
+            const itemMessageIds = parsed.peerInboxAggregate.itemMessageIds
+                .filter((messageId) => typeof messageId === 'string' && messageId.trim().length > 0)
+                .map((messageId) => messageId.trim());
+            if (itemMessageIds.length > 0) {
+                result.peerInboxAggregate = {
+                    aggregateId: parsed.peerInboxAggregate.aggregateId.trim(),
+                    itemMessageIds,
+                    firstSeq: parsed.peerInboxAggregate.firstSeq,
+                    lastSeq: parsed.peerInboxAggregate.lastSeq,
+                    messageCount: parsed.peerInboxAggregate.messageCount,
+                    flushPolicy: parsed.peerInboxAggregate.flushPolicy,
+                    ...(parsed.peerInboxAggregate.closeSummary === true ? { closeSummary: true } : {}),
+                };
+            }
+        }
+        if (parsed?.sharedCollaboration
+            && typeof parsed.sharedCollaboration.capsuleId === 'string'
+            && parsed.sharedCollaboration.capsuleId.trim()
+            && typeof parsed.sharedCollaboration.channelId === 'string'
+            && parsed.sharedCollaboration.channelId.trim()
+            && typeof parsed.sharedCollaboration.threadRootId === 'string'
+            && typeof parsed.sharedCollaboration.originMessageId === 'string'
+            && parsed.sharedCollaboration.originMessageId.trim()
+            && Number.isFinite(parsed.sharedCollaboration.originSeq)
+            && Number.isFinite(parsed.sharedCollaboration.contributionCount)
+            && Number.isFinite(parsed.sharedCollaboration.maxVisibleAgentMessages)) {
+            result.sharedCollaboration = {
+                capsuleId: parsed.sharedCollaboration.capsuleId.trim(),
+                channelId: parsed.sharedCollaboration.channelId.trim(),
+                threadRootId: parsed.sharedCollaboration.threadRootId.trim(),
+                originMessageId: parsed.sharedCollaboration.originMessageId.trim(),
+                originSeq: Math.max(0, Math.floor(parsed.sharedCollaboration.originSeq)),
+                contributionCount: Math.max(0, Math.floor(parsed.sharedCollaboration.contributionCount)),
+                maxVisibleAgentMessages: Math.max(1, Math.floor(parsed.sharedCollaboration.maxVisibleAgentMessages)),
+            };
+        }
+        const ownerAwareness = normalizeOwnerAwarenessMetadata(parsed?.ownerAwareness);
+        if (ownerAwareness) {
+            result.ownerAwareness = ownerAwareness;
+        }
+        const promptContextSections = parsePromptContextSectionsMetadata(parsed?.promptContextSections);
+        if (promptContextSections) {
+            result.promptContextSections = promptContextSections;
+        }
+        if (parsed?.activeSteerIncludeExactTargetHistory === true) {
+            result.activeSteerIncludeExactTargetHistory = true;
+        }
+        if (parsed?.liveContextIncludeExactTargetHistory === true) {
+            result.liveContextIncludeExactTargetHistory = true;
+        }
+        const runtimeOverrides = normalizePromptRuntimeOverrides(parsed?.runtimeOverrides);
+        if (runtimeOverrides) {
+            result.runtimeOverrides = runtimeOverrides;
+        }
+        const attachments = sanitizeFileRefs(parsed?.attachments);
+        if (attachments.length > 0) {
+            result.attachments = attachments;
+        }
+        const attachmentIds = sanitizeAttachmentIds(parsed?.attachmentIds);
+        if (attachmentIds.length > 0) {
+            result.attachmentIds = attachmentIds;
+        }
+        const slashCommand = normalizePromptSlashCommand(parsed?.slashCommand);
+        if (slashCommand) {
+            result.slashCommand = slashCommand;
+        }
+        if (parsed?.suppressReplyContract === true) {
+            result.suppressReplyContract = true;
+        }
+        return result.platformRun || result.mentionSuppression || result.triggerMessage || result.expectedTermination || result.systemFollowup || result.taskPeerUpdate || result.peerInboxAggregate || result.sharedCollaboration || result.ownerAwareness || result.activeSteerIncludeExactTargetHistory || result.liveContextIncludeExactTargetHistory || result.handoffDispatch || result.promptContextSections || result.runtimeOverrides || result.attachments || result.attachmentIds || result.slashCommand || result.suppressReplyContract
+            ? result
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizePromptSlashCommand(value) {
+    if (!value || typeof value.name !== 'string' || typeof value.bodyText !== 'string') {
+        return undefined;
+    }
+    const name = normalizePromptSlashCommandName(value.name);
+    if (name === 'reminder') {
+        const bodyText = value.bodyText.trim();
+        if (!bodyText)
+            return undefined;
+        return { name, bodyText };
+    }
+    if (name === 'document') {
+        return { name, bodyText: value.bodyText.trim() };
+    }
+    if (name === 'panel' || name === 'panel:plan') {
+        const bodyText = value.bodyText.trim();
+        if (!bodyText)
+            return undefined;
+        return { name, bodyText };
+    }
+    if (name === 'tool' || name === 'tool:plan') {
+        const bodyText = value.bodyText.trim();
+        if (!bodyText)
+            return undefined;
+        return { name, bodyText };
+    }
+    return undefined;
+}
+function findPromptAttachmentNoteIndex(promptText) {
+    const fileIdx = promptText.indexOf('\n\n[Attached file');
+    if (fileIdx >= 0)
+        return fileIdx;
+    return promptText.indexOf('\n\n[Attached image');
+}
+function buildDisplayContentOverrideForDirectMessage(params) {
+    const slashCommand = normalizePromptSlashCommand(params.slashCommand);
+    if (!slashCommand)
+        return null;
+    if (slashCommand.name === 'document') {
+        return slashCommand.bodyText || 'Use the document library for this conversation.';
+    }
+    return slashCommand.bodyText;
+}
+function buildDispatchPromptContentForDirectMessage(params) {
+    const overrideDisplayContent = buildDisplayContentOverrideForDirectMessage(params);
+    if (!overrideDisplayContent)
+        return params.promptText;
+    const attachNoteIdx = findPromptAttachmentNoteIndex(params.promptText);
+    if (attachNoteIdx < 0)
+        return overrideDisplayContent;
+    return `${overrideDisplayContent}${params.promptText.slice(attachNoteIdx)}`;
+}
+function serializePromptContextSectionsMetadata(value) {
+    if (!value)
+        return undefined;
+    const activation = serializePromptContextSectionsArray(value.activation);
+    const resume = serializePromptContextSectionsArray(value.resume);
+    if (!activation && !resume)
+        return undefined;
+    return {
+        ...(activation ? { activation } : {}),
+        ...(resume ? { resume } : {}),
+    };
+}
+function serializePromptContextSectionsArray(sections) {
+    const serialized = normalizePromptContextSections(sections ?? [])
+        .map((section) => ({
+        kind: section.kind,
+        text: section.text,
+    }));
+    return serialized.length > 0 ? serialized : undefined;
+}
+function parsePromptContextSectionsMetadata(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const row = value;
+    const activation = parsePromptContextSectionsArray(row.activation);
+    const resume = parsePromptContextSectionsArray(row.resume);
+    if (!activation && !resume)
+        return undefined;
+    return {
+        ...(activation ? { activation } : {}),
+        ...(resume ? { resume } : {}),
+    };
+}
+function parsePromptContextSectionsArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const sections = value
+        .map((item) => {
+        if (!item || typeof item !== 'object')
+            return null;
+        const row = item;
+        if (!isPromptContextSectionKind(row.kind) || typeof row.text !== 'string')
+            return null;
+        return createPromptContextSection(row.kind, row.text);
+    })
+        .filter((section) => Boolean(section));
+    return sections.length > 0 ? sections : undefined;
+}