@bbigbang/core 0.1.0

package/dist/web/nodeWsHandler.js

@@ -0,0 +1,2495 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { log, finishRun } from '@bbigbang/runtime-acp';
+import { AgentFileAccessService, getRunEventSeqCutoff } from '../services/agentFileAccessService.js';
+import { hasOpenPendingWorkspaceApproval, isWorkspaceApprovalProgressEvent, promoteWorkspaceSentApprovalResponses, } from '../services/workspaceSessionRuntimeService.js';
+import { getWorkspaceRunDispatchNodeId, WORKSPACE_RUN_DISPATCH_METHOD, } from '../services/workspaceRunOwnership.js';
+import { iterateParsedNodeEvents } from '../nodeEventHistory.js';
+import { insertHandoffRun, markConversationHandoffAccepted, markConversationHandoffCancelled, markConversationHandoffCompleted, markConversationHandoffFailed, } from './conversationHandoffs.js';
+import { refreshConversationSummariesForConversationIds } from './conversationSummaries.js';
+import { resolveConversationReplyTarget, resolveDirectUserIdFromReplyTarget } from './directReplyTargets.js';
+import { allocateNextChannelMessageSeq } from './channelMessageSequences.js';
+import { getBoundTaskForThread } from './threadTaskBindings.js';
+import { scheduleTaskThreadFollowupForRun } from './taskThreadFollowups.js';
+import { clearTaskThreadReopenedRunBlock } from './taskThreadRuntimeClosure.js';
+import { markCodexRotationPendingIfDue, recordCodexCompactEvent } from './rollingConversationSummary.js';
+import { buildPrimaryDmTaskRootUpdateEventForThreadConversation } from './dmTaskThreadStatusProjection.js';
+import { DM_HANDOFF_BOOTSTRAP_STOP_REASON, getExpectedBootstrapStopReason, getSnapshotConversationStatus, } from './planApprovalState.js';
+/** Persist a ServerEvent from a remote run into core DB as a node/event entry */
+function appendNodeEvent(db, runId, seq, event) {
+    const persistedEvent = normalizeReplayEventForPersistence(event);
+    db.prepare('INSERT OR IGNORE INTO events(run_id, seq, method, payload_json, created_at) VALUES(?, ?, ?, ?, ?)').run(runId, seq, 'node/event', JSON.stringify(persistedEvent), Date.now());
+}
+function nextNodeEventSeq(db, runId, runSeq) {
+    const row = db.prepare(`SELECT COALESCE(MAX(seq), 0) as maxSeq
+     FROM events
+     WHERE run_id = ?
+       AND seq > 0`).get(runId);
+    const current = runSeq.get(runId) ?? 0;
+    return Math.max(current, row?.maxSeq ?? 0) + 1;
+}
+function normalizeReplayEventForPersistence(event) {
+    switch (event.type) {
+        case 'tool.call':
+            return {
+                type: 'tool.call',
+                toolCallId: event.toolCallId,
+                name: event.name,
+                input: event.input,
+                status: event.status,
+                startedAt: event.startedAt,
+            };
+        case 'tool.result':
+            return {
+                type: 'tool.result',
+                toolCallId: event.toolCallId,
+                output: event.output,
+                error: event.error,
+                status: event.status,
+                endedAt: event.endedAt,
+            };
+        case 'run.usage':
+            return {
+                type: 'run.usage',
+                inputTokens: event.inputTokens,
+                cachedInputTokens: event.cachedInputTokens,
+                outputTokens: event.outputTokens,
+                reasoningOutputTokens: event.reasoningOutputTokens,
+                totalTokens: event.totalTokens,
+                currentInputTokens: event.currentInputTokens,
+                currentCachedInputTokens: event.currentCachedInputTokens,
+                modelContextWindow: event.modelContextWindow,
+                createdAt: event.createdAt,
+            };
+        case 'runtime.compact':
+            return {
+                type: 'runtime.compact',
+                threadId: event.threadId,
+                turnId: event.turnId,
+                itemId: event.itemId,
+                source: event.source,
+                eventKey: event.eventKey,
+                createdAt: event.createdAt,
+            };
+        default:
+            return event;
+    }
+}
+function applyRunDebugSnapshot(db, params) {
+    const now = Date.now();
+    db.prepare(`UPDATE run_debug_inputs
+        SET acp_session_id = ?,
+            is_fresh_session = ?,
+            is_exact = ?,
+            system_prompt_text = COALESCE(?, system_prompt_text),
+            context_text = ?,
+            updated_at = ?
+      WHERE run_id = ?`).run(params.acpSessionId, params.isFreshSession ? 1 : 0, params.isExact ? 1 : 0, params.effectiveSystemPromptText ?? null, params.effectiveContextText ?? null, now, params.runId);
+    db.prepare(`UPDATE sessions
+        SET acp_session_id = ?,
+            system_prompt_text = COALESCE(?, system_prompt_text),
+            updated_at = ?
+      WHERE session_key = ?`).run(params.acpSessionId, params.effectiveSystemPromptText ?? null, now, params.sessionKey);
+}
+/** Event types worth persisting for history replay */
+const REPLAY_EVENT_TYPES = new Set([
+    'content.delta',
+    'activity.delta',
+    'tool.call',
+    'tool.result',
+    'thinking.delta',
+    'plan.update',
+    'plan.phase',
+    'task.update',
+    'run.usage',
+    'runtime.compact',
+    'run.steer.result',
+]);
+const DM_TASK_HANDOFF_EVENT_METHOD = 'platform/handoff';
+const PLAN_APPROVAL_MESSAGE_SOURCE = 'plan_approval';
+function adoptProvisionedNodeIdentity(db, pendingNodeId, registeredNodeId, hostname, agentTypesJson, version, processInstanceId, now) {
+    db.prepare(`UPDATE agents
+     SET node_id = ?
+     WHERE node_id = ?`).run(registeredNodeId, pendingNodeId);
+    db.prepare(`UPDATE conversations
+     SET node_id = ?
+     WHERE node_id = ?`).run(registeredNodeId, pendingNodeId);
+    db.prepare(`UPDATE nodes
+     SET node_id = ?,
+         hostname = ?,
+         agent_types_json = ?,
+         version = ?,
+         process_instance_id = ?,
+         status = 'online',
+         last_seen = ?,
+         created_at = CASE WHEN created_at = 0 THEN ? ELSE created_at END
+     WHERE node_id = ?`).run(registeredNodeId, hostname, agentTypesJson, version, processInstanceId, now, now, pendingNodeId);
+}
+function persistNodeHostSnapshots(db, params) {
+    db.transaction(() => {
+        if (params.hosts.length === 0) {
+            markAssetMaterializationsClearedForNode(db, params.nodeId, params.snapshotAt);
+            db.prepare(`DELETE FROM node_host_snapshots WHERE node_id = ?`).run(params.nodeId);
+            return;
+        }
+        const existingHosts = db.prepare(`SELECT host_key as hostKey, host_instance_id as hostInstanceId
+         FROM node_host_snapshots
+        WHERE node_id = ?`).all(params.nodeId);
+        const activeHostKeys = new Set(params.hosts.map((host) => `${host.hostKey}\u0000${host.hostInstanceId ?? ''}`));
+        for (const existingHost of existingHosts) {
+            if (!activeHostKeys.has(`${existingHost.hostKey}\u0000${existingHost.hostInstanceId ?? ''}`)) {
+                markAssetMaterializationsClearedForHost(db, {
+                    nodeId: params.nodeId,
+                    hostKey: existingHost.hostKey,
+                    hostInstanceId: existingHost.hostInstanceId ?? '',
+                    clearedAt: params.snapshotAt,
+                });
+            }
+        }
+        const placeholders = params.hosts.map(() => '?').join(', ');
+        db.prepare(`DELETE FROM node_host_snapshots WHERE node_id = ? AND host_key NOT IN (${placeholders})`).run(params.nodeId, ...params.hosts.map((host) => host.hostKey));
+        const upsert = db.prepare(`INSERT INTO node_host_snapshots(
+         node_id, host_key, host_instance_id, session_key, workspace_root, agent_type, state, current_run_id,
+         has_pending_approval, inbox_size, pending_dispatch_count, last_wake_at, last_sleep_at,
+         last_error, resumable, snapshot_at
+       ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(node_id, host_key) DO UPDATE SET
+         host_instance_id = excluded.host_instance_id,
+         session_key = excluded.session_key,
+         workspace_root = excluded.workspace_root,
+         agent_type = excluded.agent_type,
+         state = excluded.state,
+         current_run_id = excluded.current_run_id,
+         has_pending_approval = excluded.has_pending_approval,
+         inbox_size = excluded.inbox_size,
+         pending_dispatch_count = excluded.pending_dispatch_count,
+         last_wake_at = excluded.last_wake_at,
+         last_sleep_at = excluded.last_sleep_at,
+         last_error = excluded.last_error,
+         resumable = excluded.resumable,
+         snapshot_at = excluded.snapshot_at`);
+        for (const host of params.hosts) {
+            upsert.run(params.nodeId, host.hostKey, host.hostInstanceId ?? '', host.sessionKey, host.workspaceRoot, host.agentType, host.state, host.currentRunId, host.hasPendingApproval ? 1 : 0, host.inboxSize, host.pendingDispatchCount, host.lastWakeAt, host.lastSleepAt, host.lastError, host.resumable ? 1 : 0, params.snapshotAt);
+        }
+    })();
+}
+function parseConversationHostKey(hostKey) {
+    const match = /^conversation:([^:]+):([^:]+)$/.exec(hostKey);
+    if (!match)
+        return null;
+    return { conversationId: match[1], agentType: match[2] };
+}
+function parseDreamHostKey(hostKey) {
+    const match = /^dream:([^:]+):claude_sdk$/.exec(hostKey);
+    if (!match)
+        return null;
+    return { agentId: match[1] };
+}
+function validateDreamNodeHostSnapshot(db, params) {
+    const parsed = parseDreamHostKey(params.host.hostKey);
+    if (!parsed) {
+        return { ok: false, host: params.host, conversationId: null, reason: 'invalid dream host key' };
+    }
+    if (params.host.agentType !== 'claude_sdk') {
+        return { ok: false, host: params.host, conversationId: null, reason: 'dream host must use claude_sdk agent type' };
+    }
+    const row = db.prepare(`SELECT c.id as conversationId,
+            c.node_id as nodeId,
+            c.session_key as sessionKey,
+            a.agent_id as agentId,
+            r.run_id as runId,
+            r.session_key as runSessionKey,
+            rdi.dispatch_mode as dispatchMode
+       FROM agents a
+       JOIN conversations c ON c.agent_id = a.agent_id
+                          AND c.thread_kind = 'direct'
+                          AND c.is_primary_thread = 1
+       LEFT JOIN runs r ON r.run_id = ?
+       LEFT JOIN run_debug_inputs rdi ON rdi.run_id = r.run_id
+      WHERE a.agent_id = ?`).get(params.host.currentRunId ?? '', parsed.agentId);
+    if (!row) {
+        return { ok: false, host: params.host, conversationId: null, reason: 'dream agent conversation does not exist' };
+    }
+    if (row.nodeId !== params.nodeId) {
+        return { ok: false, host: params.host, conversationId: row.conversationId, reason: 'dream agent belongs to a different node' };
+    }
+    if (row.sessionKey !== params.host.sessionKey) {
+        return { ok: false, host: params.host, conversationId: row.conversationId, reason: 'dream host session mismatch' };
+    }
+    if (params.host.currentRunId) {
+        if (!row.runId) {
+            return { ok: false, host: params.host, conversationId: row.conversationId, reason: 'dream current run does not exist' };
+        }
+        if (row.runSessionKey !== params.host.sessionKey) {
+            return { ok: false, host: params.host, conversationId: row.conversationId, reason: 'dream current run session mismatch' };
+        }
+        if (row.dispatchMode !== 'dream') {
+            return { ok: false, host: params.host, conversationId: row.conversationId, reason: 'dream host current run is not dream dispatch' };
+        }
+    }
+    return { ok: true, host: params.host, conversationId: row.conversationId };
+}
+function isPlatformAgentRole(role) {
+    return role === 'platform_agent' || role === 'library_curator' || role === 'suggested_planner';
+}
+function validateNodeHostSnapshot(db, params) {
+    if (parseDreamHostKey(params.host.hostKey)) {
+        return validateDreamNodeHostSnapshot(db, params);
+    }
+    const parsed = parseConversationHostKey(params.host.hostKey);
+    if (!parsed) {
+        return { ok: false, host: params.host, conversationId: null, reason: 'host key is not conversation-scoped' };
+    }
+    if (parsed.agentType !== params.host.agentType) {
+        return {
+            ok: false,
+            host: params.host,
+            conversationId: parsed.conversationId,
+            reason: 'host key agent type does not match snapshot',
+        };
+    }
+    const row = db.prepare(`SELECT c.id as conversationId,
+            c.node_id as nodeId,
+            c.agent_type as agentType,
+            c.session_key as sessionKey,
+            c.agent_id as agentId,
+            a.agent_role as agentRole,
+            pai.enabled as platformEnabled,
+            pai.deleted_at as platformDeletedAt,
+            pad.enabled as definitionEnabled,
+            r.run_id as runId,
+            r.session_key as runSessionKey
+       FROM conversations c
+       LEFT JOIN agents a ON a.agent_id = c.agent_id
+       LEFT JOIN platform_agent_instances pai ON pai.agent_id = c.agent_id
+       LEFT JOIN platform_agent_definitions pad ON pad.definition_id = pai.definition_id
+       LEFT JOIN runs r ON r.run_id = ?
+      WHERE c.id = ?`).get(params.host.currentRunId ?? '', parsed.conversationId);
+    if (!row) {
+        return {
+            ok: false,
+            host: params.host,
+            conversationId: parsed.conversationId,
+            reason: 'conversation does not exist',
+        };
+    }
+    if (row.nodeId !== params.nodeId) {
+        return { ok: false, host: params.host, conversationId: parsed.conversationId, reason: 'conversation belongs to a different node' };
+    }
+    if (row.agentType !== params.host.agentType) {
+        return { ok: false, host: params.host, conversationId: parsed.conversationId, reason: 'conversation agent type mismatch' };
+    }
+    if (row.sessionKey !== params.host.sessionKey) {
+        return { ok: false, host: params.host, conversationId: parsed.conversationId, reason: 'conversation session mismatch' };
+    }
+    if (params.host.currentRunId) {
+        if (!row.runId) {
+            const queuedDispatch = db.prepare(`SELECT 1
+           FROM conversation_prompt_queue
+          WHERE conversation_id = ?
+            AND dispatching_run_id = ?
+          LIMIT 1`).get(parsed.conversationId, params.host.currentRunId);
+            if (!queuedDispatch) {
+                return { ok: false, host: params.host, conversationId: parsed.conversationId, reason: 'current run does not exist' };
+            }
+        }
+        else if (row.runSessionKey !== params.host.sessionKey) {
+            return { ok: false, host: params.host, conversationId: parsed.conversationId, reason: 'current run session mismatch' };
+        }
+    }
+    if (isPlatformAgentRole(row.agentRole)) {
+        if (row.platformEnabled !== 1 || row.platformDeletedAt !== null || row.definitionEnabled !== 1) {
+            return { ok: false, host: params.host, conversationId: parsed.conversationId, reason: 'platform agent instance is disabled or deleted' };
+        }
+    }
+    return { ok: true, host: params.host, conversationId: parsed.conversationId };
+}
+function validateNodeHostSnapshots(db, params) {
+    const validHosts = [];
+    const rejectedHosts = [];
+    for (const host of params.hosts) {
+        const result = validateNodeHostSnapshot(db, { nodeId: params.nodeId, host });
+        if (result.ok) {
+            validHosts.push(result.host);
+        }
+        else {
+            rejectedHosts.push(result);
+        }
+    }
+    return { validHosts, rejectedHosts };
+}
+function cleanupRejectedNodeHostSnapshot(db, params) {
+    const now = Date.now();
+    const conversation = params.conversationId
+        ? db.prepare(`SELECT id, session_key as sessionKey
+         FROM conversations
+        WHERE id = ?`).get(params.conversationId)
+        : undefined;
+    const sessionOwner = params.host.sessionKey
+        ? db.prepare(`SELECT id
+         FROM conversations
+        WHERE session_key = ?
+        LIMIT 1`).get(params.host.sessionKey)
+        : undefined;
+    const sessionBelongsToRejectedConversation = Boolean(conversation && conversation.sessionKey === params.host.sessionKey);
+    const sessionIsUnownedInCore = Boolean(params.host.sessionKey && !sessionOwner);
+    const shouldCleanupSessionKey = sessionBelongsToRejectedConversation || sessionIsUnownedInCore;
+    const runBelongsToRejectedSession = params.host.currentRunId && sessionBelongsToRejectedConversation
+        ? Boolean(db.prepare(`SELECT 1
+         FROM runs
+        WHERE run_id = ?
+          AND session_key = ?
+        LIMIT 1`).get(params.host.currentRunId, params.host.sessionKey))
+        : false;
+    db.transaction(() => {
+        db.prepare(`DELETE FROM node_dispatch_queue
+        WHERE host_key = ?
+           OR conversation_id = ?`).run(params.host.hostKey, params.conversationId ?? '');
+        if (shouldCleanupSessionKey) {
+            db.prepare(`DELETE FROM node_dispatch_queue WHERE session_key = ?`).run(params.host.sessionKey);
+        }
+        if (runBelongsToRejectedSession) {
+            db.prepare(`DELETE FROM node_dispatch_queue WHERE run_id = ?`).run(params.host.currentRunId);
+        }
+        db.prepare(`DELETE FROM node_host_snapshots WHERE node_id = ? AND host_key = ?`).run(params.nodeId, params.host.hostKey);
+        if (params.conversationId) {
+            db.prepare(`UPDATE conversations
+            SET status = CASE
+                  WHEN status IN ('queued', 'active', 'recovering', 'awaiting_approval') THEN 'idle'
+                  ELSE status
+        END
+          WHERE id = ?`).run(params.conversationId);
+        }
+        if (runBelongsToRejectedSession) {
+            db.prepare(`UPDATE runs
+            SET ended_at = COALESCE(ended_at, ?),
+                stop_reason = COALESCE(stop_reason, 'error'),
+                error = COALESCE(error, ?)
+          WHERE run_id = ?`).run(now, `Rejected stale node host snapshot: ${params.reason}`, params.host.currentRunId);
+        }
+    })();
+    void params.agentRuntimeCleanupBroker?.cleanupAgentRuntime({
+        nodeId: params.nodeId,
+        agentId: 'node-snapshot-validation',
+        hostKeys: [params.host.hostKey],
+        sessionKeys: shouldCleanupSessionKey ? [params.host.sessionKey] : [],
+    }).catch((error) => {
+        log.warn('[node-ws] failed to clean rejected host runtime', {
+            nodeId: params.nodeId,
+            hostKey: params.host.hostKey,
+            sessionKey: params.host.sessionKey,
+            reason: params.reason,
+            error: String(error?.message ?? error),
+        });
+    });
+    log.warn('[node-ws] rejected invalid node host snapshot', {
+        nodeId: params.nodeId,
+        hostKey: params.host.hostKey,
+        sessionKey: params.host.sessionKey,
+        currentRunId: params.host.currentRunId,
+        reason: params.reason,
+    });
+}
+async function cleanupDisabledPlatformAgentRuntimeForNode(db, params) {
+    const rows = db.prepare(`SELECT c.id as conversationId,
+            c.agent_type as agentType,
+            c.session_key as sessionKey,
+            c.agent_id as agentId
+       FROM conversations c
+       JOIN agents a ON a.agent_id = c.agent_id
+       LEFT JOIN platform_agent_instances pai ON pai.agent_id = c.agent_id
+       LEFT JOIN platform_agent_definitions pad ON pad.definition_id = pai.definition_id
+      WHERE c.node_id = ?
+        AND a.agent_role IN ('platform_agent', 'library_curator', 'suggested_planner')
+        AND (
+          pai.agent_id IS NULL
+          OR pai.enabled != 1
+          OR pai.deleted_at IS NOT NULL
+          OR pad.enabled != 1
+        )`).all(params.nodeId);
+    if (rows.length === 0)
+        return;
+    const targetsByAgent = new Map();
+    const now = Date.now();
+    db.transaction(() => {
+        for (const row of rows) {
+            const hostKey = `conversation:${row.conversationId}:${row.agentType}`;
+            db.prepare(`DELETE FROM node_dispatch_queue
+          WHERE host_key = ?
+             OR session_key = ?
+             OR conversation_id = ?`).run(hostKey, row.sessionKey, row.conversationId);
+            db.prepare(`DELETE FROM node_host_snapshots
+          WHERE node_id = ?
+            AND (host_key = ? OR session_key = ?)`).run(params.nodeId, hostKey, row.sessionKey);
+            db.prepare(`DELETE FROM conversation_prompt_queue WHERE conversation_id = ?`).run(row.conversationId);
+            db.prepare(`UPDATE conversations
+            SET status = CASE
+                  WHEN status IN ('queued', 'active', 'recovering', 'awaiting_approval') THEN 'idle'
+                  ELSE status
+                END
+          WHERE id = ?`).run(row.conversationId);
+            db.prepare(`UPDATE runs
+            SET ended_at = COALESCE(ended_at, ?),
+                stop_reason = COALESCE(stop_reason, 'error'),
+                error = COALESCE(error, 'Platform agent instance is disabled or deleted.')
+          WHERE session_key = ?
+            AND ended_at IS NULL`).run(now, row.sessionKey);
+            const group = targetsByAgent.get(row.agentId) ?? { hostKeys: new Set(), sessionKeys: new Set() };
+            group.hostKeys.add(hostKey);
+            group.sessionKeys.add(row.sessionKey);
+            targetsByAgent.set(row.agentId, group);
+        }
+    })();
+    if (!params.agentRuntimeCleanupBroker)
+        return;
+    for (const [agentId, target] of targetsByAgent.entries()) {
+        try {
+            await params.agentRuntimeCleanupBroker.cleanupAgentRuntime({
+                nodeId: params.nodeId,
+                agentId,
+                hostKeys: [...target.hostKeys],
+                sessionKeys: [...target.sessionKeys],
+            });
+        }
+        catch (error) {
+            log.warn('[node-ws] disabled platform runtime cleanup during node register failed', {
+                nodeId: params.nodeId,
+                agentId,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+}
+function recordAssetMaterialized(db, params) {
+    db.prepare(`INSERT INTO asset_materializations(
+       asset_id, agent_id, conversation_id, node_id, node_process_instance_id,
+       host_key, host_instance_id, run_id, local_path, materialized_at, cleared_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
+     ON CONFLICT(asset_id, agent_id, conversation_id, node_id, node_process_instance_id, host_key, host_instance_id) DO UPDATE SET
+       run_id = excluded.run_id,
+       local_path = excluded.local_path,
+       materialized_at = excluded.materialized_at,
+       cleared_at = NULL`).run(params.assetId, params.agentId, params.conversationId, params.nodeId, params.nodeProcessInstanceId, params.hostKey, params.hostInstanceId, params.runId ?? null, params.localPath, params.materializedAt);
+}
+function upsertMaterializedHostSnapshot(db, params) {
+    const row = db.prepare(`SELECT session_key as sessionKey,
+            COALESCE(workspace_path, '') as workspaceRoot,
+            agent_type as agentType,
+            status
+       FROM conversations
+      WHERE id = ?`).get(params.conversationId);
+    if (!row)
+        return;
+    const hostState = row.status === 'failed' ? 'failed' : (row.status === 'idle' ? 'idle' : 'active');
+    db.prepare(`INSERT INTO node_host_snapshots(
+       node_id, host_key, host_instance_id, session_key, workspace_root, agent_type, state, current_run_id,
+       has_pending_approval, inbox_size, pending_dispatch_count, last_wake_at, last_sleep_at,
+       last_error, resumable, snapshot_at
+     ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, NULL, NULL, 1, ?)
+     ON CONFLICT(node_id, host_key) DO UPDATE SET
+       state = CASE
+         WHEN node_host_snapshots.host_instance_id != excluded.host_instance_id THEN excluded.state
+         ELSE node_host_snapshots.state
+       END,
+       host_instance_id = excluded.host_instance_id,
+       session_key = excluded.session_key,
+       workspace_root = excluded.workspace_root,
+       agent_type = excluded.agent_type,
+       current_run_id = COALESCE(excluded.current_run_id, node_host_snapshots.current_run_id),
+       has_pending_approval = CASE
+         WHEN node_host_snapshots.host_instance_id != excluded.host_instance_id THEN excluded.has_pending_approval
+         ELSE node_host_snapshots.has_pending_approval
+       END,
+       inbox_size = CASE
+         WHEN node_host_snapshots.host_instance_id != excluded.host_instance_id THEN excluded.inbox_size
+         ELSE node_host_snapshots.inbox_size
+       END,
+       pending_dispatch_count = CASE
+         WHEN node_host_snapshots.host_instance_id != excluded.host_instance_id THEN excluded.pending_dispatch_count
+         ELSE node_host_snapshots.pending_dispatch_count
+       END,
+       last_error = CASE
+         WHEN node_host_snapshots.host_instance_id != excluded.host_instance_id THEN excluded.last_error
+         ELSE node_host_snapshots.last_error
+       END,
+       resumable = CASE
+         WHEN node_host_snapshots.host_instance_id != excluded.host_instance_id THEN excluded.resumable
+         ELSE node_host_snapshots.resumable
+       END,
+       snapshot_at = MAX(node_host_snapshots.snapshot_at, excluded.snapshot_at)
+     WHERE node_host_snapshots.host_instance_id = excluded.host_instance_id
+        OR node_host_snapshots.snapshot_at <= excluded.snapshot_at`).run(params.nodeId, params.hostKey, params.hostInstanceId, row.sessionKey, row.workspaceRoot, row.agentType, hostState, params.runId ?? null, row.status === 'awaiting_approval' ? 1 : 0, params.snapshotAt);
+}
+function markAssetMaterializationsClearedForHost(db, params) {
+    db.prepare(`UPDATE asset_materializations
+        SET cleared_at = COALESCE(cleared_at, ?)
+      WHERE node_id = ?
+        AND host_key = ?
+        AND host_instance_id = ?
+        AND cleared_at IS NULL`).run(params.clearedAt, params.nodeId, params.hostKey, params.hostInstanceId);
+}
+function markAssetMaterializationsClearedForNode(db, nodeId, clearedAt) {
+    db.prepare(`UPDATE asset_materializations
+        SET cleared_at = COALESCE(cleared_at, ?)
+      WHERE node_id = ?
+        AND cleared_at IS NULL`).run(clearedAt, nodeId);
+}
+function persistNodeRuntimeSnapshot(db, params) {
+    db.prepare(`INSERT INTO node_runtime_snapshots(
+       node_id, process_instance_id, workspace_root, terminal_backend_available, runtime_drivers_json, capabilities_json, snapshot_at
+     ) VALUES(?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(node_id) DO UPDATE SET
+       process_instance_id = excluded.process_instance_id,
+       workspace_root = excluded.workspace_root,
+       terminal_backend_available = excluded.terminal_backend_available,
+       runtime_drivers_json = excluded.runtime_drivers_json,
+       capabilities_json = excluded.capabilities_json,
+       snapshot_at = excluded.snapshot_at`).run(params.nodeId, params.processInstanceId ?? null, params.runtime.workspaceRoot, params.runtime.terminalBackendAvailable ? 1 : 0, JSON.stringify(params.runtime.runtimeDrivers), JSON.stringify(params.runtime.capabilities), params.snapshotAt);
+}
+function requiresMcpReplyContract(db, conversationId) {
+    const row = db
+        .prepare('SELECT agent_id as agentId FROM conversations WHERE id = ?')
+        .get(conversationId);
+    return Boolean(row?.agentId);
+}
+function isPlatformDebugRun(db, runId) {
+    const row = db.prepare(`SELECT activation_metadata_json as activationMetadataJson
+       FROM run_debug_inputs
+      WHERE run_id = ?`).get(runId);
+    if (!row?.activationMetadataJson)
+        return false;
+    try {
+        const parsed = JSON.parse(row.activationMetadataJson);
+        const legacyRole = parsed.platformRun?.role ?? parsed.role;
+        if ((legacyRole === 'suggested_planner' || legacyRole === 'library_curator')
+            && parsed.platformRun?.mode === 'debug') {
+            return true;
+        }
+        return (typeof parsed.platformRun?.definitionId === 'string'
+            && typeof parsed.platformRun?.workflowType === 'string'
+            && parsed.platformRun?.mode === 'debug');
+    }
+    catch {
+        return false;
+    }
+}
+function hasRunFinalReplyMessage(db, runId) {
+    const row = db
+        .prepare(`SELECT COUNT(1) as count
+       FROM channel_messages
+       WHERE run_id = ?
+         AND sender_type = 'agent'
+         AND message_kind = 'final'`)
+        .get(runId);
+    return (row?.count ?? 0) > 0;
+}
+function getRunFinalReplyMessage(db, runId) {
+    const row = db.prepare(`SELECT message_id as messageId,
+            sender_id as senderId,
+            sender_name as senderName,
+            content,
+            seq,
+            created_at as createdAt,
+            message_source as messageSource,
+            tool_ids as toolIds
+       FROM channel_messages
+      WHERE run_id = ?
+        AND sender_type = 'agent'
+        AND message_kind = 'final'
+        AND deleted_at IS NULL
+      ORDER BY created_at DESC, seq DESC
+      LIMIT 1`).get(runId);
+    return row ?? null;
+}
+function normalizeWorkspaceToolPublishFallbackText(value) {
+    return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+function buildWorkspaceToolPublishFallbackContent(toolRows) {
+    if (toolRows.length === 0) {
+        return 'Published the workspace tool.';
+    }
+    if (toolRows.length === 1) {
+        const tool = toolRows[0];
+        const label = normalizeWorkspaceToolPublishFallbackText(tool.name) || normalizeWorkspaceToolPublishFallbackText(tool.slug) || 'Workspace Tool';
+        const description = normalizeWorkspaceToolPublishFallbackText(tool.description);
+        const suffix = description ? ` ${description}` : '';
+        return `Published Workspace Tool: ${label}.${suffix}`.slice(0, 800);
+    }
+    const labels = toolRows
+        .map((tool) => normalizeWorkspaceToolPublishFallbackText(tool.name) || normalizeWorkspaceToolPublishFallbackText(tool.slug))
+        .filter(Boolean);
+    return `Published Workspace Tools: ${labels.join(', ')}.`.slice(0, 800);
+}
+function parseWorkspaceToolIdsJson(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed))
+            return [];
+        const toolIds = [];
+        const seen = new Set();
+        for (const rawToolId of parsed) {
+            const toolId = typeof rawToolId === 'string' ? rawToolId.trim() : '';
+            if (!toolId || seen.has(toolId))
+                continue;
+            seen.add(toolId);
+            toolIds.push(toolId);
+        }
+        return toolIds;
+    }
+    catch {
+        return [];
+    }
+}
+function consumePendingWorkspaceToolAttachments(params) {
+    const toolIds = [...new Set(params.toolIds.map((toolId) => toolId.trim()).filter(Boolean))];
+    if (toolIds.length === 0)
+        return 0;
+    const placeholders = toolIds.map(() => '?').join(', ');
+    const result = params.db.prepare(`DELETE FROM run_pending_tool_attachments
+      WHERE run_id = ?
+        AND conversation_id = ?
+        AND agent_id = ?
+        AND tool_id IN (${placeholders})`).run(params.runId, params.conversationId, params.agentId, ...toolIds);
+    return Number(result.changes ?? 0);
+}
+function persistPendingWorkspaceToolPublishFallback(params) {
+    const emptyResult = { emittedCount: 0, updatedCount: 0, toolIds: [] };
+    if (!requiresMcpReplyContract(params.db, params.conversationId))
+        return emptyResult;
+    const context = getFallbackMessageContext(params.db, params.conversationId, params.manager.getConfig().humanUserName);
+    if (!context)
+        return emptyResult;
+    const toolRows = params.db.prepare(`SELECT pending.tool_id as toolId,
+            tools.name as name,
+            tools.description as description,
+            tools.slug as slug,
+            tools.user_id as userId
+       FROM run_pending_tool_attachments pending
+       JOIN workspace_tools tools ON tools.tool_id = pending.tool_id
+      WHERE pending.run_id = ?
+        AND pending.conversation_id = ?
+        AND pending.agent_id = ?
+        AND tools.agent_id = pending.agent_id
+        AND tools.deleted_at IS NULL
+      ORDER BY pending.created_at ASC`).all(params.runId, params.conversationId, context.agentId);
+    if (toolRows.length === 0)
+        return emptyResult;
+    const allToolIds = toolRows.map((row) => row.toolId);
+    const consumeToolIds = (toolIds) => consumePendingWorkspaceToolAttachments({
+        db: params.db,
+        runId: params.runId,
+        conversationId: params.conversationId,
+        agentId: context.agentId,
+        toolIds,
+    });
+    if (context.agentType !== 'codex_app_server'
+        || !context.channelId.startsWith('dm:')
+        || context.threadRootId
+        || !context.userId) {
+        consumeToolIds(allToolIds);
+        return emptyResult;
+    }
+    const attachableToolRows = toolRows.filter((row) => row.userId === context.userId);
+    const attachableToolIds = new Set(attachableToolRows.map((row) => row.toolId));
+    const invalidToolIds = allToolIds.filter((toolId) => !attachableToolIds.has(toolId));
+    if (invalidToolIds.length > 0) {
+        consumeToolIds(invalidToolIds);
+    }
+    if (attachableToolRows.length === 0)
+        return emptyResult;
+    const toolIds = attachableToolRows.map((row) => row.toolId);
+    const existingFinal = getRunFinalReplyMessage(params.db, params.runId);
+    if (existingFinal) {
+        const mergedToolIds = parseWorkspaceToolIdsJson(existingFinal.toolIds);
+        const seenToolIds = new Set(mergedToolIds);
+        for (const toolId of toolIds) {
+            if (seenToolIds.has(toolId))
+                continue;
+            seenToolIds.add(toolId);
+            mergedToolIds.push(toolId);
+        }
+        consumeToolIds(toolIds);
+        if (JSON.stringify(mergedToolIds) === (existingFinal.toolIds ?? null)) {
+            return emptyResult;
+        }
+        const toolIdsJson = JSON.stringify(mergedToolIds);
+        params.db.prepare(`UPDATE channel_messages
+          SET tool_ids = ?
+        WHERE message_id = ?`).run(toolIdsJson, existingFinal.messageId);
+        params.broadcast(params.conversationId, {
+            type: 'channel.message',
+            message: {
+                id: existingFinal.messageId,
+                senderId: existingFinal.senderId,
+                senderName: existingFinal.senderName,
+                senderType: 'agent',
+                content: existingFinal.content,
+                createdAt: new Date(existingFinal.createdAt).toISOString(),
+                seq: existingFinal.seq,
+                runId: params.runId,
+                messageSource: existingFinal.messageSource ?? 'agent_send',
+                messageKind: 'final',
+                toolIds: mergedToolIds,
+            },
+        });
+        refreshConversationSummariesForConversationIds(params.db, (agentId) => params.manager.getAgent(agentId), [params.conversationId]);
+        return { emittedCount: 0, updatedCount: 1, toolIds: mergedToolIds };
+    }
+    const now = Date.now();
+    const seq = allocateNextChannelMessageSeq(params.db, context.channelId);
+    const messageId = randomUUID();
+    const runEventSeqCutoff = getRunEventSeqCutoff(params.db, params.runId);
+    const content = buildWorkspaceToolPublishFallbackContent(attachableToolRows);
+    const toolIdsJson = JSON.stringify(toolIds);
+    params.db.prepare(`INSERT INTO channel_messages(message_id, channel_id, sender_id, sender_name, sender_type, target, content, seq, created_at, run_id, thread_root_id, message_kind, message_source, tool_ids, run_event_seq_cutoff)
+     VALUES(?, ?, ?, ?, 'agent', ?, ?, ?, ?, ?, ?, 'final', 'workspace_tool_publish_fallback', ?, ?)`).run(messageId, context.channelId, context.agentId, context.agentName, context.target, content, seq, now, params.runId, context.threadRootId, toolIdsJson, runEventSeqCutoff);
+    consumeToolIds(toolIds);
+    params.broadcast(params.conversationId, {
+        type: 'channel.message',
+        message: {
+            id: messageId,
+            senderId: context.agentId,
+            senderName: context.agentName,
+            senderType: 'agent',
+            content,
+            createdAt: new Date(now).toISOString(),
+            seq,
+            runId: params.runId,
+            messageSource: 'workspace_tool_publish_fallback',
+            messageKind: 'final',
+            toolIds,
+            ...(context.threadRootId ? { threadRootId: context.threadRootId } : {}),
+        },
+    });
+    refreshConversationSummariesForConversationIds(params.db, (agentId) => params.manager.getAgent(agentId), [params.conversationId]);
+    return { emittedCount: 1, updatedCount: 0, toolIds };
+}
+function isCancelStopReason(stopReason) {
+    return Boolean(stopReason?.includes('cancel'));
+}
+function isWorkspaceToolPublishFallbackRecoverableRunEndError(error) {
+    return String(error ?? '').toLowerCase().includes('assistant text repair exceeded retry cap');
+}
+function normalizeComparisonText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function stripLegacyStatusText(text) {
+    return text
+        .split('\n')
+        .filter((line) => !/^\s*(?:-\s*)?(?:\[(?:plan|task)\]\s*)?(?:plan|task)\s+updated\s*$/i.test(line))
+        .filter((line) => !/^\s*(?:-\s*)?\[(?:plan|task)\]\b/i.test(line))
+        .join('\n');
+}
+function stripFallbackNoiseTokens(text) {
+    return text
+        .replace(/\[(?:plan|task)\]\s*(?:plan|task)\s+updated/ig, '')
+        .replace(/(?:plan|task)\s+updated/ig, '');
+}
+function stripInternalReminderTail(text) {
+    return text
+        .replace(/\(?System reminder acknowledged[\s\S]*$/i, '')
+        .trim();
+}
+function cleanFallbackText(text) {
+    return stripInternalReminderTail(stripFallbackNoiseTokens(stripLegacyStatusText(text))).trim();
+}
+function isIgnorablePlanOrTaskFallbackText(text) {
+    const normalized = text.trim().toLowerCase();
+    return normalized === 'plan updated'
+        || normalized === 'task updated'
+        || normalized === '[plan] plan updated'
+        || normalized === '[task] task updated';
+}
+function isIgnorableFallbackText(text) {
+    return text.includes(`Empty response: {'content':`)
+        || isIgnorablePlanOrTaskFallbackText(text);
+}
+function hasSubstantiveFallbackText(text) {
+    return text.trim().length > 0;
+}
+function listRunAgentMessages(db, runId) {
+    return db.prepare(`SELECT content, created_at, channel_id, seq
+     FROM channel_messages
+     WHERE run_id = ?
+       AND sender_type = 'agent'
+     ORDER BY created_at ASC, seq ASC`).all(runId);
+}
+function listRunDeltaEvents(db, runId) {
+    const deltas = [];
+    for (const row of iterateParsedNodeEvents(db, {
+        runId,
+        types: ['content.delta'],
+    })) {
+        if (row.event?.type === 'content.delta') {
+            deltas.push({
+                createdAt: row.createdAt,
+                seq: row.seq,
+                text: row.event.text,
+            });
+        }
+    }
+    return deltas;
+}
+function collectFallbackSegments(db, runId) {
+    const replyRows = listRunAgentMessages(db, runId);
+    const deltaRows = listRunDeltaEvents(db, runId);
+    if (deltaRows.length === 0)
+        return [];
+    const timeline = [
+        ...replyRows.map((row, index) => ({ type: 'message', createdAt: row.created_at, order: index })),
+        ...deltaRows.map((row, index) => ({ type: 'delta', createdAt: row.createdAt, order: index, text: row.text, seq: row.seq })),
+    ].sort((a, b) => {
+        if (a.createdAt !== b.createdAt)
+            return a.createdAt - b.createdAt;
+        if (a.type !== b.type)
+            return a.type === 'delta' ? -1 : 1;
+        return a.order - b.order;
+    });
+    let buffer = '';
+    const rawSegments = [];
+    const flushBuffer = () => {
+        if (!buffer)
+            return;
+        rawSegments.push(buffer);
+        buffer = '';
+    };
+    for (const item of timeline) {
+        if (item.type === 'delta') {
+            buffer += item.text;
+            continue;
+        }
+        flushBuffer();
+    }
+    flushBuffer();
+    const existingNormalized = new Set(replyRows.map((row) => normalizeComparisonText(cleanFallbackText(row.content))).filter(Boolean));
+    const emittedNormalized = new Set();
+    return rawSegments
+        .map((segment) => cleanFallbackText(segment))
+        .filter((segment) => hasSubstantiveFallbackText(segment))
+        .filter((segment) => !isIgnorableFallbackText(segment))
+        .filter((segment) => {
+        const normalized = normalizeComparisonText(segment);
+        if (!normalized)
+            return false;
+        if (existingNormalized.has(normalized) || emittedNormalized.has(normalized))
+            return false;
+        emittedNormalized.add(normalized);
+        return true;
+    });
+}
+function getFallbackMessageContext(db, conversationId, humanUserName) {
+    const row = db.prepare(`SELECT c.id as conversationId,
+            c.agent_id as agentId,
+            c.channel_id as channelId,
+            c.thread_kind as threadKind,
+            c.is_primary_thread as isPrimaryThread,
+            c.thread_root_id as threadRootId,
+            c.user_id as userId,
+            c.reply_target as replyTarget,
+            ch.name as channelName,
+            a.name as agentName,
+            a.agent_type as agentType
+     FROM conversations c
+     JOIN agents a ON a.agent_id = c.agent_id
+     LEFT JOIN channels ch ON ch.channel_id = c.channel_id
+     WHERE c.id = ?`).get(conversationId);
+    if (!row?.agentId)
+        return null;
+    const target = resolveConversationReplyTarget(db, conversationId, humanUserName)
+        ?? `${`#${row.channelName ?? row.channelId}`}${row.threadRootId ? `:${row.threadRootId}` : ''}`;
+    return {
+        agentId: row.agentId,
+        agentName: row.agentName,
+        agentType: row.agentType,
+        channelId: row.threadKind === 'direct' ? `dm:${row.agentId}` : row.channelId,
+        target,
+        threadRootId: row.threadRootId ?? null,
+        userId: row.threadKind === 'direct'
+            ? row.userId?.trim() || resolveDirectUserIdFromReplyTarget(db, row.replyTarget)
+            : row.userId ?? null,
+    };
+}
+function getPlanTextFromApprovalRequest(msg) {
+    const input = msg.input && typeof msg.input === 'object' && !Array.isArray(msg.input)
+        ? msg.input
+        : null;
+    if (typeof input?.plan === 'string' && input.plan.trim())
+        return input.plan.trim();
+    const args = msg.toolArgs && typeof msg.toolArgs === 'object' && !Array.isArray(msg.toolArgs)
+        ? msg.toolArgs
+        : null;
+    if (typeof args?.plan === 'string' && args.plan.trim())
+        return args.plan.trim();
+    return null;
+}
+function upsertPlanApprovalMessage(params) {
+    const context = getFallbackMessageContext(params.db, params.conversationId, params.manager.getConfig().humanUserName);
+    if (!context)
+        return;
+    const now = Date.now();
+    const existing = params.db.prepare(`SELECT message_id as messageId, seq, created_at as createdAt
+     FROM channel_messages
+     WHERE run_id = ?
+       AND message_source = ?
+       AND message_kind = 'plan'
+     ORDER BY created_at DESC, seq DESC
+     LIMIT 1`).get(params.runId, PLAN_APPROVAL_MESSAGE_SOURCE);
+    if (existing) {
+        const runEventSeqCutoff = getRunEventSeqCutoff(params.db, params.runId);
+        params.db.prepare(`UPDATE channel_messages
+       SET content = ?,
+           run_event_seq_cutoff = ?
+       WHERE message_id = ?`).run(params.planText, runEventSeqCutoff, existing.messageId);
+        const fileRefs = params.agentFileAccessService
+            ? params.agentFileAccessService.getFileRefsForMessage({
+                agentId: context.agentId,
+                runId: params.runId,
+                content: params.planText,
+                createdAt: existing.createdAt,
+                runEventSeqCutoff,
+            })
+            : undefined;
+        params.broadcast(params.conversationId, {
+            type: 'channel.message',
+            message: {
+                id: existing.messageId,
+                senderId: context.agentId,
+                senderName: context.agentName,
+                senderType: 'agent',
+                content: params.planText,
+                createdAt: new Date(existing.createdAt).toISOString(),
+                seq: existing.seq,
+                runId: params.runId,
+                messageSource: PLAN_APPROVAL_MESSAGE_SOURCE,
+                messageKind: 'plan',
+                ...(fileRefs ? { fileRefs } : {}),
+                ...(context.threadRootId ? { threadRootId: context.threadRootId } : {}),
+            },
+        });
+        return;
+    }
+    const seq = allocateNextChannelMessageSeq(params.db, context.channelId);
+    const messageId = randomUUID();
+    const runEventSeqCutoff = getRunEventSeqCutoff(params.db, params.runId);
+    params.db.prepare(`INSERT INTO channel_messages(message_id, channel_id, sender_id, sender_name, sender_type, target, content, seq, created_at, run_id, thread_root_id, message_kind, message_source, run_event_seq_cutoff)
+     VALUES(?, ?, ?, ?, 'agent', ?, ?, ?, ?, ?, ?, 'plan', ?, ?)`).run(messageId, context.channelId, context.agentId, context.agentName, context.target, params.planText, seq, now, params.runId, context.threadRootId, PLAN_APPROVAL_MESSAGE_SOURCE, runEventSeqCutoff);
+    const fileRefs = params.agentFileAccessService
+        ? params.agentFileAccessService.getFileRefsForMessage({
+            agentId: context.agentId,
+            runId: params.runId,
+            content: params.planText,
+            createdAt: now,
+            runEventSeqCutoff,
+        })
+        : undefined;
+    params.broadcast(params.conversationId, {
+        type: 'channel.message',
+        message: {
+            id: messageId,
+            senderId: context.agentId,
+            senderName: context.agentName,
+            senderType: 'agent',
+            content: params.planText,
+            createdAt: new Date(now).toISOString(),
+            seq,
+            runId: params.runId,
+            messageSource: PLAN_APPROVAL_MESSAGE_SOURCE,
+            messageKind: 'plan',
+            ...(fileRefs ? { fileRefs } : {}),
+            ...(context.threadRootId ? { threadRootId: context.threadRootId } : {}),
+        },
+    });
+    refreshConversationSummariesForConversationIds(params.db, (agentId) => params.manager.getAgent(agentId), [params.conversationId]);
+}
+function persistDeltaFallbackMessages(params) {
+    const emptyResult = { emittedCount: 0, suppressedCount: 0 };
+    if (!requiresMcpReplyContract(params.db, params.conversationId))
+        return emptyResult;
+    const platformDebugRun = isPlatformDebugRun(params.db, params.runId);
+    const context = getFallbackMessageContext(params.db, params.conversationId, params.manager.getConfig().humanUserName);
+    if (!context)
+        return emptyResult;
+    const boundTask = context.threadRootId
+        ? getBoundTaskForThread(params.db, {
+            channelId: context.channelId,
+            threadRootId: context.threadRootId,
+        })
+        : undefined;
+    if (platformDebugRun && hasRunFinalReplyMessage(params.db, params.runId)) {
+        return {
+            emittedCount: 0,
+            suppressedCount: 0,
+            suppressedReason: 'final_reply',
+        };
+    }
+    if (!platformDebugRun && (context.agentType === 'codex_app_server' || context.agentType === 'claude_sdk')) {
+        return {
+            emittedCount: 0,
+            suppressedCount: 0,
+            suppressedReason: context.agentType,
+        };
+    }
+    const segments = collectFallbackSegments(params.db, params.runId);
+    if (segments.length === 0)
+        return emptyResult;
+    if (context.threadRootId
+        && boundTask
+        && !context.channelId.startsWith('dm:')
+        && (boundTask.status === 'in_review' || boundTask.status === 'done')) {
+        return {
+            emittedCount: 0,
+            suppressedCount: segments.length,
+            suppressedReason: 'closed_task_thread',
+        };
+    }
+    let createdAt = Date.now();
+    let emittedCount = 0;
+    for (const content of segments) {
+        const seq = allocateNextChannelMessageSeq(params.db, context.channelId);
+        const messageId = randomUUID();
+        const runEventSeqCutoff = getRunEventSeqCutoff(params.db, params.runId);
+        params.db.prepare(`INSERT INTO channel_messages(message_id, channel_id, sender_id, sender_name, sender_type, target, content, seq, created_at, run_id, thread_root_id, message_kind, message_source, run_event_seq_cutoff)
+       VALUES(?, ?, ?, ?, 'agent', ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(messageId, context.channelId, context.agentId, context.agentName, context.target, content, seq, createdAt, params.runId, context.threadRootId, null, 'delta_fallback', runEventSeqCutoff);
+        const fileRefs = params.agentFileAccessService
+            ? params.agentFileAccessService.getFileRefsForMessage({
+                agentId: context.agentId,
+                runId: params.runId,
+                content,
+                createdAt,
+                runEventSeqCutoff,
+            })
+            : [];
+        params.broadcast(params.conversationId, {
+            type: 'channel.message',
+            message: {
+                id: messageId,
+                senderId: context.agentId,
+                senderName: context.agentName,
+                senderType: 'agent',
+                content,
+                createdAt: new Date(createdAt).toISOString(),
+                seq,
+                runId: params.runId,
+                ...(fileRefs.length > 0 ? { fileRefs } : {}),
+                messageSource: 'delta_fallback',
+                ...(context.threadRootId ? { threadRootId: context.threadRootId } : {}),
+            },
+        });
+        createdAt += 1;
+        emittedCount += 1;
+    }
+    return { emittedCount, suppressedCount: 0 };
+}
+function isDreamDispatchRun(db, runId) {
+    const row = db.prepare(`SELECT dispatch_mode as dispatchMode
+       FROM run_debug_inputs
+      WHERE run_id = ?
+      LIMIT 1`).get(runId);
+    return row?.dispatchMode === 'dream';
+}
+function getRunEndError(msg, db, conversationId, runId, wasHandedOff = false, expectedBootstrapStopReason) {
+    if (msg.error)
+        return msg.error;
+    if (isDreamDispatchRun(db, runId))
+        return null;
+    if (isCancelStopReason(msg.stopReason)) {
+        if (wasHandedOff || expectedBootstrapStopReason === DM_HANDOFF_BOOTSTRAP_STOP_REASON)
+            return null;
+        if (hasRunFinalReplyMessage(db, runId))
+            return null;
+        if (requiresMcpReplyContract(db, conversationId)) {
+            return 'Agent run was cancelled before sending a final reply';
+        }
+        return 'Run cancelled before completion';
+    }
+    return null;
+}
+function wasRunHandedOff(db, runId) {
+    return Boolean(db.prepare(`SELECT 1
+     FROM events
+     WHERE run_id = ?
+       AND method = ?
+     LIMIT 1`).get(runId, DM_TASK_HANDOFF_EVENT_METHOD));
+}
+function updateConversationStatus(db, broadcast, conversationId, status) {
+    db.prepare('UPDATE conversations SET status = ?, updated_at = ? WHERE id = ?')
+        .run(status, Date.now(), conversationId);
+    broadcast(conversationId, {
+        type: 'conversation.status',
+        conversationId,
+        status,
+    });
+}
+function getWorkspaceRunContext(db, runId) {
+    const row = db.prepare(`SELECT ws.workspace_session_id as workspaceSessionId,
+            ws.session_key as sessionKey,
+            r.ended_at as endedAt
+       FROM runs r
+       JOIN workspace_sessions ws ON ws.session_key = r.session_key
+      WHERE r.run_id = ?
+      LIMIT 1`).get(runId);
+    return row ?? null;
+}
+function updateWorkspaceSessionStatus(db, workspaceSessionId, status) {
+    const now = Date.now();
+    db.prepare(`UPDATE workspace_sessions
+        SET status = ?,
+            updated_at = ?,
+            last_active_at = ?
+      WHERE workspace_session_id = ?`).run(status, now, now, workspaceSessionId);
+}
+function resolveWorkspaceSessionStatus(db, sessionKey, params) {
+    if (hasOpenPendingWorkspaceApproval(db, sessionKey))
+        return 'awaiting_approval';
+    return getNextOpenWorkspaceRunId(db, sessionKey) ? params.openStatus : params.closedStatus;
+}
+function getNextOpenWorkspaceRunId(db, sessionKey) {
+    const row = db.prepare(`SELECT run_id as runId
+       FROM runs
+      WHERE session_key = ?
+        AND ended_at IS NULL
+      ORDER BY started_at ASC, rowid ASC
+      LIMIT 1`).get(sessionKey);
+    return row?.runId ?? null;
+}
+function workspaceRunBelongsToCurrentNode(db, runId, currentNodeId) {
+    const ownerNodeId = getWorkspaceRunDispatchNodeId(db, runId);
+    return Boolean(ownerNodeId && currentNodeId && ownerNodeId === currentNodeId);
+}
+function listOpenWorkspaceRunsForNode(db, nodeId) {
+    return db.prepare(`SELECT r.run_id as runId,
+            ws.workspace_session_id as workspaceSessionId,
+            ws.session_key as sessionKey
+       FROM runs r
+       JOIN workspace_sessions ws ON ws.session_key = r.session_key
+      WHERE r.ended_at IS NULL
+        AND EXISTS (
+          SELECT 1
+            FROM events owner
+           WHERE owner.run_id = r.run_id
+             AND owner.method = ?
+             AND json_valid(owner.payload_json)
+             AND json_extract(owner.payload_json, '$.nodeId') = ?
+        )`).all(WORKSPACE_RUN_DISPATCH_METHOD, nodeId);
+}
+function buildBroadcastNodeEvent(event) {
+    return event.type === 'tool.call'
+        ? { ...event, startedAt: event.startedAt ?? Date.now() }
+        : event.type === 'tool.result'
+            ? { ...event, endedAt: event.endedAt ?? Date.now() }
+            : event.type === 'run.usage'
+                ? { ...event, createdAt: event.createdAt ?? Date.now() }
+                : event.type === 'runtime.compact'
+                    ? { ...event, createdAt: event.createdAt ?? Date.now() }
+                    : event;
+}
+function broadcastPrimaryDmTaskRootStatusProjection(params) {
+    void params.manager;
+    const update = buildPrimaryDmTaskRootUpdateEventForThreadConversation(params.db, params.threadConversationId, params.taskThreadStatus);
+    if (!update)
+        return;
+    params.broadcast(update.conversationId, update.event);
+}
+function finishConversationRun(params) {
+    const endedAt = Date.now();
+    finishRun(params.db, params.error
+        ? { runId: params.runId, error: params.error }
+        : { runId: params.runId, stopReason: params.stopReason ?? 'end_turn' });
+    if (!params.error) {
+        markCodexRotationPendingIfDue(params.db, params.conversationId);
+    }
+    updateConversationStatus(params.db, params.broadcast, params.conversationId, params.error ? 'failed' : 'idle');
+    broadcastPrimaryDmTaskRootStatusProjection({
+        db: params.db,
+        broadcast: params.broadcast,
+        manager: params.manager,
+        threadConversationId: params.conversationId,
+        taskThreadStatus: params.error ? 'failed' : 'idle',
+    });
+    params.broadcast(params.conversationId, {
+        type: 'turn.end',
+        turnId: params.runId,
+        stopReason: params.error ? 'error' : (params.stopReason ?? 'end_turn'),
+        endedAt,
+        error: params.error,
+    });
+    if (params.error) {
+        params.broadcast(params.conversationId, { type: 'error', message: params.error });
+    }
+    scheduleTaskThreadFollowupForRun({
+        db: params.db,
+        conversationId: params.conversationId,
+        runId: params.runId,
+        stopReason: params.stopReason,
+        error: params.error,
+    });
+    void params.onRunFinished?.({
+        db: params.db,
+        runId: params.runId,
+        conversationId: params.conversationId,
+        stopReason: params.stopReason,
+        error: params.error,
+    });
+    void params.manager.onConversationSettled(params.conversationId);
+}
+export function handleNodeWebSocket(socket, registry, broadcast, db, manager, workspaceBroker, skillsBroker, codexTranscriptBroker, claudeTranscriptBroker, broadcastToChannel, terminalBroker, inspectBroker, gitBroker, claudeControlBroker, codexAppServerBroker, agentRuntimeCleanupBroker, workspaceSessionRuntimeService, onRunFinished, workspaceToolService, missionService, droidMissionBroker, nativeMissionWorkerBroker, soloSessionRelay) {
+    const agentFileAccessService = workspaceBroker
+        ? new AgentFileAccessService({
+            db,
+            getAgentById: (agentId) => manager.getAgent(agentId),
+            broker: workspaceBroker,
+        })
+        : null;
+    let nodeId = null;
+    let connectionProcessInstanceId = null;
+    const isStaleNodeConnection = () => {
+        if (!nodeId)
+            return false;
+        const activeEntry = typeof registry.getNode === 'function' ? registry.getNode(nodeId) : undefined;
+        if (activeEntry?.ws && activeEntry.ws !== socket) {
+            return true;
+        }
+        if (!connectionProcessInstanceId)
+            return false;
+        const currentNode = db.prepare(`SELECT process_instance_id as processInstanceId
+         FROM nodes
+        WHERE node_id = ?`).get(nodeId);
+        return currentNode?.processInstanceId !== connectionProcessInstanceId;
+    };
+    // Sequence counter per runId for node/event persistence
+    const runSeq = new Map();
+    const refreshHandoffSummaries = (handoff, fallbackConversationId) => {
+        const conversationIds = new Set();
+        if (fallbackConversationId)
+            conversationIds.add(fallbackConversationId);
+        if (handoff?.sourceConversationId)
+            conversationIds.add(handoff.sourceConversationId);
+        if (handoff?.targetConversationId)
+            conversationIds.add(handoff.targetConversationId);
+        if (conversationIds.size === 0)
+            return;
+        refreshConversationSummariesForConversationIds(db, (agentId) => manager.getAgent(agentId), conversationIds);
+    };
+    // Wrap broadcast: when a branch conversation's status changes, also forward to its channel stream
+    const broadcastWithChannelForward = (conversationId, event) => {
+        broadcast(conversationId, event);
+        if (broadcastToChannel) {
+            const conv = manager.getConversation(conversationId);
+            if (conv?.channelId && conv.threadKind === 'branch' && !conv.channelId.startsWith('dm:')) {
+                if (event.type === 'channel.message') {
+                    broadcastToChannel(conv.channelId, event);
+                    return;
+                }
+                if (event.type === 'conversation.status') {
+                    broadcastToChannel(conv.channelId, {
+                        type: 'channel.conversation.status',
+                        channelId: conv.channelId,
+                        conversation: { ...conv, status: event.status },
+                    });
+                }
+            }
+        }
+    };
+    const failNodeOwnedRuntimeState = (params) => {
+        inspectBroker?.rejectPendingForNode(params.nodeId);
+        gitBroker?.rejectPendingForNode(params.nodeId);
+        workspaceBroker?.rejectPendingForNode(params.nodeId);
+        terminalBroker?.handleNodeDisconnect(params.nodeId);
+        skillsBroker?.rejectPendingForNode(params.nodeId);
+        codexTranscriptBroker?.rejectPendingForNode(params.nodeId);
+        claudeTranscriptBroker?.rejectPendingForNode(params.nodeId);
+        claudeControlBroker?.rejectPendingForNode(params.nodeId);
+        codexAppServerBroker?.rejectPendingForNode(params.nodeId);
+        agentRuntimeCleanupBroker?.rejectPendingForNode(params.nodeId);
+        workspaceSessionRuntimeService?.rejectPendingDispatchesForNode(params.nodeId, params.disconnectMessage);
+        manager.rejectPendingDispatchesForNode(params.nodeId, params.disconnectMessage);
+        manager.rejectPendingSteersForNode(params.nodeId, params.disconnectMessage);
+        nativeMissionWorkerBroker?.rejectNodeAttempts(params.nodeId, new Error(params.disconnectMessage));
+        if (params.unregisterNode) {
+            registry.unregister(params.nodeId);
+        }
+        const now = Date.now();
+        if (params.markNodeOffline) {
+            db.prepare(`UPDATE nodes SET status='offline', last_seen=? WHERE node_id=?`)
+                .run(now, params.nodeId);
+        }
+        markAssetMaterializationsClearedForNode(db, params.nodeId, now);
+        const workspaceOpenRuns = listOpenWorkspaceRunsForNode(db, params.nodeId);
+        const affectedWorkspaceSessions = new Map();
+        for (const run of workspaceOpenRuns) {
+            finishRun(db, { runId: run.runId, error: params.disconnectMessage });
+            affectedWorkspaceSessions.set(run.workspaceSessionId, run.sessionKey);
+        }
+        if (affectedWorkspaceSessions.size > 0) {
+            const stmt = db.prepare(`UPDATE workspace_sessions
+            SET status = ?,
+                updated_at = ?,
+                last_active_at = ?
+          WHERE workspace_session_id = ?`);
+            for (const [workspaceSessionId, sessionKey] of affectedWorkspaceSessions.entries()) {
+                stmt.run(resolveWorkspaceSessionStatus(db, sessionKey, {
+                    openStatus: 'queued',
+                    closedStatus: 'failed',
+                }), now, now, workspaceSessionId);
+            }
+        }
+        const affected = db.prepare(`SELECT id FROM conversations WHERE node_id = ? AND status != 'idle'`).all(params.nodeId);
+        const openRuns = db.prepare(`SELECT r.run_id as runId, c.id as conversationId
+         FROM runs r
+         JOIN conversations c ON c.session_key = r.session_key
+        WHERE c.node_id = ?
+          AND r.ended_at IS NULL`).all(params.nodeId);
+        const openRunConversationIds = new Set(openRuns.map((run) => run.conversationId));
+        for (const run of openRuns) {
+            finishRun(db, { runId: run.runId, error: params.disconnectMessage });
+            db.prepare(`UPDATE conversations SET status='failed', updated_at=? WHERE id=? AND status != 'idle'`)
+                .run(Date.now(), run.conversationId);
+            broadcastWithChannelForward(run.conversationId, {
+                type: 'turn.end',
+                turnId: run.runId,
+                stopReason: 'error',
+                endedAt: Date.now(),
+                error: params.disconnectMessage,
+            });
+            void onRunFinished?.({
+                db,
+                runId: run.runId,
+                conversationId: run.conversationId,
+                error: params.disconnectMessage,
+            });
+        }
+        for (const conv of affected) {
+            if (!openRunConversationIds.has(conv.id)) {
+                db.prepare(`UPDATE conversations SET status='failed', updated_at=? WHERE id=? AND status != 'idle'`)
+                    .run(Date.now(), conv.id);
+            }
+            broadcastWithChannelForward(conv.id, {
+                type: 'conversation.status',
+                conversationId: conv.id,
+                status: 'failed',
+            });
+            broadcastPrimaryDmTaskRootStatusProjection({
+                db,
+                broadcast: broadcastWithChannelForward,
+                manager,
+                threadConversationId: conv.id,
+                taskThreadStatus: 'failed',
+            });
+            broadcastWithChannelForward(conv.id, {
+                type: 'error',
+                message: params.disconnectMessage,
+            });
+        }
+    };
+    socket.on('message', (raw) => {
+        let msg;
+        try {
+            msg = JSON.parse(String(raw));
+        }
+        catch {
+            log.warn('[node-ws] invalid JSON from node');
+            return;
+        }
+        if (msg.type !== 'node.register' && isStaleNodeConnection()) {
+            log.debug('[node-ws] ignoring message from stale node connection', {
+                nodeId,
+                messageType: msg.type,
+                connectionProcessInstanceId,
+            });
+            return;
+        }
+        switch (msg.type) {
+            case 'node.register': {
+                nodeId = msg.nodeId;
+                const now = Date.now();
+                const processInstanceId = typeof msg.processInstanceId === 'string' && msg.processInstanceId.trim()
+                    ? msg.processInstanceId.trim()
+                    : null;
+                connectionProcessInstanceId = processInstanceId;
+                const previousRegistryEntry = typeof registry.getNode === 'function' ? registry.getNode(msg.nodeId) : undefined;
+                const existing = db.prepare(`SELECT node_id,
+                  status,
+                  process_instance_id as processInstanceId
+             FROM nodes
+            WHERE node_id = ?`).get(msg.nodeId);
+                if (existing?.status === 'deleted') {
+                    log.warn(`[node-ws] connection rejected: node ${msg.nodeId} was deleted`);
+                    socket.close(4000, 'Machine has been deleted');
+                    return;
+                }
+                const replacedProcessInstance = Boolean(existing?.processInstanceId
+                    && processInstanceId
+                    && existing.processInstanceId !== processInstanceId);
+                registry.register({
+                    nodeId: msg.nodeId,
+                    hostname: msg.hostname,
+                    agentTypes: msg.agentTypes,
+                    version: msg.version,
+                    processInstanceId,
+                    terminalBackendAvailable: msg.terminalBackendAvailable,
+                    ws: socket,
+                    lastSeen: now,
+                });
+                // Persist to DB: update existing pre-provisioned row or insert new
+                const agentTypesJson = JSON.stringify(msg.agentTypes);
+                if (existing) {
+                    db.prepare(`UPDATE nodes SET hostname=?, agent_types_json=?, version=?, process_instance_id=?, status='online', last_seen=?,
+             created_at=CASE WHEN created_at=0 THEN ? ELSE created_at END WHERE node_id=?`).run(msg.hostname, agentTypesJson, msg.version, processInstanceId, now, now, msg.nodeId);
+                }
+                else {
+                    const pending = db.prepare(`SELECT node_id
+             FROM nodes
+             WHERE status = 'pending'
+               AND display_name = ?
+             ORDER BY provisioned_at DESC
+             LIMIT 1`).get(msg.hostname);
+                    if (pending) {
+                        adoptProvisionedNodeIdentity(db, pending.node_id, msg.nodeId, msg.hostname, agentTypesJson, msg.version, processInstanceId, now);
+                    }
+                    else {
+                        db.prepare(`INSERT INTO nodes(node_id, hostname, agent_types_json, version, process_instance_id, status, last_seen, created_at, provisioned_at, display_name, env_var_keys)
+               VALUES(?,?,?,?,?,'online',?,?,0,NULL,'[]')`).run(msg.nodeId, msg.hostname, agentTypesJson, msg.version, processInstanceId, now, now);
+                    }
+                }
+                if (replacedProcessInstance) {
+                    const disconnectMessage = `Agent node process restarted: ${msg.nodeId}`;
+                    failNodeOwnedRuntimeState({
+                        nodeId: msg.nodeId,
+                        disconnectMessage,
+                        unregisterNode: false,
+                        markNodeOffline: false,
+                    });
+                    if (previousRegistryEntry?.ws && previousRegistryEntry.ws !== socket) {
+                        try {
+                            previousRegistryEntry.ws.close();
+                        }
+                        catch {
+                            // Ignore failures from stale sockets during process replacement cleanup.
+                        }
+                    }
+                    log.warn('[node-ws] replaced active node process and failed open runtime state', {
+                        nodeId: msg.nodeId,
+                        previousProcessInstanceId: existing?.processInstanceId ?? null,
+                        processInstanceId,
+                    });
+                }
+                void cleanupDisabledPlatformAgentRuntimeForNode(db, {
+                    nodeId: msg.nodeId,
+                    agentRuntimeCleanupBroker,
+                }).finally(() => {
+                    try {
+                        socket.send(JSON.stringify({ type: 'node.ack', nodeId: msg.nodeId }));
+                    }
+                    catch {
+                        // Ignore ack send failures; the socket close path will reconcile node state.
+                    }
+                    log.info(`[node-ws] registered: ${msg.nodeId} (${msg.hostname})`);
+                    void workspaceToolService?.reconcileActiveTerminalsForNode(msg.nodeId).catch((error) => {
+                        log.warn('[node-ws] workspace tool active terminal reconcile failed', {
+                            nodeId: msg.nodeId,
+                            error: String(error?.message ?? error),
+                        });
+                    });
+                });
+                break;
+            }
+            case 'node.heartbeat': {
+                registry.heartbeat(msg.nodeId);
+                break;
+            }
+            case 'node.hosts.snapshot': {
+                registry.heartbeat(msg.nodeId);
+                db.prepare(`UPDATE nodes SET last_seen = ?, status = 'online' WHERE node_id = ?`)
+                    .run(msg.generatedAt, msg.nodeId);
+                const { validHosts, rejectedHosts } = validateNodeHostSnapshots(db, {
+                    nodeId: msg.nodeId,
+                    hosts: msg.hosts,
+                });
+                for (const rejected of rejectedHosts) {
+                    cleanupRejectedNodeHostSnapshot(db, {
+                        nodeId: msg.nodeId,
+                        host: rejected.host,
+                        conversationId: rejected.conversationId,
+                        reason: rejected.reason,
+                        agentRuntimeCleanupBroker,
+                    });
+                }
+                persistNodeHostSnapshots(db, {
+                    nodeId: msg.nodeId,
+                    snapshotAt: msg.generatedAt,
+                    hosts: validHosts,
+                });
+                const activeConversationIds = new Set();
+                for (const host of validHosts) {
+                    if (host.state === 'active' && host.currentRunId) {
+                        const status = getSnapshotConversationStatus(db, {
+                            runId: host.currentRunId,
+                            hasPendingApproval: host.hasPendingApproval,
+                        });
+                        const conversationIds = manager.handleNodeHostSnapshotCurrentRun({
+                            runId: host.currentRunId,
+                            nodeId: msg.nodeId,
+                            hostKey: host.hostKey,
+                            sessionKey: host.sessionKey,
+                            agentType: host.agentType,
+                            hasPendingApproval: host.hasPendingApproval,
+                        });
+                        for (const conversationId of conversationIds) {
+                            activeConversationIds.add(conversationId);
+                            broadcastWithChannelForward(conversationId, {
+                                type: 'conversation.status',
+                                conversationId,
+                                status,
+                            });
+                            if (status === 'awaiting_approval') {
+                                broadcastPrimaryDmTaskRootStatusProjection({
+                                    db,
+                                    broadcast: broadcastWithChannelForward,
+                                    manager,
+                                    threadConversationId: conversationId,
+                                    taskThreadStatus: status,
+                                });
+                            }
+                        }
+                    }
+                }
+                const queuedConversationIds = db.prepare(`SELECT DISTINCT q.conversation_id as conversationId
+           FROM conversation_prompt_queue q
+           JOIN conversations c ON c.id = q.conversation_id
+           WHERE c.node_id = ?`).all(msg.nodeId);
+                for (const conversation of queuedConversationIds) {
+                    if (activeConversationIds.has(conversation.conversationId))
+                        continue;
+                    void manager.onConversationSettled(conversation.conversationId);
+                }
+                break;
+            }
+            case 'node.runtime.snapshot': {
+                registry.heartbeat(msg.nodeId);
+                db.prepare(`UPDATE nodes SET last_seen = ?, status = 'online' WHERE node_id = ?`)
+                    .run(msg.generatedAt, msg.nodeId);
+                const snapshotProcessInstanceId = typeof msg.processInstanceId === 'string' && msg.processInstanceId.trim()
+                    ? msg.processInstanceId.trim()
+                    : connectionProcessInstanceId;
+                if (connectionProcessInstanceId
+                    && snapshotProcessInstanceId
+                    && snapshotProcessInstanceId !== connectionProcessInstanceId) {
+                    log.warn('[node-ws] ignoring runtime snapshot from mismatched node process', {
+                        nodeId: msg.nodeId,
+                        connectionProcessInstanceId,
+                        snapshotProcessInstanceId,
+                    });
+                    break;
+                }
+                persistNodeRuntimeSnapshot(db, {
+                    nodeId: msg.nodeId,
+                    processInstanceId: snapshotProcessInstanceId,
+                    snapshotAt: msg.generatedAt,
+                    runtime: msg.runtime,
+                });
+                break;
+            }
+            case 'asset.materialized': {
+                if (!nodeId) {
+                    log.debug('[node-ws] ignoring asset.materialized before node registration', { assetId: msg.assetId });
+                    break;
+                }
+                const assetId = msg.assetId?.trim();
+                const agentId = msg.agentId?.trim();
+                const conversationId = msg.conversationId?.trim();
+                const nodeProcessInstanceId = msg.nodeProcessInstanceId?.trim();
+                const hostKey = msg.hostKey?.trim();
+                const hostInstanceId = msg.hostInstanceId?.trim();
+                const localPath = msg.localPath?.trim();
+                if (!assetId
+                    || !agentId
+                    || !conversationId
+                    || !nodeProcessInstanceId
+                    || !hostKey
+                    || !hostInstanceId
+                    || !localPath
+                    || !path.isAbsolute(localPath)) {
+                    log.warn('[node-ws] ignoring invalid asset.materialized payload', { assetId, agentId, conversationId, hostKey });
+                    break;
+                }
+                const currentNode = db.prepare(`SELECT process_instance_id as processInstanceId
+             FROM nodes
+            WHERE node_id = ?`).get(nodeId);
+                if (currentNode?.processInstanceId !== nodeProcessInstanceId) {
+                    log.warn('[node-ws] ignoring asset.materialized for stale node process', {
+                        assetId,
+                        nodeId,
+                        nodeProcessInstanceId,
+                        currentProcessInstanceId: currentNode?.processInstanceId ?? null,
+                    });
+                    break;
+                }
+                const conversation = manager.getConversation(conversationId);
+                if (!conversation || conversation.agentId !== agentId || conversation.nodeId !== nodeId) {
+                    log.warn('[node-ws] ignoring asset.materialized for mismatched conversation', {
+                        assetId,
+                        agentId,
+                        conversationId,
+                        nodeId,
+                    });
+                    break;
+                }
+                const expectedHost = manager.getConversationHostKey(conversationId);
+                if (!expectedHost || expectedHost.nodeId !== nodeId || expectedHost.hostKey !== hostKey) {
+                    log.warn('[node-ws] ignoring asset.materialized for mismatched host binding', {
+                        assetId,
+                        conversationId,
+                        nodeId,
+                        hostKey,
+                        expectedHostKey: expectedHost?.hostKey ?? null,
+                        expectedNodeId: expectedHost?.nodeId ?? null,
+                    });
+                    break;
+                }
+                const assetExists = !!db.prepare(`SELECT 1 FROM attachments WHERE id = ?`).get(assetId);
+                if (!assetExists) {
+                    log.warn('[node-ws] ignoring asset.materialized for unknown asset', { assetId, conversationId });
+                    break;
+                }
+                if (msg.runId) {
+                    const runMatchesConversation = !!db.prepare(`SELECT 1
+               FROM runs r
+               JOIN conversations c ON c.session_key = r.session_key
+              WHERE r.run_id = ?
+                AND c.id = ?`).get(msg.runId, conversationId);
+                    if (!runMatchesConversation) {
+                        log.warn('[node-ws] ignoring asset.materialized for mismatched run', {
+                            assetId,
+                            runId: msg.runId,
+                            conversationId,
+                        });
+                        break;
+                    }
+                }
+                const materializedAt = Number.isFinite(msg.materializedAt) ? msg.materializedAt : Date.now();
+                const materializedNodeId = nodeId;
+                const materializedAssetId = assetId;
+                const materializedAgentId = agentId;
+                const materializedConversationId = conversationId;
+                const materializedNodeProcessInstanceId = nodeProcessInstanceId;
+                const materializedHostKey = hostKey;
+                const materializedHostInstanceId = hostInstanceId;
+                const materializedLocalPath = localPath;
+                db.transaction(() => {
+                    upsertMaterializedHostSnapshot(db, {
+                        nodeId: materializedNodeId,
+                        hostKey: materializedHostKey,
+                        hostInstanceId: materializedHostInstanceId,
+                        conversationId: materializedConversationId,
+                        runId: msg.runId ?? null,
+                        snapshotAt: materializedAt,
+                    });
+                    recordAssetMaterialized(db, {
+                        assetId: materializedAssetId,
+                        agentId: materializedAgentId,
+                        conversationId: materializedConversationId,
+                        nodeId: materializedNodeId,
+                        nodeProcessInstanceId: materializedNodeProcessInstanceId,
+                        hostKey: materializedHostKey,
+                        hostInstanceId: materializedHostInstanceId,
+                        runId: msg.runId ?? null,
+                        localPath: materializedLocalPath,
+                        materializedAt,
+                    });
+                })();
+                break;
+            }
+            case 'asset.materialization.cleared': {
+                if (!nodeId)
+                    break;
+                const hostKey = msg.hostKey?.trim();
+                const hostInstanceId = msg.hostInstanceId?.trim();
+                const nodeProcessInstanceId = msg.nodeProcessInstanceId?.trim();
+                if (!hostKey || !hostInstanceId || !nodeProcessInstanceId)
+                    break;
+                const currentNode = db.prepare(`SELECT process_instance_id as processInstanceId
+             FROM nodes
+            WHERE node_id = ?`).get(nodeId);
+                if (currentNode?.processInstanceId !== nodeProcessInstanceId) {
+                    log.debug('[node-ws] ignoring asset.materialization.cleared for stale node process', {
+                        nodeId,
+                        hostKey,
+                        hostInstanceId,
+                    });
+                    break;
+                }
+                markAssetMaterializationsClearedForHost(db, {
+                    nodeId,
+                    hostKey,
+                    hostInstanceId,
+                    clearedAt: Number.isFinite(msg.clearedAt) ? msg.clearedAt : Date.now(),
+                });
+                break;
+            }
+            case 'mission.run.accepted': {
+                if (!nodeId)
+                    break;
+                if (msg.runtimeProvider === 'bigbang_native') {
+                    nativeMissionWorkerBroker?.handleAccepted(msg, nodeId);
+                    break;
+                }
+                const attempt = droidMissionBroker?.handleAccepted(msg, nodeId);
+                if (!attempt)
+                    break;
+                if (attempt.interaction) {
+                    missionService?.recordMissionRuntimeEvent({
+                        missionId: msg.missionId,
+                        eventType: 'mission_interaction_accepted',
+                        source: 'agent_node',
+                        eventTime: Date.now(),
+                        payload: {
+                            missionDir: msg.missionDir,
+                            pid: msg.pid ?? null,
+                            requestId: msg.requestId,
+                        },
+                    });
+                }
+                else {
+                    missionService?.markMissionAccepted({
+                        missionId: msg.missionId,
+                        missionDir: msg.missionDir,
+                        pid: msg.pid,
+                        requestId: msg.requestId,
+                    });
+                }
+                break;
+            }
+            case 'mission.run.event': {
+                if (!nodeId)
+                    break;
+                if (msg.runtimeProvider === 'bigbang_native') {
+                    nativeMissionWorkerBroker?.handleEvent(msg, nodeId);
+                    break;
+                }
+                if (!droidMissionBroker?.verifyEvent(msg, nodeId))
+                    break;
+                missionService?.recordMissionRuntimeEvent({
+                    missionId: msg.missionId,
+                    eventType: msg.eventType,
+                    source: msg.source,
+                    eventTime: msg.eventTime,
+                    payload: {
+                        ...msg.payload,
+                        requestId: msg.requestId,
+                    },
+                });
+                break;
+            }
+            case 'mission.run.end': {
+                if (!nodeId)
+                    break;
+                if (msg.runtimeProvider === 'bigbang_native') {
+                    nativeMissionWorkerBroker?.handleEnd(msg, nodeId);
+                    break;
+                }
+                const attempt = droidMissionBroker?.handleEnd(msg, nodeId);
+                if (!attempt)
+                    break;
+                if (attempt.interaction) {
+                    const failed = Boolean(msg.error) || (msg.exitCode != null && msg.exitCode !== 0) || Boolean(msg.signal);
+                    missionService?.recordMissionRuntimeEvent({
+                        missionId: msg.missionId,
+                        eventType: failed ? 'mission_interaction_failed' : 'mission_interaction_completed',
+                        source: 'agent_node',
+                        eventTime: Date.now(),
+                        payload: {
+                            missionDir: msg.missionDir,
+                            factorySessionId: msg.factorySessionId ?? null,
+                            factoryArtifactDir: msg.factoryArtifactDir ?? null,
+                            exitCode: msg.exitCode ?? null,
+                            signal: msg.signal ?? null,
+                            error: msg.error ?? null,
+                            requestId: msg.requestId,
+                        },
+                    });
+                }
+                else {
+                    missionService?.finishDroidMission({
+                        missionId: msg.missionId,
+                        missionDir: msg.missionDir,
+                        factorySessionId: msg.factorySessionId,
+                        factoryArtifactDir: msg.factoryArtifactDir,
+                        exitCode: msg.exitCode,
+                        signal: msg.signal,
+                        error: msg.error,
+                        requestId: msg.requestId,
+                    });
+                }
+                break;
+            }
+            case 'mission.continuation.inspect.response': {
+                if (!nodeId)
+                    break;
+                droidMissionBroker?.handleContinuationInspectResponse(msg, nodeId);
+                break;
+            }
+            case 'run.accepted': {
+                const workspaceRun = getWorkspaceRunContext(db, msg.runId);
+                if (workspaceRun) {
+                    if (workspaceRun.endedAt != null) {
+                        log.debug('[node-ws] ignoring late workspace run.accepted for ended run', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                        });
+                        break;
+                    }
+                    if (!workspaceRunBelongsToCurrentNode(db, msg.runId, nodeId)) {
+                        log.debug('[node-ws] ignoring workspace run.accepted from non-owner node', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                            nodeId,
+                        });
+                        break;
+                    }
+                    if (!workspaceSessionRuntimeService?.handleRunAccepted(msg.runId)) {
+                        log.debug('[node-ws] ignoring workspace run.accepted without pending waiter', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                        });
+                    }
+                    break;
+                }
+                const accepted = manager.handleRunAccepted(msg.runId, msg.conversationId);
+                if (!accepted) {
+                    log.debug('[node-ws] ignoring late run.accepted without pending waiter', {
+                        runId: msg.runId,
+                        conversationId: msg.conversationId,
+                    });
+                    break;
+                }
+                broadcastWithChannelForward(msg.conversationId, {
+                    type: 'conversation.status',
+                    conversationId: msg.conversationId,
+                    status: 'active',
+                });
+                const handoff = markConversationHandoffAccepted(db, {
+                    targetConversationId: msg.conversationId,
+                    targetRunId: msg.runId,
+                });
+                if (handoff) {
+                    insertHandoffRun(db, {
+                        handoffId: handoff.handoffId,
+                        runId: msg.runId,
+                        agentId: handoff.agentId,
+                        disposition: 'accepted',
+                    });
+                }
+                refreshHandoffSummaries(handoff, msg.conversationId);
+                break;
+            }
+            case 'run.steer.result': {
+                const handled = manager.handleRunSteerResult(msg);
+                if (!handled) {
+                    log.debug('[node-ws] ignoring late run.steer.result without pending waiter', {
+                        requestId: msg.requestId,
+                        runId: msg.runId,
+                        conversationId: msg.conversationId,
+                        ok: msg.ok,
+                    });
+                }
+                break;
+            }
+            case 'run.delivery.ack': {
+                const handled = manager.handleRunDeliveryAck(msg);
+                if (!handled) {
+                    log.debug('[node-ws] ignoring unknown run.delivery.ack', {
+                        deliveryId: msg.deliveryId,
+                        roundId: msg.roundId,
+                        runId: msg.runId,
+                        conversationId: msg.conversationId,
+                        mode: msg.mode,
+                    });
+                }
+                break;
+            }
+            case 'run.event': {
+                log.debug('[node-ws] run.event', { conversationId: msg.conversationId, eventType: msg.event.type });
+                const workspaceRun = getWorkspaceRunContext(db, msg.runId);
+                if (workspaceRun) {
+                    if (workspaceRun.endedAt != null) {
+                        log.debug('[node-ws] ignoring workspace run.event for ended run', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                            eventType: msg.event.type,
+                        });
+                        break;
+                    }
+                    if (!workspaceRunBelongsToCurrentNode(db, msg.runId, nodeId)) {
+                        log.debug('[node-ws] ignoring workspace run.event from non-owner node', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                            eventType: msg.event.type,
+                            nodeId,
+                        });
+                        break;
+                    }
+                    if (msg.event.type === 'conversation.status') {
+                        if (msg.event.status !== 'awaiting_approval') {
+                            promoteWorkspaceSentApprovalResponses(db, msg.runId);
+                        }
+                        updateWorkspaceSessionStatus(db, workspaceRun.workspaceSessionId, hasOpenPendingWorkspaceApproval(db, workspaceRun.sessionKey) ? 'awaiting_approval' : msg.event.status);
+                        break;
+                    }
+                    const broadcastEvent = buildBroadcastNodeEvent(msg.event);
+                    if (REPLAY_EVENT_TYPES.has(msg.event.type)) {
+                        if (isWorkspaceApprovalProgressEvent(broadcastEvent)) {
+                            promoteWorkspaceSentApprovalResponses(db, msg.runId);
+                        }
+                        const seq = nextNodeEventSeq(db, msg.runId, runSeq);
+                        runSeq.set(msg.runId, seq);
+                        appendNodeEvent(db, msg.runId, seq, broadcastEvent);
+                        if (isWorkspaceApprovalProgressEvent(broadcastEvent)) {
+                            updateWorkspaceSessionStatus(db, workspaceRun.workspaceSessionId, hasOpenPendingWorkspaceApproval(db, workspaceRun.sessionKey) ? 'awaiting_approval' : 'active');
+                        }
+                    }
+                    break;
+                }
+                if (msg.event.type === 'conversation.status') {
+                    db.prepare('UPDATE conversations SET status = ?, updated_at = ? WHERE id = ?')
+                        .run(msg.event.status, Date.now(), msg.conversationId);
+                    broadcastWithChannelForward(msg.conversationId, msg.event);
+                    break;
+                }
+                // Silently discard events for runs that no longer exist (deleted by reset/clear-chat)
+                const runKnown = !!(db.prepare('SELECT 1 FROM runs WHERE run_id = ?').get(msg.runId));
+                if (!runKnown) {
+                    log.debug('[node-ws] ignoring run.event for unknown/deleted run', { runId: msg.runId });
+                    break;
+                }
+                const broadcastEvent = buildBroadcastNodeEvent(msg.event);
+                if (broadcastEvent.type === 'runtime.compact') {
+                    recordCodexCompactEvent(db, msg.conversationId, broadcastEvent);
+                }
+                broadcastWithChannelForward(msg.conversationId, broadcastEvent);
+                if (broadcastEvent.type === 'run.steer.result') {
+                    const handled = manager.handleRunSteerResult({
+                        requestId: broadcastEvent.requestId,
+                        runId: msg.runId,
+                        conversationId: msg.conversationId,
+                        ok: broadcastEvent.ok,
+                        ...(broadcastEvent.error ? { error: broadcastEvent.error } : {}),
+                    });
+                    if (!handled) {
+                        log.debug('[node-ws] ignoring run.event steer result without pending waiter', {
+                            requestId: broadcastEvent.requestId,
+                            runId: msg.runId,
+                            conversationId: msg.conversationId,
+                            ok: broadcastEvent.ok,
+                        });
+                    }
+                }
+                // Persist replay-worthy events to core DB immediately
+                if (REPLAY_EVENT_TYPES.has(msg.event.type)) {
+                    const seq = nextNodeEventSeq(db, msg.runId, runSeq);
+                    runSeq.set(msg.runId, seq);
+                    appendNodeEvent(db, msg.runId, seq, broadcastEvent);
+                    if (nodeId) {
+                        agentFileAccessService?.recordEventAccesses({
+                            nodeId,
+                            conversationId: msg.conversationId,
+                            runId: msg.runId,
+                            event: broadcastEvent,
+                        });
+                    }
+                }
+                break;
+            }
+            case 'run.end': {
+                log.info('[node-ws] run.end', { runId: msg.runId, conversationId: msg.conversationId, error: msg.error ?? null });
+                runSeq.delete(msg.runId);
+                const workspaceRun = getWorkspaceRunContext(db, msg.runId);
+                if (workspaceRun) {
+                    if (workspaceRun.endedAt != null) {
+                        log.debug('[node-ws] ignoring workspace run.end for already ended run', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                        });
+                        break;
+                    }
+                    if (!workspaceRunBelongsToCurrentNode(db, msg.runId, nodeId)) {
+                        log.debug('[node-ws] ignoring workspace run.end from non-owner node', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                            nodeId,
+                        });
+                        break;
+                    }
+                    promoteWorkspaceSentApprovalResponses(db, msg.runId);
+                    finishRun(db, msg.error
+                        ? { runId: msg.runId, error: msg.error }
+                        : { runId: msg.runId, stopReason: msg.stopReason ?? 'end_turn' });
+                    updateWorkspaceSessionStatus(db, workspaceRun.workspaceSessionId, resolveWorkspaceSessionStatus(db, workspaceRun.sessionKey, {
+                        openStatus: 'queued',
+                        closedStatus: msg.error ? 'failed' : 'idle',
+                    }));
+                    break;
+                }
+                // Check if this run still exists in core's DB.
+                // After reset/clear-chat the run rows are deleted — ignore stale run.end messages
+                // so they don't overwrite the conversation status set by the reset operation.
+                const runExists = !!(db
+                    .prepare('SELECT 1 FROM runs WHERE run_id = ?')
+                    .get(msg.runId));
+                if (!runExists) {
+                    log.warn('[node-ws] ignoring run.end for unknown/deleted run', { runId: msg.runId });
+                    manager.rejectPendingSteersForRun(msg.runId, msg.conversationId, 'Run ended before active-turn steer was acknowledged.');
+                    void manager.onConversationSettled(msg.conversationId);
+                    break;
+                }
+                manager.rejectPendingSteersForRun(msg.runId, msg.conversationId, 'Run ended before active-turn steer was acknowledged.');
+                manager.handleRunFinished(msg.runId, msg.conversationId, {
+                    error: msg.error ?? null,
+                    stopReason: msg.stopReason ?? null,
+                });
+                const handedOff = isCancelStopReason(msg.stopReason) && wasRunHandedOff(db, msg.runId);
+                const expectedBootstrapStopReason = isCancelStopReason(msg.stopReason)
+                    ? getExpectedBootstrapStopReason(db, msg.runId)
+                    : null;
+                const runEndError = getRunEndError(msg, db, msg.conversationId, msg.runId, handedOff, expectedBootstrapStopReason);
+                let handoff = null;
+                if (msg.error) {
+                    handoff = markConversationHandoffFailed(db, {
+                        targetConversationId: msg.conversationId,
+                        targetRunId: msg.runId,
+                        error: runEndError,
+                    });
+                }
+                else if (isCancelStopReason(msg.stopReason) && !handedOff && !expectedBootstrapStopReason) {
+                    handoff = markConversationHandoffCancelled(db, {
+                        targetConversationId: msg.conversationId,
+                        targetRunId: msg.runId,
+                        error: runEndError ?? null,
+                    });
+                }
+                else if (runEndError) {
+                    handoff = markConversationHandoffFailed(db, {
+                        targetConversationId: msg.conversationId,
+                        targetRunId: msg.runId,
+                        error: runEndError,
+                    });
+                }
+                else if (!handedOff) {
+                    handoff = markConversationHandoffCompleted(db, {
+                        targetConversationId: msg.conversationId,
+                        targetRunId: msg.runId,
+                    });
+                }
+                if (handoff) {
+                    insertHandoffRun(db, {
+                        handoffId: handoff.handoffId,
+                        runId: msg.runId,
+                        agentId: handoff.agentId,
+                        disposition: handoff.status === 'failed'
+                            ? 'failed'
+                            : handoff.status === 'cancelled'
+                                ? 'cancelled'
+                                : 'completed',
+                    });
+                }
+                if ((!msg.error || isWorkspaceToolPublishFallbackRecoverableRunEndError(msg.error))
+                    && !isCancelStopReason(msg.stopReason)) {
+                    const toolPublishFallbackResult = persistPendingWorkspaceToolPublishFallback({
+                        db,
+                        conversationId: msg.conversationId,
+                        runId: msg.runId,
+                        broadcast: broadcastWithChannelForward,
+                        manager,
+                    });
+                    if (toolPublishFallbackResult.emittedCount > 0 || toolPublishFallbackResult.updatedCount > 0) {
+                        log.info('[node-ws] surfaced workspace tool publish fallback attachment', {
+                            conversationId: msg.conversationId,
+                            runId: msg.runId,
+                            emittedCount: toolPublishFallbackResult.emittedCount,
+                            updatedCount: toolPublishFallbackResult.updatedCount,
+                            toolIds: toolPublishFallbackResult.toolIds,
+                        });
+                    }
+                    const fallbackResult = persistDeltaFallbackMessages({
+                        db,
+                        conversationId: msg.conversationId,
+                        runId: msg.runId,
+                        broadcast: broadcastWithChannelForward,
+                        manager,
+                        agentFileAccessService,
+                    });
+                    if (fallbackResult.emittedCount > 0) {
+                        log.info('[node-ws] emitted delta fallback messages', {
+                            conversationId: msg.conversationId,
+                            runId: msg.runId,
+                            count: fallbackResult.emittedCount,
+                        });
+                    }
+                    if (fallbackResult.suppressedCount > 0) {
+                        log.info('[node-ws] suppressed delta fallback messages', {
+                            conversationId: msg.conversationId,
+                            runId: msg.runId,
+                            count: fallbackResult.suppressedCount,
+                            reason: fallbackResult.suppressedReason ?? 'unknown',
+                        });
+                    }
+                }
+                finishConversationRun({
+                    db,
+                    broadcast: broadcastWithChannelForward,
+                    manager,
+                    conversationId: msg.conversationId,
+                    runId: msg.runId,
+                    stopReason: handedOff ? 'handoff' : (expectedBootstrapStopReason ?? msg.stopReason),
+                    error: runEndError ?? undefined,
+                    onRunFinished,
+                });
+                clearTaskThreadReopenedRunBlock(msg.conversationId, msg.runId);
+                refreshHandoffSummaries(handoff, msg.conversationId);
+                break;
+            }
+            case 'run.debug.snapshot': {
+                const workspaceRun = getWorkspaceRunContext(db, msg.runId);
+                if (workspaceRun) {
+                    if (workspaceRun.endedAt != null) {
+                        log.debug('[node-ws] ignoring workspace run.debug.snapshot for ended run', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                        });
+                        break;
+                    }
+                    if (workspaceRun.sessionKey !== msg.sessionKey) {
+                        log.debug('[node-ws] ignoring workspace run.debug.snapshot with mismatched session key', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                        });
+                        break;
+                    }
+                    if (!workspaceRunBelongsToCurrentNode(db, msg.runId, nodeId)) {
+                        log.debug('[node-ws] ignoring workspace run.debug.snapshot from non-owner node', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                            nodeId,
+                        });
+                        break;
+                    }
+                }
+                applyRunDebugSnapshot(db, {
+                    runId: msg.runId,
+                    conversationId: msg.conversationId,
+                    sessionKey: msg.sessionKey,
+                    acpSessionId: msg.acpSessionId,
+                    isFreshSession: msg.isFreshSession,
+                    isExact: msg.isExact,
+                    effectiveSystemPromptText: msg.effectiveSystemPromptText,
+                    effectiveContextText: msg.effectiveContextText,
+                });
+                break;
+            }
+            case 'permission.request': {
+                const approvalEvent = {
+                    type: 'approval.request',
+                    requestId: msg.requestId,
+                    toolName: msg.toolName,
+                    toolArgs: msg.toolArgs,
+                    toolKind: msg.toolKind,
+                    ...(msg.approvalKind ? { approvalKind: msg.approvalKind } : {}),
+                    ...(msg.title ? { title: msg.title } : {}),
+                    ...(msg.description ? { description: msg.description } : {}),
+                    ...(msg.input !== undefined ? { input: msg.input } : {}),
+                    ...(msg.actions?.length ? { actions: msg.actions } : {}),
+                };
+                const workspaceRun = getWorkspaceRunContext(db, msg.runId);
+                if (workspaceRun) {
+                    if (workspaceRun.endedAt != null) {
+                        log.debug('[node-ws] ignoring workspace permission.request for ended run', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                            requestId: msg.requestId,
+                        });
+                        break;
+                    }
+                    if (!workspaceRunBelongsToCurrentNode(db, msg.runId, nodeId)) {
+                        log.debug('[node-ws] ignoring workspace permission.request from non-owner node', {
+                            runId: msg.runId,
+                            workspaceSessionId: workspaceRun.workspaceSessionId,
+                            requestId: msg.requestId,
+                            nodeId,
+                        });
+                        break;
+                    }
+                    updateWorkspaceSessionStatus(db, workspaceRun.workspaceSessionId, 'awaiting_approval');
+                    const runKnown = !!db.prepare('SELECT 1 FROM runs WHERE run_id = ?').get(msg.runId);
+                    if (runKnown) {
+                        const seq = nextNodeEventSeq(db, msg.runId, runSeq);
+                        runSeq.set(msg.runId, seq);
+                        appendNodeEvent(db, msg.runId, seq, approvalEvent);
+                    }
+                    break;
+                }
+                if (msg.approvalKind === 'plan') {
+                    const planText = getPlanTextFromApprovalRequest(msg);
+                    if (planText) {
+                        upsertPlanApprovalMessage({
+                            db,
+                            manager,
+                            conversationId: msg.conversationId,
+                            runId: msg.runId,
+                            planText,
+                            broadcast: broadcastWithChannelForward,
+                            agentFileAccessService,
+                        });
+                    }
+                }
+                db.prepare('UPDATE conversations SET status = ?, updated_at = ? WHERE id = ?')
+                    .run('awaiting_approval', Date.now(), msg.conversationId);
+                broadcastWithChannelForward(msg.conversationId, {
+                    type: 'conversation.status',
+                    conversationId: msg.conversationId,
+                    status: 'awaiting_approval',
+                });
+                broadcastPrimaryDmTaskRootStatusProjection({
+                    db,
+                    broadcast: broadcastWithChannelForward,
+                    manager,
+                    threadConversationId: msg.conversationId,
+                    taskThreadStatus: 'awaiting_approval',
+                });
+                const runKnown = !!db.prepare('SELECT 1 FROM runs WHERE run_id = ?').get(msg.runId);
+                if (runKnown) {
+                    const seq = nextNodeEventSeq(db, msg.runId, runSeq);
+                    runSeq.set(msg.runId, seq);
+                    appendNodeEvent(db, msg.runId, seq, approvalEvent);
+                }
+                broadcastWithChannelForward(msg.conversationId, approvalEvent);
+                break;
+            }
+            case 'workspace.list.response': {
+                workspaceBroker?.handleWorkspaceListResponse(msg);
+                break;
+            }
+            case 'workspace.inspect.response': {
+                inspectBroker?.handleInspectResponse(msg);
+                break;
+            }
+            case 'workspace.git_status.response': {
+                gitBroker?.handleGitStatusResponse(msg);
+                break;
+            }
+            case 'workspace.git_diff.response': {
+                gitBroker?.handleGitDiffResponse(msg);
+                break;
+            }
+            case 'workspace.git_action.response': {
+                gitBroker?.handleGitActionResponse(msg);
+                break;
+            }
+            case 'workspace.read.response': {
+                workspaceBroker?.handleWorkspaceReadResponse(msg);
+                break;
+            }
+            case 'workspace.archive.response': {
+                workspaceBroker?.handleWorkspaceArchiveResponse(msg);
+                break;
+            }
+            case 'workspace.extract.response': {
+                workspaceBroker?.handleWorkspaceExtractResponse(msg);
+                break;
+            }
+            case 'library.mirror.apply.response': {
+                workspaceBroker?.handleLibraryMirrorApplyResponse(msg);
+                break;
+            }
+            case 'library.mirror.snapshot.response': {
+                workspaceBroker?.handleLibraryMirrorSnapshotResponse(msg);
+                break;
+            }
+            case 'library.authority.delete.response': {
+                workspaceBroker?.handleLibraryAuthorityDeleteResponse(msg);
+                break;
+            }
+            case 'library.authority.rename.response': {
+                workspaceBroker?.handleLibraryAuthorityRenameResponse(msg);
+                break;
+            }
+            case 'fs.read_path.response': {
+                workspaceBroker?.handleFsReadPathResponse(msg);
+                break;
+            }
+            case 'fs.path_suggest.response': {
+                workspaceBroker?.handleFsPathSuggestResponse(msg);
+                break;
+            }
+            case 'http.fetch_text.response': {
+                workspaceBroker?.handleHttpFetchTextResponse(msg);
+                break;
+            }
+            case 'workspace.service_proxy.response': {
+                workspaceBroker?.handleWorkspaceServiceProxyResponse(msg);
+                break;
+            }
+            case 'fs.read_path.stream.start': {
+                workspaceBroker?.handleFsReadPathStreamStart(msg);
+                break;
+            }
+            case 'fs.read_path.stream.chunk': {
+                workspaceBroker?.handleFsReadPathStreamChunk(msg);
+                break;
+            }
+            case 'fs.read_path.stream.end': {
+                workspaceBroker?.handleFsReadPathStreamEnd(msg);
+                break;
+            }
+            case 'workspace.write.response': {
+                workspaceBroker?.handleWorkspaceWriteResponse(msg);
+                break;
+            }
+            case 'workspace.delete_file.response': {
+                workspaceBroker?.handleWorkspaceDeleteFileResponse(msg);
+                break;
+            }
+            case 'workspace.delete_path.response': {
+                workspaceBroker?.handleWorkspaceDeletePathResponse(msg);
+                break;
+            }
+            case 'workspace.reset.response': {
+                workspaceBroker?.handleWorkspaceResetResponse(msg);
+                break;
+            }
+            case 'agent.cleanup.response': {
+                agentRuntimeCleanupBroker?.handleCleanupResponse(msg);
+                break;
+            }
+            case 'terminal.list.response': {
+                terminalBroker?.handleListResponse(msg);
+                break;
+            }
+            case 'terminal.create.response': {
+                terminalBroker?.handleCreateResponse(msg);
+                break;
+            }
+            case 'terminal.snapshot.response': {
+                terminalBroker?.handleSnapshotResponse(msg);
+                break;
+            }
+            case 'terminal.input.response': {
+                terminalBroker?.handleInputResponse(msg);
+                break;
+            }
+            case 'terminal.resize.response': {
+                terminalBroker?.handleResizeResponse(msg);
+                break;
+            }
+            case 'terminal.close.response': {
+                terminalBroker?.handleCloseResponse(msg);
+                break;
+            }
+            case 'terminal.output.event': {
+                terminalBroker?.handleOutputEvent(msg);
+                break;
+            }
+            case 'terminal.exit.event': {
+                terminalBroker?.handleExitEvent(msg);
+                break;
+            }
+            case 'skills.list.response': {
+                skillsBroker?.handleSkillsListResponse(msg);
+                break;
+            }
+            case 'skills.read.response': {
+                skillsBroker?.handleSkillsReadResponse(msg);
+                break;
+            }
+            case 'codex.transcript.list.response': {
+                codexTranscriptBroker?.handleListResponse(msg);
+                break;
+            }
+            case 'codex.transcript.read.response': {
+                codexTranscriptBroker?.handleReadResponse(msg);
+                break;
+            }
+            case 'claude.transcript.list.response': {
+                claudeTranscriptBroker?.handleListResponse(msg);
+                break;
+            }
+            case 'claude.transcript.read.response': {
+                claudeTranscriptBroker?.handleReadResponse(msg);
+                break;
+            }
+            case 'claude.controls.response': {
+                claudeControlBroker?.handleControlsResponse(msg);
+                break;
+            }
+            case 'claude.set_mode.response': {
+                claudeControlBroker?.handleSetModeResponse(msg);
+                break;
+            }
+            case 'claude.set_model.response': {
+                claudeControlBroker?.handleSetModelResponse(msg);
+                break;
+            }
+            case 'claude.command.response': {
+                claudeControlBroker?.handleCommandResponse(msg);
+                break;
+            }
+            case 'codex.model.list.response': {
+                codexAppServerBroker?.handleModelListResponse(msg);
+                break;
+            }
+            case 'codex.skills.list.response': {
+                codexAppServerBroker?.handleSkillsListResponse(msg);
+                break;
+            }
+            case 'codex.thread.list.response': {
+                codexAppServerBroker?.handleThreadListResponse(msg);
+                break;
+            }
+            case 'codex.thread.read.response': {
+                codexAppServerBroker?.handleThreadReadResponse(msg);
+                break;
+            }
+            case 'codex.conversation.summary.response': {
+                codexAppServerBroker?.handleConversationSummaryResponse(msg);
+                break;
+            }
+            case 'solo.run.event':
+            case 'solo.run.end':
+            case 'solo.permission.request': {
+                if (!soloSessionRelay?.relayNodeMessage(msg)) {
+                    log.debug('[node-ws] solo message with no active client relay', {
+                        type: msg.type,
+                        soloSessionId: msg.soloSessionId,
+                    });
+                }
+                break;
+            }
+            default: {
+                log.warn('[node-ws] unknown message type', msg.type);
+            }
+        }
+    });
+    socket.on('close', () => {
+        if (nodeId) {
+            if (isStaleNodeConnection()) {
+                log.debug('[node-ws] ignoring stale socket close for replaced node connection', {
+                    nodeId,
+                    connectionProcessInstanceId,
+                });
+                return;
+            }
+            const disconnectMessage = `Agent node disconnected: ${nodeId}`;
+            failNodeOwnedRuntimeState({
+                nodeId,
+                disconnectMessage,
+                unregisterNode: true,
+                markNodeOffline: true,
+            });
+            log.info(`[node-ws] disconnected: ${nodeId}`);
+        }
+    });
+    socket.on('error', (err) => {
+        log.warn('[node-ws] socket error', err);
+    });
+}