@bbigbang/core 0.1.0

package/dist/web/conversationManager.js

@@ -0,0 +1,2511 @@
+import { randomUUID } from 'node:crypto';
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import { BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL, buildThreadShortId, normalizeAgentDisabledToolKinds, normalizeThreadShortIdInput, parseAgentPermissionKind, } from '@bbigbang/protocol';
+import { log, createSession, upsertBinding, } from '@bbigbang/runtime-acp';
+import { getRuntimeDriver } from '@bbigbang/protocol';
+import { ExecutionDispatcher } from '../execution/executionDispatcher.js';
+import { parseDreamScheduleHourMinute } from '../scheduler/dreamLogic.js';
+import { getPlatformDirectReplyScope, isPlatformAgentRole } from '../services/platformAgentPolicy.js';
+import { ensureDmThreadContextSnapshot } from './activationContext.js';
+import { deriveSurfaceKind, parseSurfaceKind } from './conversationSurfaceKinds.js';
+import { buildClearedTaskRootArchiveTarget, CHANNEL_TASK_ROOT_PRESERVED_SOURCE, } from './clearedTaskRoots.js';
+import { findThreadRootMessageId, resolveThreadRootLookup } from './threadRoots.js';
+import { clearAgentMentionCooldownsForChannelChatClear } from './agentMentionCooldowns.js';
+import { deleteTargetParticipantsForAgent, deleteTargetParticipantsForAgentInChannel, deleteTargetParticipantsForChannel, } from './targetParticipants.js';
+import { buildDirectReplyTarget, resolveDirectUserName } from './directReplyTargets.js';
+import { appendTaskEvent, deleteTaskEventsForChannel } from './taskEvents.js';
+import { refreshConversationSummary } from './conversationSummaries.js';
+import { ackNotificationDelivery, deleteAgentNotificationV2State, deleteNotificationV2StateForChannel, deleteNotificationV2StateForThreadRoots, } from './notificationRounds.js';
+import { clearRollingSummaryStateForAgent, clearRollingSummaryStateForConversation, maybeRotateCodexConversationAfterSettlement, } from './rollingConversationSummary.js';
+import { deletePeerInboxAggregatesForAgent, deletePeerInboxAggregatesForChannel, } from './peerInboxAggregates.js';
+import { parseConversationBuiltinSkillRoots, serializeConversationBuiltinSkillRoots, } from './conversationBuiltinSkillRoots.js';
+import { hardDeletePanelRowsForConversation, hardDeletePanelsForConversation, unlinkPanelAttachmentStoragePaths, } from './panelLifecycle.js';
+import { listEffectiveAgentRuntimeCapabilities } from './runtimeCapabilities.js';
+function slugifyAgentName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/[\s_]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 40);
+}
+function normalizeAgentName(name) {
+    return name.trim().toLowerCase();
+}
+function normalizeChannelThreadRootId(threadRootId) {
+    return normalizeThreadShortIdInput(threadRootId);
+}
+function normalizeUiPanelEnabled(value) {
+    return value === true || value === 1 || value === '1';
+}
+const UI_PANEL_ENABLED_SELECT_SQL = `CASE
+  WHEN instr(COALESCE(builtin_skill_roots, ''), '${BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL}') > 0 THEN 1
+  ELSE ui_panel_enabled
+END as uiPanelEnabled`;
+export class AgentRuntimeSupportError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class AgentNameConflictError extends Error {
+    statusCode;
+    constructor(message = 'Agent name already exists') {
+        super(message);
+        this.statusCode = 409;
+    }
+}
+export class AgentConfigValidationError extends Error {
+    statusCode;
+    constructor(message) {
+        super(message);
+        this.statusCode = 400;
+    }
+}
+export class ConversationManager {
+    db;
+    config;
+    nodeRegistry;
+    codexAppServerBroker;
+    agentRuntimeCleanupBroker;
+    executionDispatcher;
+    deletingAgentIds = new Set();
+    constructor(params) {
+        this.db = params.db;
+        this.config = params.config;
+        this.nodeRegistry = params.nodeRegistry;
+        this.codexAppServerBroker = params.codexAppServerBroker;
+        this.agentRuntimeCleanupBroker = params.agentRuntimeCleanupBroker;
+        this.executionDispatcher = new ExecutionDispatcher({
+            db: params.db,
+            config: params.config,
+            nodeRegistry: params.nodeRegistry,
+            getAgentById: (agentId) => this.getAgent(agentId),
+        });
+    }
+    setLibraryService(libraryService) {
+        this.executionDispatcher.setLibraryService(libraryService);
+    }
+    beginAgentDeletion(agentId) {
+        if (this.deletingAgentIds.has(agentId)) {
+            throw new Error('Agent deletion is already in progress.');
+        }
+        if (!this.getAgent(agentId))
+            return false;
+        this.deletingAgentIds.add(agentId);
+        return true;
+    }
+    finishAgentDeletion(agentId) {
+        this.deletingAgentIds.delete(agentId);
+    }
+    isAgentDeletionInProgress(agentId) {
+        return !!agentId && this.deletingAgentIds.has(agentId);
+    }
+    assertAgentNotDeleting(agentId) {
+        if (this.isAgentDeletionInProgress(agentId)) {
+            throw new Error('Agent deletion is in progress.');
+        }
+    }
+    getDb() {
+        return this.db;
+    }
+    getConfig() {
+        return this.config;
+    }
+    start() {
+        this.backfillConversationReplyTargets();
+        this.recoverSteerAcks();
+        log.info('ConversationManager ready');
+    }
+    close() {
+        this.executionDispatcher.close();
+    }
+    // ─── Agent CRUD ───
+    createAgent(params) {
+        const agentId = randomUUID();
+        const agentType = params.agentType ?? 'codex_app_server';
+        const name = params.name.trim();
+        this.assertNodeSupportsAgentType(params.nodeId, agentType);
+        this.assertAgentNameAvailable(name);
+        const model = params.model?.trim() || null;
+        const reasoningEffort = params.reasoningEffort?.trim() || null;
+        const claudePermissionMode = agentType === 'claude_sdk' ? normalizeClaudePermissionMode(params.claudePermissionMode) : null;
+        const codexMode = agentType === 'codex_app_server' ? normalizeCodexMode(params.codexMode) : null;
+        const codexServiceTier = agentType === 'codex_app_server' ? normalizeCodexServiceTier(params.codexServiceTier) : null;
+        const channelId = params.channelId ?? 'default';
+        const envVarsJson = params.envVars && Object.keys(params.envVars).length > 0
+            ? JSON.stringify(params.envVars)
+            : null;
+        const disabledToolKinds = normalizeAgentDisabledToolKinds(agentType, params.disabledToolKinds);
+        const disabledToolKindsJson = disabledToolKinds && disabledToolKinds.length > 0
+            ? JSON.stringify(disabledToolKinds)
+            : null;
+        const skillRoots = normalizeSkillRootsForStorage(params.skillRoots);
+        const skillRootsJson = skillRoots && skillRoots.length > 0
+            ? JSON.stringify(skillRoots)
+            : null;
+        const now = Date.now();
+        const workspacePath = params.workspacePath
+            ?? path.join(os.homedir(), '.bigbang', 'agents', `${agentId}-${slugifyAgentName(name)}`);
+        fs.mkdirSync(workspacePath, { recursive: true });
+        const projectPath = params.projectPath?.trim() || null;
+        const description = params.description?.trim() || null;
+        this.db.prepare(`INSERT INTO agents(agent_id, name, agent_type, agent_role, model, reasoning_effort, claude_permission_mode, codex_mode, codex_service_tier, channel_id, system_prompt, description, memory, env_vars, disabled_tool_kinds, node_id, workspace_path, project_path, skill_roots, enabled_skill_paths, created_at, updated_at)
+       VALUES(?, ?, ?, 'user', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(agentId, name, agentType, model, reasoningEffort, claudePermissionMode, codexMode, codexServiceTier, channelId, params.systemPrompt ?? '', description, '', envVarsJson, disabledToolKindsJson, params.nodeId ?? null, workspacePath, projectPath, skillRootsJson, null, now, now);
+        this.db.prepare(`INSERT OR IGNORE INTO agent_channel_memberships(agent_id, channel_id, is_home, joined_at)
+       VALUES(?, ?, 1, ?)`).run(agentId, channelId, now);
+        return {
+            agentId, name, agentType, ...(model ? { model } : {}), ...(reasoningEffort ? { reasoningEffort } : {}),
+            ...(claudePermissionMode ? { claudePermissionMode } : {}),
+            ...(codexMode ? { codexMode } : {}), ...(codexServiceTier ? { codexServiceTier } : {}),
+            channelId, channelIds: [channelId],
+            systemPrompt: params.systemPrompt ?? '',
+            ...(description ? { description } : {}),
+            envVars: params.envVars, disabledToolKinds, nodeId: params.nodeId ?? null,
+            workspacePath, projectPath,
+            skillRoots,
+            skillSelectionMode: 'legacy_all',
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    assertNodeSupportsAgentType(nodeId, agentType) {
+        const normalizedNodeId = nodeId?.trim();
+        if (!normalizedNodeId)
+            return;
+        const supportedAgentTypes = this.getKnownNodeAgentTypes(normalizedNodeId);
+        if (!supportedAgentTypes || supportedAgentTypes.length === 0)
+            return;
+        if (supportedAgentTypes.includes(agentType))
+            return;
+        throw new AgentRuntimeSupportError(400, `Node does not support agent type ${agentType}: ${normalizedNodeId}`);
+    }
+    getKnownNodeAgentTypes(nodeId) {
+        const liveAgentTypes = normalizeAgentTypeList(this.nodeRegistry?.getNode(nodeId)?.agentTypes);
+        if (liveAgentTypes.length > 0) {
+            return liveAgentTypes;
+        }
+        const row = this.db.prepare(`SELECT agent_types_json as agentTypesJson
+       FROM nodes
+       WHERE node_id = ?`).get(nodeId);
+        if (!row?.agentTypesJson)
+            return null;
+        try {
+            return normalizeAgentTypeList(JSON.parse(row.agentTypesJson));
+        }
+        catch {
+            return null;
+        }
+    }
+    listAgents(channelId, options) {
+        const roleFilter = options?.includeLibraryCurators
+            ? ''
+            : ` AND COALESCE(a.agent_role, 'user') = 'user'`;
+        const sql = channelId
+            ? `SELECT a.agent_id as agentId, a.name, COALESCE(a.agent_role, 'user') as agentRole, a.agent_type as agentType, a.model, a.reasoning_effort as reasoningEffort,
+                a.claude_permission_mode as claudePermissionMode, a.channel_id as channelId,
+                a.codex_mode as codexMode, a.codex_service_tier as codexServiceTier,
+                a.system_prompt as systemPrompt, a.description,
+                a.env_vars as envVarsJson, a.disabled_tool_kinds as disabledToolKindsJson,
+                a.node_id as nodeId, a.workspace_path as workspacePath, a.project_path as projectPath,
+                a.skill_roots as skillRootsJson, a.enabled_skill_paths as enabledSkillPathsJson,
+                a.memory_network_enabled as memoryNetworkEnabled,
+                a.dream_enabled as dreamEnabled, a.dream_schedule as dreamSchedule,
+                a.dream_min_messages as dreamMinMessages, a.last_dream_at as lastDreamAt, a.last_dream_seq as lastDreamSeq,
+                a.deleted_at as deletedAt, a.created_at as createdAt, a.updated_at as updatedAt
+         FROM agents a
+         JOIN agent_channel_memberships m ON m.agent_id = a.agent_id
+         WHERE m.channel_id = ? AND a.deleted_at IS NULL${roleFilter} ORDER BY a.updated_at DESC`
+            : `SELECT agent_id as agentId, name, COALESCE(agent_role, 'user') as agentRole, agent_type as agentType, model, reasoning_effort as reasoningEffort,
+                claude_permission_mode as claudePermissionMode, channel_id as channelId,
+                codex_mode as codexMode, codex_service_tier as codexServiceTier,
+                system_prompt as systemPrompt, description,
+                env_vars as envVarsJson, disabled_tool_kinds as disabledToolKindsJson,
+                node_id as nodeId, workspace_path as workspacePath, project_path as projectPath,
+                skill_roots as skillRootsJson, enabled_skill_paths as enabledSkillPathsJson,
+                memory_network_enabled as memoryNetworkEnabled,
+                dream_enabled as dreamEnabled, dream_schedule as dreamSchedule,
+                dream_min_messages as dreamMinMessages, last_dream_at as lastDreamAt, last_dream_seq as lastDreamSeq,
+                deleted_at as deletedAt, created_at as createdAt, updated_at as updatedAt
+         FROM agents WHERE deleted_at IS NULL${roleFilter.replace('a.', '')} ORDER BY updated_at DESC`;
+        const rows = channelId
+            ? this.db.prepare(sql).all(channelId)
+            : this.db.prepare(sql).all();
+        return rows.map((row) => this.rowToAgentInfo(row));
+    }
+    getAgent(agentId) {
+        const row = this.db.prepare(`SELECT agent_id as agentId, name, COALESCE(agent_role, 'user') as agentRole, agent_type as agentType, model, reasoning_effort as reasoningEffort,
+              claude_permission_mode as claudePermissionMode, channel_id as channelId,
+              codex_mode as codexMode, codex_service_tier as codexServiceTier,
+              system_prompt as systemPrompt, description,
+              env_vars as envVarsJson, disabled_tool_kinds as disabledToolKindsJson,
+              node_id as nodeId, workspace_path as workspacePath, project_path as projectPath,
+              skill_roots as skillRootsJson, enabled_skill_paths as enabledSkillPathsJson,
+              memory_network_enabled as memoryNetworkEnabled,
+              dream_enabled as dreamEnabled, dream_schedule as dreamSchedule,
+              dream_min_messages as dreamMinMessages, last_dream_at as lastDreamAt, last_dream_seq as lastDreamSeq,
+              deleted_at as deletedAt, created_at as createdAt, updated_at as updatedAt
+       FROM agents WHERE agent_id = ? AND deleted_at IS NULL`).get(agentId);
+        return row ? this.rowToAgentInfo(row) : null;
+    }
+    listActiveAgentIdsForNode(nodeId) {
+        const rows = this.db.prepare(`SELECT agent_id as agentId
+         FROM agents
+        WHERE node_id = ?
+          AND deleted_at IS NULL
+        ORDER BY updated_at DESC`).all(nodeId);
+        return rows.map((row) => row.agentId);
+    }
+    getAgentIncludingDeleted(agentId) {
+        const row = this.db.prepare(`SELECT agent_id as agentId, name, agent_type as agentType, model, reasoning_effort as reasoningEffort,
+              claude_permission_mode as claudePermissionMode, channel_id as channelId,
+              codex_mode as codexMode, codex_service_tier as codexServiceTier,
+              system_prompt as systemPrompt, description,
+              env_vars as envVarsJson, disabled_tool_kinds as disabledToolKindsJson,
+              node_id as nodeId, workspace_path as workspacePath, project_path as projectPath,
+              skill_roots as skillRootsJson, enabled_skill_paths as enabledSkillPathsJson,
+              deleted_at as deletedAt, created_at as createdAt, updated_at as updatedAt
+       FROM agents WHERE agent_id = ?`).get(agentId);
+        return row ? this.rowToAgentInfo(row) : null;
+    }
+    updateAgent(agentId, req) {
+        const existing = this.getAgent(agentId);
+        if (!existing)
+            return null;
+        const existingStorage = this.db.prepare(`SELECT disabled_tool_kinds as disabledToolKindsJson,
+              enabled_skill_paths as enabledSkillPathsJson
+         FROM agents
+        WHERE agent_id = ?`).get(agentId);
+        const now = Date.now();
+        const name = typeof req.name === 'string' ? req.name.trim() : existing.name;
+        if (normalizeAgentName(name) !== normalizeAgentName(existing.name)) {
+            this.assertAgentNameAvailable(name, agentId);
+        }
+        const agentType = existing.agentType;
+        const systemPrompt = req.systemPrompt ?? existing.systemPrompt;
+        const description = 'description' in req ? (req.description?.trim() || null) : (existing.description ?? null);
+        const model = 'model' in req ? (req.model?.trim() || null) : (existing.model ?? null);
+        const reasoningEffort = 'reasoningEffort' in req ? (req.reasoningEffort?.trim() || null) : (existing.reasoningEffort ?? null);
+        const claudePermissionMode = agentType === 'claude_sdk'
+            ? ('claudePermissionMode' in req ? normalizeClaudePermissionMode(req.claudePermissionMode) : (existing.claudePermissionMode ?? null))
+            : null;
+        const codexMode = agentType === 'codex_app_server'
+            ? ('codexMode' in req ? normalizeCodexMode(req.codexMode) : (existing.codexMode ?? null))
+            : null;
+        const codexServiceTier = agentType === 'codex_app_server'
+            ? ('codexServiceTier' in req ? normalizeCodexServiceTier(req.codexServiceTier) : (existing.codexServiceTier ?? null))
+            : null;
+        const envVars = req.envVars ?? existing.envVars;
+        const disabledToolKinds = 'disabledToolKinds' in req
+            ? normalizeAgentDisabledToolKinds(agentType, req.disabledToolKinds)
+            : existing.disabledToolKinds;
+        const skillRoots = 'skillRoots' in req ? normalizeSkillRootsForStorage(req.skillRoots) : existing.skillRoots;
+        const storedEnabledSkillPaths = parseStringArray(existingStorage?.enabledSkillPathsJson ?? null);
+        const shouldRefreshStoredEnabledSkillPaths = !('enabledSkillPaths' in req)
+            && 'skillRoots' in req
+            && existingStorage?.enabledSkillPathsJson != null;
+        const enabledSkillPaths = 'enabledSkillPaths' in req
+            ? normalizeEnabledSkillPaths(req.enabledSkillPaths, skillRoots)
+            : shouldRefreshStoredEnabledSkillPaths
+                ? retainEnabledSkillPathsWithinRoots(storedEnabledSkillPaths ?? [], skillRoots)
+                : storedEnabledSkillPaths;
+        const channelId = req.channelId ?? existing.channelId;
+        const projectPath = 'projectPath' in req ? (req.projectPath?.trim() || null) : (existing.projectPath ?? null);
+        const envVarsJson = envVars && Object.keys(envVars).length > 0
+            ? JSON.stringify(envVars)
+            : null;
+        const disabledToolKindsJson = 'disabledToolKinds' in req
+            ? (disabledToolKinds && disabledToolKinds.length > 0 ? JSON.stringify(disabledToolKinds) : null)
+            : existingStorage?.disabledToolKindsJson ?? null;
+        const skillRootsJson = skillRoots && skillRoots.length > 0
+            ? JSON.stringify(skillRoots)
+            : null;
+        const enabledSkillPathsJson = ('enabledSkillPaths' in req || shouldRefreshStoredEnabledSkillPaths)
+            ? JSON.stringify(enabledSkillPaths ?? [])
+            : existingStorage?.enabledSkillPathsJson ?? null;
+        const memoryNetworkEnabled = 'memoryNetworkEnabled' in req
+            ? (req.memoryNetworkEnabled ? 1 : 0)
+            : (existing.memoryNetworkEnabled ? 1 : 0);
+        if (memoryNetworkEnabled === 1 && isPlatformAgentRole(existing.agentRole)) {
+            throw new AgentConfigValidationError('Memory Network cannot be enabled for platform agents');
+        }
+        let dreamEnabled = 'dreamEnabled' in req
+            ? (req.dreamEnabled ? 1 : 0)
+            : (existing.dreamEnabled ? 1 : 0);
+        if (memoryNetworkEnabled === 0) {
+            dreamEnabled = 0;
+        }
+        if (dreamEnabled === 1 && memoryNetworkEnabled === 0) {
+            throw new AgentConfigValidationError('Dream requires Memory Network to be enabled');
+        }
+        if (dreamEnabled === 1 && isPlatformAgentRole(existing.agentRole)) {
+            throw new AgentConfigValidationError('Dream cannot be enabled for platform agents');
+        }
+        const dreamSchedule = 'dreamSchedule' in req
+            ? (req.dreamSchedule?.trim() || '02:00')
+            : (existing.dreamSchedule ?? '02:00');
+        if (!parseDreamScheduleHourMinute(dreamSchedule)) {
+            throw new AgentConfigValidationError('Invalid dream schedule; expected HH:mm');
+        }
+        const dreamMinMessages = 'dreamMinMessages' in req
+            ? Math.max(1, Math.floor(req.dreamMinMessages ?? 5))
+            : (existing.dreamMinMessages ?? 5);
+        this.db.prepare(`UPDATE agents
+       SET name = ?, agent_type = ?, system_prompt = ?, description = ?, model = ?, reasoning_effort = ?, claude_permission_mode = ?, codex_mode = ?, codex_service_tier = ?, env_vars = ?, disabled_tool_kinds = ?, channel_id = ?, project_path = ?, skill_roots = ?, enabled_skill_paths = ?, memory_network_enabled = ?, dream_enabled = ?, dream_schedule = ?, dream_min_messages = ?, updated_at = ?
+       WHERE agent_id = ?`).run(name, agentType, systemPrompt, description, model, reasoningEffort, claudePermissionMode, codexMode, codexServiceTier, envVarsJson, disabledToolKindsJson, channelId, projectPath, skillRootsJson, enabledSkillPathsJson, memoryNetworkEnabled, dreamEnabled, dreamSchedule, dreamMinMessages, now, agentId);
+        // Migrate home channel membership if channelId changed
+        if (req.channelId && req.channelId !== existing.channelId) {
+            this.db.prepare(`UPDATE agent_channel_memberships SET is_home = 0 WHERE agent_id = ? AND channel_id = ?`).run(agentId, existing.channelId);
+            this.db.prepare(`INSERT INTO agent_channel_memberships(agent_id, channel_id, is_home, joined_at)
+         VALUES(?, ?, 1, ?)
+         ON CONFLICT(agent_id, channel_id) DO UPDATE SET is_home = 1`).run(agentId, channelId, now);
+        }
+        return this.getAgent(agentId) ?? {
+            ...existing,
+            name,
+            agentType,
+            systemPrompt,
+            description: description ?? undefined,
+            model: model ?? undefined,
+            reasoningEffort: reasoningEffort ?? undefined,
+            claudePermissionMode: claudePermissionMode ?? undefined,
+            codexMode: codexMode ?? undefined,
+            codexServiceTier: codexServiceTier ?? undefined,
+            envVars,
+            disabledToolKinds,
+            projectPath: projectPath ?? undefined,
+            skillRoots,
+            ...(enabledSkillPaths !== undefined ? { enabledSkillPaths } : {}),
+            skillSelectionMode: enabledSkillPathsJson == null ? 'legacy_all' : 'explicit',
+            memoryNetworkEnabled: memoryNetworkEnabled === 1,
+            dreamEnabled: dreamEnabled === 1,
+            dreamSchedule,
+            dreamMinMessages,
+            channelId,
+            updatedAt: now,
+        };
+    }
+    async dispatchDream(agentId) {
+        return this.executionDispatcher.dispatchDream(agentId);
+    }
+    deleteAgent(agentId) {
+        const existing = this.db.prepare(`SELECT deleted_at as deletedAt FROM agents WHERE agent_id = ?`).get(agentId);
+        if (!existing)
+            return { deletedConversations: 0 };
+        const rows = this.db.prepare(`SELECT id, session_key as sessionKey
+       FROM conversations WHERE agent_id = ?`).all(agentId);
+        const dmChannelId = `dm:${agentId}`;
+        const now = Date.now();
+        const dmAttachmentPaths = this.listAgentDmAttachmentPaths(agentId);
+        const panelAttachmentPaths = [];
+        for (const row of rows) {
+            this.cancelConversationRun(row.id);
+        }
+        this.db.transaction(() => {
+            this.deleteTaskThreadFollowupsForConversationIds(rows.map((row) => row.id));
+            for (const row of rows) {
+                const deletedPanels = hardDeletePanelRowsForConversation(this.db, row.id);
+                panelAttachmentPaths.push(...deletedPanels.storagePaths);
+                const bindingKeys = this.db.prepare(`SELECT binding_key as bindingKey FROM bindings WHERE session_key = ?`).all(row.sessionKey);
+                const runIds = this.db.prepare(`SELECT run_id as runId FROM runs WHERE session_key = ?`)
+                    .all(row.sessionKey);
+                this.db.prepare('DELETE FROM conversation_prompt_queue WHERE conversation_id = ?').run(row.id);
+                this.db.prepare('DELETE FROM run_debug_inputs WHERE conversation_id = ?').run(row.id);
+                for (const run of runIds) {
+                    this.db.prepare('DELETE FROM delivery_checkpoints WHERE run_id = ?').run(run.runId);
+                    this.db.prepare('DELETE FROM events WHERE run_id = ?').run(run.runId);
+                    this.db.prepare('DELETE FROM run_debug_inputs WHERE run_id = ?').run(run.runId);
+                }
+                this.db.prepare('DELETE FROM claude_session_user_messages WHERE session_key = ?').run(row.sessionKey);
+                this.db.prepare('DELETE FROM run_debug_inputs WHERE session_key = ?').run(row.sessionKey);
+                this.db.prepare('DELETE FROM runs WHERE session_key = ?').run(row.sessionKey);
+                for (const binding of bindingKeys) {
+                    this.db.prepare('DELETE FROM jobs WHERE binding_key = ?').run(binding.bindingKey);
+                    this.db.prepare('DELETE FROM tool_policies WHERE binding_key = ?').run(binding.bindingKey);
+                    this.db.prepare('DELETE FROM delivery_checkpoints WHERE binding_key = ?').run(binding.bindingKey);
+                    this.db.prepare('DELETE FROM ui_prefs WHERE binding_key = ?').run(binding.bindingKey);
+                    this.db.prepare('DELETE FROM tool_allow_prefixes WHERE binding_key = ?').run(binding.bindingKey);
+                }
+                this.db.prepare('DELETE FROM bindings WHERE session_key = ?').run(row.sessionKey);
+                this.db.prepare('DELETE FROM conversations WHERE id = ?').run(row.id);
+                this.db.prepare('DELETE FROM sessions WHERE session_key = ?').run(row.sessionKey);
+            }
+            const dmTaskIds = this.db.prepare(`SELECT task_id as taskId FROM tasks WHERE channel_id = ?`).all(dmChannelId).map((row) => row.taskId);
+            this.deleteTaskRuntimeStateForTaskIds(dmTaskIds);
+            this.db.prepare(`DELETE FROM tasks WHERE channel_id = ?`).run(dmChannelId);
+            deleteTaskEventsForChannel(this.db, dmChannelId);
+            this.db.prepare(`DELETE FROM channel_task_sequences WHERE channel_id = ?`).run(dmChannelId);
+            this.db.prepare(`DELETE FROM channel_messages WHERE channel_id = ?`).run(dmChannelId);
+            this.deleteTaskThreadFollowupsForChannel(dmChannelId);
+            deleteTargetParticipantsForChannel(this.db, dmChannelId);
+            this.deleteDmThreadContextSnapshotsForChannel(dmChannelId);
+            this.deleteAgentDmAttachmentRows(agentId);
+            this.unassignOpenChannelTasksForDeletedAgent(agentId, now);
+            this.db.prepare(`DELETE FROM conversation_prompt_queue WHERE agent_id = ?`).run(agentId);
+            this.db.prepare(`DELETE FROM conversation_summaries WHERE agent_id = ?`).run(agentId);
+            clearRollingSummaryStateForAgent(this.db, agentId);
+            this.db.prepare(`DELETE FROM conversation_handoffs WHERE agent_id = ?`).run(agentId);
+            this.db.prepare(`DELETE FROM run_pending_tool_attachments WHERE tool_id IN (
+        SELECT tool_id FROM workspace_tools WHERE agent_id = ?
+      )`).run(agentId);
+            this.db.prepare(`UPDATE workspace_tool_runs
+            SET status = CASE WHEN status = 'running' THEN 'failed' ELSE status END,
+                ended_at = CASE WHEN ended_at IS NULL AND status = 'running' THEN ? ELSE ended_at END,
+                terminal_id = CASE WHEN status = 'running' THEN NULL ELSE terminal_id END
+          WHERE tool_id IN (SELECT tool_id FROM workspace_tools WHERE agent_id = ?)`).run(now, agentId);
+            this.db.prepare(`UPDATE workspace_tools
+            SET slug = CASE
+                  WHEN deleted_at IS NULL AND slug NOT LIKE '__deleted__/%'
+                    THEN '__deleted__/' || tool_id || '/' || slug
+                  ELSE slug
+                END,
+                panel_id = NULL,
+                deleted_at = COALESCE(deleted_at, ?),
+                updated_at = ?,
+                active_terminal_id = NULL
+          WHERE agent_id = ?`).run(now, now, agentId);
+            this.db.prepare(`DELETE FROM agent_message_checkpoints WHERE agent_id = ?`).run(agentId);
+            this.db.prepare(`DELETE FROM agent_channel_memberships WHERE agent_id = ?`).run(agentId);
+            this.db.prepare(`DELETE FROM channel_subscriptions WHERE agent_id = ?`).run(agentId);
+            this.deleteWorkspaceSessionsForAgent(agentId);
+            this.db.prepare(`DELETE FROM agent_project_bindings WHERE agent_id = ?`).run(agentId);
+            this.db.prepare(`DELETE FROM workbench_workspace_agents WHERE agent_id = ?`).run(agentId);
+            this.db.prepare(`UPDATE workbench_workspaces
+         SET archived_at = COALESCE(archived_at, ?), updated_at = ?
+         WHERE agent_id = ?`).run(now, now, agentId);
+            this.db.prepare(`DELETE FROM agent_task_links WHERE agent_id = ?`).run(agentId);
+            this.db.prepare(`DELETE FROM task_participants WHERE agent_id = ?`).run(agentId);
+            deleteTargetParticipantsForAgent(this.db, agentId);
+            this.deleteAgentNotificationState(agentId);
+            this.db.prepare(`UPDATE agents
+         SET deleted_at = COALESCE(deleted_at, ?),
+             system_prompt = '',
+             description = NULL,
+             model = NULL,
+             reasoning_effort = NULL,
+             codex_mode = NULL,
+             codex_service_tier = NULL,
+             memory = '',
+             env_vars = NULL,
+             disabled_tool_kinds = NULL,
+             node_id = NULL,
+             workspace_path = NULL,
+             project_path = NULL,
+             skill_roots = NULL,
+             enabled_skill_paths = NULL,
+             updated_at = ?
+         WHERE agent_id = ?`).run(now, now, agentId);
+        })();
+        this.deleteAttachmentFiles(dmAttachmentPaths);
+        unlinkPanelAttachmentStoragePaths(panelAttachmentPaths);
+        return { deletedConversations: rows.length };
+    }
+    assertAgentNameAvailable(name, excludeAgentId) {
+        const normalizedName = normalizeAgentName(name);
+        if (!normalizedName)
+            return;
+        const rows = (excludeAgentId
+            ? this.db.prepare(`SELECT agent_id as agentId, name
+         FROM agents
+         WHERE deleted_at IS NULL
+           AND agent_id != ?`).all(excludeAgentId)
+            : this.db.prepare(`SELECT agent_id as agentId, name
+         FROM agents
+         WHERE deleted_at IS NULL`).all());
+        if (rows.some((row) => normalizeAgentName(row.name) === normalizedName)) {
+            throw new AgentNameConflictError();
+        }
+    }
+    listAgentDmAttachmentPaths(agentId) {
+        if (!this.tableExists('attachments'))
+            return [];
+        const rows = this.db.prepare(`SELECT DISTINCT storage_path as storagePath
+       FROM attachments
+       WHERE storage_path IS NOT NULL
+         AND (
+           channel_id = ?
+           OR channel_id LIKE ?
+           OR (agent_id = ? AND channel_id IS NULL AND user_id IS NULL)
+         )`).all(`dm:${agentId}`, `dm:${agentId}:%`, agentId);
+        return rows.map((row) => row.storagePath).filter((path) => !!path);
+    }
+    deleteAgentDmAttachmentRows(agentId) {
+        if (!this.tableExists('attachments'))
+            return;
+        this.db.prepare(`DELETE FROM attachments
+       WHERE channel_id = ?
+          OR channel_id LIKE ?
+          OR (agent_id = ? AND channel_id IS NULL AND user_id IS NULL)`).run(`dm:${agentId}`, `dm:${agentId}:%`, agentId);
+    }
+    deleteAttachmentFiles(paths) {
+        for (const storagePath of [...new Set(paths)]) {
+            try {
+                if (fs.existsSync(storagePath))
+                    fs.unlinkSync(storagePath);
+            }
+            catch (error) {
+                log.warn('[conversation-manager] failed to delete agent DM attachment file', {
+                    storagePath,
+                    error: String(error?.message ?? error),
+                });
+            }
+        }
+    }
+    deleteTaskRuntimeStateForTaskIds(taskIds) {
+        const uniqueTaskIds = [...new Set(taskIds.filter(Boolean))];
+        if (uniqueTaskIds.length === 0)
+            return;
+        const placeholders = uniqueTaskIds.map(() => '?').join(', ');
+        this.db.prepare(`DELETE FROM task_loop_events
+       WHERE loop_id IN (SELECT loop_id FROM task_loops WHERE task_id IN (${placeholders}))`).run(...uniqueTaskIds);
+        this.db.prepare(`DELETE FROM task_loop_iterations
+       WHERE loop_id IN (SELECT loop_id FROM task_loops WHERE task_id IN (${placeholders}))`).run(...uniqueTaskIds);
+        this.db.prepare(`DELETE FROM task_loops WHERE task_id IN (${placeholders})`).run(...uniqueTaskIds);
+        this.db.prepare(`DELETE FROM thread_task_bindings WHERE task_id IN (${placeholders})`).run(...uniqueTaskIds);
+        this.db.prepare(`DELETE FROM task_thread_followups WHERE task_id IN (${placeholders})`).run(...uniqueTaskIds);
+        this.db.prepare(`DELETE FROM task_participants WHERE task_id IN (${placeholders})`).run(...uniqueTaskIds);
+        this.db.prepare(`DELETE FROM agent_task_links WHERE task_id IN (${placeholders})`).run(...uniqueTaskIds);
+    }
+    unassignOpenChannelTasksForDeletedAgent(agentId, now) {
+        const rows = this.db.prepare(`SELECT task_id as taskId,
+              agent_task_ref as agentTaskRef,
+              channel_id as channelId,
+              task_number as taskNumber,
+              title,
+              status,
+              message_id as messageId
+       FROM tasks
+       WHERE claimed_by_agent_id = ?
+         AND channel_id != ?
+         AND status != 'done'`).all(agentId, `dm:${agentId}`);
+        if (rows.length === 0)
+            return;
+        for (const row of rows) {
+            appendTaskEvent(this.db, {
+                taskId: row.taskId,
+                agentTaskRef: row.agentTaskRef,
+                channelId: row.channelId,
+                taskNumber: row.taskNumber,
+                eventType: 'unclaimed',
+                actorType: 'system',
+                actorId: 'system',
+                actorName: 'system',
+                fromStatus: row.status,
+                toStatus: row.status,
+                claimedByAgentIdAfter: null,
+                claimedByNameAfter: null,
+                messageId: row.messageId,
+                createdAt: now,
+            });
+        }
+        const taskIds = rows.map((row) => row.taskId);
+        const placeholders = taskIds.map(() => '?').join(', ');
+        this.db.prepare(`UPDATE task_loop_iterations
+       SET status = 'cancelled',
+           ended_at = COALESCE(ended_at, ?),
+           updated_at = ?
+       WHERE status IN ('pending', 'running', 'awaiting_approval')
+         AND loop_id IN (
+           SELECT loop_id FROM task_loops
+           WHERE worker_agent_id = ? AND task_id IN (${placeholders})
+         )`).run(now, now, agentId, ...taskIds);
+        this.db.prepare(`UPDATE task_loops
+       SET worker_agent_id = NULL,
+           worker_conversation_id = NULL,
+           status = CASE
+             WHEN status IN ('succeeded', 'failed', 'stopped', 'cancelled') THEN status
+             ELSE 'stopped'
+           END,
+           stop_reason = COALESCE(stop_reason, 'worker_agent_deleted'),
+           completed_at = CASE
+             WHEN status IN ('succeeded', 'failed', 'stopped', 'cancelled') THEN completed_at
+             ELSE COALESCE(completed_at, ?)
+           END,
+           updated_at = ?
+       WHERE worker_agent_id = ?
+         AND task_id IN (${placeholders})`).run(now, now, agentId, ...taskIds);
+        this.db.prepare(`UPDATE tasks
+       SET claimed_by_agent_id = NULL,
+           claimed_by_name = NULL,
+           assigned_by_user = NULL,
+           updated_at = ?
+       WHERE task_id IN (${placeholders})`).run(now, ...taskIds);
+    }
+    deleteDmThreadContextSnapshotsForChannel(channelId) {
+        if (!this.tableExists('dm_thread_context_snapshots'))
+            return;
+        this.db.prepare(`DELETE FROM dm_thread_context_snapshots WHERE channel_id = ?`).run(channelId);
+    }
+    deleteAgentNotificationState(agentId) {
+        deleteAgentNotificationV2State(this.db, agentId);
+        deletePeerInboxAggregatesForAgent(this.db, agentId);
+        this.db.prepare(`DELETE FROM agent_mention_cooldowns
+       WHERE from_agent_id = ? OR to_agent_id = ?`).run(agentId, agentId);
+    }
+    tableExists(tableName) {
+        return !!this.db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1`).get(tableName);
+    }
+    withRuntimeCapabilities(conversation) {
+        return {
+            ...conversation,
+            runtimeCapabilities: listEffectiveAgentRuntimeCapabilities(this.db, {
+                nodeId: conversation.nodeId,
+                agentType: conversation.agentType,
+            }),
+        };
+    }
+    // ─── CRUD ───
+    createConversation(params) {
+        const id = randomUUID();
+        const userId = params.userId ?? null;
+        // If agentId provided, inherit agent's settings as defaults
+        const agent = params.agentId ? this.getAgent(params.agentId) : null;
+        const agentType = params.agentType ?? (agent?.agentType ?? 'codex_app_server');
+        const workspacePath = params.workspacePath ?? agent?.workspacePath ?? this.config.workspaceRoot;
+        const title = params.title ?? '';
+        const channelId = params.channelId ?? agent?.channelId ?? 'default';
+        const nodeId = params.nodeId ?? agent?.nodeId ?? null;
+        const threadKind = params.threadKind ?? 'direct';
+        const isPrimaryThread = params.isPrimaryThread ?? false;
+        const threadRootId = params.threadRootId ?? null;
+        const activeProjectId = 'activeProjectId' in params
+            ? this.resolveConversationActiveProjectId(params.agentId ?? null, params.activeProjectId ?? null)
+            : this.resolveDefaultConversationActiveProjectId(params.agentId ?? null);
+        const surfaceKind = deriveSurfaceKind(threadKind, threadRootId);
+        const replyTarget = this.computeReplyTarget({
+            conversationId: id,
+            channelId,
+            threadKind,
+            isPrimaryThread,
+            threadRootId,
+            userId,
+            title,
+        });
+        const envVarsJson = (() => {
+            const ev = params.envVars ?? agent?.envVars;
+            return ev && Object.keys(ev).length > 0 ? JSON.stringify(ev) : null;
+        })();
+        const now = Date.now();
+        const sessionKey = randomUUID();
+        const preset = getRuntimeDriver(agentType);
+        // Create session row
+        createSession(this.db, {
+            sessionKey,
+            agentCommand: preset.command,
+            agentArgs: preset.args,
+            cwd: workspacePath,
+            loadSupported: false,
+        });
+        // bindingKey = web:{channelId}:{conversationId}:{agentType}
+        // → each agent type in each thread gets its own isolated session
+        upsertBinding(this.db, { platform: 'web', chatId: channelId, threadId: id, userId: agentType }, sessionKey);
+        // Create conversations row
+        this.db
+            .prepare(`INSERT INTO conversations(id, channel_id, reply_target, title, agent_type, workspace_path, session_key, status, thread_kind, is_primary_thread, thread_root_id, surface_kind, env_vars, node_id, agent_id, user_id, active_project_id, history_reset_at, created_at, updated_at)
+         VALUES(?, ?, ?, ?, ?, ?, ?, 'idle', ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`)
+            .run(id, channelId, replyTarget, title, agentType, workspacePath, sessionKey, threadKind, isPrimaryThread ? 1 : 0, threadRootId, surfaceKind, envVarsJson, nodeId, params.agentId ?? null, userId, activeProjectId, now, now);
+        if (params.agentId) {
+            const createdAgent = this.getAgent(params.agentId);
+            if (createdAgent) {
+                refreshConversationSummary(this.db, createdAgent, id);
+            }
+        }
+        return this.withRuntimeCapabilities({
+            id,
+            channelId,
+            replyTarget,
+            title,
+            agentType,
+            threadKind,
+            isPrimaryThread,
+            threadRootId,
+            surfaceKind,
+            workspacePath,
+            status: 'idle',
+            createdAt: now,
+            updatedAt: now,
+            historyResetAt: null,
+            nodeId,
+            agentId: params.agentId ?? null,
+            userId,
+            activeProjectId,
+            uiPanelEnabled: false,
+        });
+    }
+    openAgentThread(agentId, userId, activeProjectId) {
+        this.assertAgentNotDeleting(agentId);
+        const agent = this.getAgent(agentId);
+        if (!agent)
+            return null;
+        // Look for existing primary thread for this (agent, user) pair
+        const existing = userId
+            ? this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                  reply_target as replyTarget,
+                  thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                  thread_root_id as threadRootId,
+                  surface_kind as surfaceKind,
+                  workspace_path as workspacePath, status, node_id as nodeId,
+                  agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                  ${UI_PANEL_ENABLED_SELECT_SQL},
+                  history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+           FROM conversations
+           WHERE agent_id = ? AND user_id = ? AND is_primary_thread = 1
+           ORDER BY updated_at DESC
+           LIMIT 1`).get(agentId, userId)
+            : this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                  reply_target as replyTarget,
+                  thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                  thread_root_id as threadRootId,
+                  surface_kind as surfaceKind,
+                  workspace_path as workspacePath, status, node_id as nodeId,
+                  agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                  ${UI_PANEL_ENABLED_SELECT_SQL},
+                  history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+           FROM conversations
+           WHERE agent_id = ? AND user_id IS NULL AND is_primary_thread = 1
+           ORDER BY updated_at DESC
+           LIMIT 1`).get(agentId);
+        if (existing) {
+            const resolvedActiveProjectId = activeProjectId === undefined
+                ? existing.activeProjectId ?? null
+                : this.resolveConversationActiveProjectId(agentId, activeProjectId);
+            const canonicalReplyTarget = this.computeReplyTarget({
+                conversationId: existing.id,
+                channelId: existing.channelId,
+                threadKind: existing.threadKind,
+                isPrimaryThread: !!existing.isPrimaryThread,
+                threadRootId: existing.threadRootId ?? null,
+                userId: existing.userId ?? null,
+                title: existing.title,
+            });
+            if ((existing.replyTarget ?? '').trim() !== canonicalReplyTarget || (existing.activeProjectId ?? null) !== resolvedActiveProjectId) {
+                this.db.prepare(`UPDATE conversations
+           SET reply_target = ?, surface_kind = ?, active_project_id = ?, updated_at = ?
+           WHERE id = ?`).run(canonicalReplyTarget, deriveSurfaceKind(existing.threadKind, existing.threadRootId ?? null), resolvedActiveProjectId, Date.now(), existing.id);
+                existing.replyTarget = canonicalReplyTarget;
+                existing.surfaceKind = deriveSurfaceKind(existing.threadKind, existing.threadRootId ?? null);
+                existing.activeProjectId = resolvedActiveProjectId;
+            }
+            return this.withRuntimeCapabilities({
+                ...existing,
+                isPrimaryThread: !!existing.isPrimaryThread,
+                surfaceKind: parseSurfaceKind(existing.surfaceKind, {
+                    threadKind: existing.threadKind,
+                    threadRootId: existing.threadRootId ?? null,
+                }),
+                userId: existing.userId ?? null,
+                activeProjectId: resolvedActiveProjectId,
+                uiPanelEnabled: normalizeUiPanelEnabled(existing.uiPanelEnabled),
+            });
+        }
+        // Create new per-user primary thread
+        return this.createConversation({
+            agentId,
+            agentType: agent.agentType,
+            workspacePath: agent.workspacePath ?? undefined,
+            channelId: agent.channelId,
+            nodeId: agent.nodeId ?? undefined,
+            threadKind: 'direct',
+            isPrimaryThread: true,
+            title: '',
+            userId: userId ?? null,
+            ...(activeProjectId !== undefined ? { activeProjectId } : {}),
+        });
+    }
+    openNamedAgentPrimaryThread(params) {
+        this.assertAgentNotDeleting(params.agentId);
+        const agent = this.getAgent(params.agentId);
+        if (!agent)
+            return null;
+        const title = params.title.trim();
+        if (!title) {
+            return this.openAgentThread(params.agentId, params.userId, params.activeProjectId);
+        }
+        const userId = params.userId ?? null;
+        const trimmedLegacyTitles = (params.legacyTitles ?? [])
+            .map((value) => value.trim())
+            .filter((value) => value && value !== title);
+        const existing = userId
+            ? this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                  reply_target as replyTarget,
+                  thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                  thread_root_id as threadRootId,
+                  surface_kind as surfaceKind,
+                  workspace_path as workspacePath, status, node_id as nodeId,
+                  agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                  ${UI_PANEL_ENABLED_SELECT_SQL},
+                  history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+           FROM conversations
+           WHERE agent_id = ? AND user_id = ? AND is_primary_thread = 1 AND title = ?
+           ORDER BY updated_at DESC
+           LIMIT 1`).get(params.agentId, userId, title)
+            : this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                  reply_target as replyTarget,
+                  thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                  thread_root_id as threadRootId,
+                  surface_kind as surfaceKind,
+                  workspace_path as workspacePath, status, node_id as nodeId,
+                  agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                  ${UI_PANEL_ENABLED_SELECT_SQL},
+                  history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+           FROM conversations
+           WHERE agent_id = ? AND user_id IS NULL AND is_primary_thread = 1 AND title = ?
+           ORDER BY updated_at DESC
+           LIMIT 1`).get(params.agentId, title);
+        const legacyExisting = !existing && trimmedLegacyTitles.length > 0
+            ? (() => {
+                const placeholders = trimmedLegacyTitles.map(() => '?').join(', ');
+                return userId
+                    ? this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                        reply_target as replyTarget,
+                        thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                        thread_root_id as threadRootId,
+                        surface_kind as surfaceKind,
+                        workspace_path as workspacePath, status, node_id as nodeId,
+                        agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                        ${UI_PANEL_ENABLED_SELECT_SQL},
+                        history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+                 FROM conversations
+                 WHERE agent_id = ? AND user_id = ? AND is_primary_thread = 1 AND title IN (${placeholders})
+                 ORDER BY updated_at DESC
+                 LIMIT 1`).get(params.agentId, userId, ...trimmedLegacyTitles)
+                    : this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                        reply_target as replyTarget,
+                        thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                        thread_root_id as threadRootId,
+                        surface_kind as surfaceKind,
+                        workspace_path as workspacePath, status, node_id as nodeId,
+                        agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                        ${UI_PANEL_ENABLED_SELECT_SQL},
+                        history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+                 FROM conversations
+                 WHERE agent_id = ? AND user_id IS NULL AND is_primary_thread = 1 AND title IN (${placeholders})
+                 ORDER BY updated_at DESC
+                 LIMIT 1`).get(params.agentId, ...trimmedLegacyTitles);
+            })()
+            : undefined;
+        const resolvedExisting = existing ?? legacyExisting;
+        if (resolvedExisting) {
+            const resolvedActiveProjectId = params.activeProjectId === undefined
+                ? resolvedExisting.activeProjectId ?? null
+                : this.resolveConversationActiveProjectId(params.agentId, params.activeProjectId);
+            const canonicalReplyTarget = this.computeReplyTarget({
+                conversationId: resolvedExisting.id,
+                channelId: resolvedExisting.channelId,
+                threadKind: resolvedExisting.threadKind,
+                isPrimaryThread: !!resolvedExisting.isPrimaryThread,
+                threadRootId: resolvedExisting.threadRootId ?? null,
+                userId: resolvedExisting.userId ?? null,
+                title,
+            });
+            if ((resolvedExisting.replyTarget ?? '').trim() !== canonicalReplyTarget
+                || (resolvedExisting.activeProjectId ?? null) !== resolvedActiveProjectId
+                || resolvedExisting.title !== title) {
+                this.db.prepare(`UPDATE conversations
+           SET reply_target = ?, surface_kind = ?, active_project_id = ?, title = ?, updated_at = ?
+           WHERE id = ?`).run(canonicalReplyTarget, deriveSurfaceKind(resolvedExisting.threadKind, resolvedExisting.threadRootId ?? null), resolvedActiveProjectId, title, Date.now(), resolvedExisting.id);
+                resolvedExisting.replyTarget = canonicalReplyTarget;
+                resolvedExisting.surfaceKind = deriveSurfaceKind(resolvedExisting.threadKind, resolvedExisting.threadRootId ?? null);
+                resolvedExisting.activeProjectId = resolvedActiveProjectId;
+                resolvedExisting.title = title;
+            }
+            return this.withRuntimeCapabilities({
+                ...resolvedExisting,
+                isPrimaryThread: !!resolvedExisting.isPrimaryThread,
+                surfaceKind: parseSurfaceKind(resolvedExisting.surfaceKind, {
+                    threadKind: resolvedExisting.threadKind,
+                    threadRootId: resolvedExisting.threadRootId ?? null,
+                }),
+                userId: resolvedExisting.userId ?? null,
+                activeProjectId: resolvedActiveProjectId,
+                uiPanelEnabled: normalizeUiPanelEnabled(resolvedExisting.uiPanelEnabled),
+            });
+        }
+        return this.createConversation({
+            agentId: params.agentId,
+            title,
+            threadKind: 'direct',
+            isPrimaryThread: true,
+            userId,
+            activeProjectId: params.activeProjectId,
+        });
+    }
+    openAgentDirectThread(agentId, userId, threadRootId, activeProjectId) {
+        this.assertAgentNotDeleting(agentId);
+        const agent = this.getAgent(agentId);
+        if (!agent)
+            return null;
+        const normalizedThreadRootId = normalizeChannelThreadRootId(threadRootId);
+        if (!normalizedThreadRootId)
+            return null;
+        const dmChannelId = `dm:${agentId}`;
+        const threadRootLookup = resolveThreadRootLookup(this.db, dmChannelId, normalizedThreadRootId);
+        const canonicalThreadRootId = threadRootLookup?.canonicalThreadRootId ?? normalizedThreadRootId;
+        const fallbackThreadRootId = buildThreadShortId(normalizedThreadRootId);
+        const equivalentThreadRootIds = new Set([normalizedThreadRootId, fallbackThreadRootId, canonicalThreadRootId].filter((value) => Boolean(value)));
+        const existingCandidates = userId
+            ? this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                  reply_target as replyTarget,
+                  thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                  thread_root_id as threadRootId,
+                  surface_kind as surfaceKind,
+                  workspace_path as workspacePath, status, node_id as nodeId,
+                  agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                  ${UI_PANEL_ENABLED_SELECT_SQL},
+                  history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+           FROM conversations
+           WHERE agent_id = ? AND user_id = ? AND thread_kind = 'direct' AND is_primary_thread = 0
+           ORDER BY updated_at DESC`).all(agentId, userId)
+            : this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                  reply_target as replyTarget,
+                  thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                  thread_root_id as threadRootId,
+                  surface_kind as surfaceKind,
+                  workspace_path as workspacePath, status, node_id as nodeId,
+                  agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                  ${UI_PANEL_ENABLED_SELECT_SQL},
+                  history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+           FROM conversations
+           WHERE agent_id = ? AND user_id IS NULL AND thread_kind = 'direct' AND is_primary_thread = 0
+           ORDER BY updated_at DESC`).all(agentId);
+        const existing = existingCandidates.find((candidate) => (typeof candidate.threadRootId === 'string' && equivalentThreadRootIds.has(candidate.threadRootId)));
+        if (existing) {
+            const resolvedActiveProjectId = activeProjectId === undefined
+                ? existing.activeProjectId ?? null
+                : this.resolveConversationActiveProjectId(agentId, activeProjectId);
+            const resolvedThreadRootId = canonicalThreadRootId ?? existing.threadRootId ?? normalizedThreadRootId;
+            const canonicalReplyTarget = this.computeReplyTarget({
+                conversationId: existing.id,
+                channelId: existing.channelId,
+                threadKind: existing.threadKind,
+                isPrimaryThread: false,
+                threadRootId: resolvedThreadRootId,
+                userId: existing.userId ?? userId ?? null,
+            });
+            if ((existing.replyTarget ?? '').trim() !== canonicalReplyTarget
+                || (existing.threadRootId ?? null) !== resolvedThreadRootId
+                || (existing.activeProjectId ?? null) !== resolvedActiveProjectId) {
+                this.db.prepare(`UPDATE conversations
+           SET reply_target = ?, thread_root_id = ?, surface_kind = ?, active_project_id = ?, updated_at = ?
+           WHERE id = ?`).run(canonicalReplyTarget, resolvedThreadRootId, deriveSurfaceKind(existing.threadKind, resolvedThreadRootId), resolvedActiveProjectId, Date.now(), existing.id);
+                existing.replyTarget = canonicalReplyTarget;
+                existing.threadRootId = resolvedThreadRootId;
+                existing.surfaceKind = deriveSurfaceKind(existing.threadKind, resolvedThreadRootId);
+                existing.activeProjectId = resolvedActiveProjectId;
+            }
+            return this.withRuntimeCapabilities({
+                ...existing,
+                isPrimaryThread: !!existing.isPrimaryThread,
+                threadRootId: existing.threadRootId ?? resolvedThreadRootId,
+                surfaceKind: parseSurfaceKind(existing.surfaceKind, {
+                    threadKind: existing.threadKind,
+                    threadRootId: existing.threadRootId ?? resolvedThreadRootId,
+                }),
+                userId: existing.userId ?? userId ?? null,
+                activeProjectId: resolvedActiveProjectId,
+                uiPanelEnabled: normalizeUiPanelEnabled(existing.uiPanelEnabled),
+            });
+        }
+        return this.createConversation({
+            agentId,
+            agentType: agent.agentType,
+            workspacePath: agent.workspacePath ?? undefined,
+            channelId: agent.channelId,
+            nodeId: agent.nodeId ?? undefined,
+            threadKind: 'direct',
+            isPrimaryThread: false,
+            threadRootId: canonicalThreadRootId,
+            title: '',
+            userId: userId ?? null,
+            ...(activeProjectId !== undefined ? { activeProjectId } : {}),
+        });
+    }
+    openAgentChannelThread(agentId, channelId, threadRootId, activeProjectId) {
+        this.assertAgentNotDeleting(agentId);
+        const agent = this.getAgent(agentId);
+        if (!agent)
+            return null;
+        const normalizedThreadRootId = normalizeChannelThreadRootId(threadRootId);
+        const threadRootLookup = normalizedThreadRootId
+            ? resolveThreadRootLookup(this.db, channelId, normalizedThreadRootId)
+            : null;
+        const canonicalThreadRootId = threadRootLookup?.canonicalThreadRootId ?? normalizedThreadRootId;
+        const fallbackThreadRootId = normalizedThreadRootId ? buildThreadShortId(normalizedThreadRootId) : null;
+        const equivalentThreadRootIds = new Set([normalizedThreadRootId, fallbackThreadRootId, canonicalThreadRootId].filter((value) => Boolean(value)));
+        const existing = (normalizedThreadRootId
+            ? this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                reply_target as replyTarget,
+                thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                thread_root_id as threadRootId,
+                surface_kind as surfaceKind,
+                workspace_path as workspacePath, status, node_id as nodeId,
+                agent_id as agentId, active_project_id as activeProjectId,
+                ${UI_PANEL_ENABLED_SELECT_SQL},
+                history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+         FROM conversations
+         WHERE agent_id = ? AND channel_id = ? AND thread_kind = 'branch'
+         ORDER BY updated_at DESC`).all(agentId, channelId).find((candidate) => (typeof candidate.threadRootId === 'string' && equivalentThreadRootIds.has(candidate.threadRootId)))
+            : this.db.prepare(`SELECT id, channel_id as channelId, title, agent_type as agentType,
+                reply_target as replyTarget,
+                thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                thread_root_id as threadRootId,
+                surface_kind as surfaceKind,
+                workspace_path as workspacePath, status, node_id as nodeId,
+                agent_id as agentId, active_project_id as activeProjectId,
+                ${UI_PANEL_ENABLED_SELECT_SQL},
+                history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+         FROM conversations
+         WHERE agent_id = ? AND channel_id = ? AND thread_kind = 'branch' AND thread_root_id IS NULL
+         ORDER BY updated_at DESC
+         LIMIT 1`).get(agentId, channelId));
+        if (existing) {
+            const resolvedActiveProjectId = activeProjectId === undefined
+                ? existing.activeProjectId ?? null
+                : this.resolveConversationActiveProjectId(agentId, activeProjectId);
+            const resolvedThreadRootId = canonicalThreadRootId ?? existing.threadRootId ?? normalizedThreadRootId;
+            const canonicalReplyTarget = this.computeReplyTarget({
+                conversationId: existing.id,
+                channelId: existing.channelId,
+                threadKind: existing.threadKind,
+                isPrimaryThread: false,
+                threadRootId: resolvedThreadRootId,
+            });
+            if ((existing.replyTarget ?? '').trim() !== canonicalReplyTarget
+                || (existing.threadRootId ?? null) !== resolvedThreadRootId
+                || (existing.activeProjectId ?? null) !== resolvedActiveProjectId) {
+                this.db.prepare(`UPDATE conversations
+              SET reply_target = ?, thread_root_id = ?, surface_kind = ?, active_project_id = ?, updated_at = ?
+            WHERE id = ?`).run(canonicalReplyTarget, resolvedThreadRootId, deriveSurfaceKind(existing.threadKind, resolvedThreadRootId), resolvedActiveProjectId, Date.now(), existing.id);
+                existing.replyTarget = canonicalReplyTarget;
+                existing.threadRootId = resolvedThreadRootId;
+                existing.surfaceKind = deriveSurfaceKind(existing.threadKind, resolvedThreadRootId);
+                existing.activeProjectId = resolvedActiveProjectId;
+            }
+            return this.withRuntimeCapabilities({
+                ...existing,
+                isPrimaryThread: !!existing.isPrimaryThread,
+                threadRootId: existing.threadRootId ?? resolvedThreadRootId,
+                surfaceKind: parseSurfaceKind(existing.surfaceKind, {
+                    threadKind: existing.threadKind,
+                    threadRootId: existing.threadRootId ?? resolvedThreadRootId,
+                }),
+                activeProjectId: resolvedActiveProjectId,
+                uiPanelEnabled: normalizeUiPanelEnabled(existing.uiPanelEnabled),
+            });
+        }
+        return this.createConversation({
+            agentId,
+            agentType: agent.agentType,
+            workspacePath: agent.workspacePath ?? undefined,
+            channelId,
+            nodeId: agent.nodeId ?? undefined,
+            threadKind: 'branch',
+            isPrimaryThread: false,
+            threadRootId: canonicalThreadRootId,
+            title: '',
+            ...(activeProjectId !== undefined ? { activeProjectId } : {}),
+        });
+    }
+    listConversations(filter) {
+        const convSelect = `SELECT id, channel_id as channelId, reply_target as replyTarget, title, agent_type as agentType,
+                thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                thread_root_id as threadRootId,
+                surface_kind as surfaceKind,
+                workspace_path as workspacePath, status, node_id as nodeId,
+                agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                ${UI_PANEL_ENABLED_SELECT_SQL},
+                history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+         FROM conversations`;
+        const mapRows = (rows) => rows.map((row) => this.withRuntimeCapabilities({
+            ...row,
+            isPrimaryThread: !!row.isPrimaryThread,
+            threadRootId: row.threadRootId ?? null,
+            surfaceKind: parseSurfaceKind(row.surfaceKind, {
+                threadKind: row.threadKind,
+                threadRootId: row.threadRootId ?? null,
+            }),
+            historyResetAt: row.historyResetAt ?? null,
+            userId: row.userId ?? null,
+            activeProjectId: row.activeProjectId ?? null,
+            uiPanelEnabled: normalizeUiPanelEnabled(row.uiPanelEnabled),
+        }));
+        if (filter?.channelId && filter?.agentId) {
+            return mapRows(this.db.prepare(`${convSelect} WHERE channel_id = ? AND agent_id = ? ORDER BY is_primary_thread DESC, updated_at DESC`)
+                .all(filter.channelId, filter.agentId));
+        }
+        if (filter?.channelId) {
+            return mapRows(this.db.prepare(`${convSelect} WHERE channel_id = ? ORDER BY updated_at DESC`)
+                .all(filter.channelId));
+        }
+        if (filter?.agentId) {
+            return mapRows(this.db.prepare(`${convSelect} WHERE agent_id = ? ORDER BY is_primary_thread DESC, updated_at DESC`)
+                .all(filter.agentId));
+        }
+        // Top-level list: apply per-user DM filter
+        // Real channel threads (branch in non-default channel) are shared; everything else is per-user
+        if (filter?.userId) {
+            if (filter.isAdmin) {
+                // Admin: real channel branches (shared) + their own DMs + legacy NULL-user DMs
+                return mapRows(this.db.prepare(`${convSelect} WHERE (
+            (thread_kind = 'branch' AND channel_id != 'default')
+            OR user_id = ?
+            OR user_id IS NULL
+          ) ORDER BY updated_at DESC`).all(filter.userId));
+            }
+            else {
+                // Regular user: real channel branches (shared) + their own DMs only
+                return mapRows(this.db.prepare(`${convSelect} WHERE (
+            (thread_kind = 'branch' AND channel_id != 'default')
+            OR user_id = ?
+          ) ORDER BY updated_at DESC`).all(filter.userId));
+            }
+        }
+        return mapRows(this.db.prepare(`${convSelect} ORDER BY updated_at DESC`).all());
+    }
+    getConversation(id) {
+        const row = this.db
+            .prepare(`SELECT id, channel_id as channelId, reply_target as replyTarget, title, agent_type as agentType,
+                thread_kind as threadKind, is_primary_thread as isPrimaryThread,
+                thread_root_id as threadRootId,
+                surface_kind as surfaceKind,
+                workspace_path as workspacePath, status, node_id as nodeId,
+                agent_id as agentId, user_id as userId, active_project_id as activeProjectId,
+                ${UI_PANEL_ENABLED_SELECT_SQL},
+                history_reset_at as historyResetAt, created_at as createdAt, updated_at as updatedAt
+         FROM conversations WHERE id = ?`)
+            .get(id);
+        return row
+            ? this.withRuntimeCapabilities({
+                ...row,
+                isPrimaryThread: !!row.isPrimaryThread,
+                threadRootId: row.threadRootId ?? null,
+                surfaceKind: parseSurfaceKind(row.surfaceKind, {
+                    threadKind: row.threadKind,
+                    threadRootId: row.threadRootId ?? null,
+                }),
+                historyResetAt: row.historyResetAt ?? null,
+                userId: row.userId ?? null,
+                activeProjectId: row.activeProjectId ?? null,
+                uiPanelEnabled: normalizeUiPanelEnabled(row.uiPanelEnabled),
+            })
+            : null;
+    }
+    enableBuiltinSkillRootForConversation(conversationId, builtinSkillRoot) {
+        const row = this.db.prepare(`SELECT builtin_skill_roots as builtinSkillRootsJson
+         FROM conversations
+        WHERE id = ?`).get(conversationId);
+        if (!row)
+            return;
+        const mergedBuiltinSkillRoots = serializeConversationBuiltinSkillRoots([
+            ...parseConversationBuiltinSkillRoots(row.builtinSkillRootsJson),
+            builtinSkillRoot,
+        ]);
+        this.db.prepare(`UPDATE conversations
+          SET builtin_skill_roots = ?,
+              updated_at = ?
+        WHERE id = ?`).run(mergedBuiltinSkillRoots, Date.now(), conversationId);
+    }
+    disableBuiltinSkillRootForConversation(conversationId, builtinSkillRoot) {
+        const row = this.db.prepare(`SELECT builtin_skill_roots as builtinSkillRootsJson
+         FROM conversations
+        WHERE id = ?`).get(conversationId);
+        if (!row)
+            return;
+        const roots = parseConversationBuiltinSkillRoots(row.builtinSkillRootsJson);
+        const filtered = roots.filter((r) => r !== builtinSkillRoot);
+        this.db.prepare(`UPDATE conversations
+          SET builtin_skill_roots = ?,
+              updated_at = ?
+        WHERE id = ?`).run(serializeConversationBuiltinSkillRoots(filtered), Date.now(), conversationId);
+    }
+    setUiPanelEnabledForConversation(conversationId, enabled) {
+        const row = this.db.prepare(`SELECT builtin_skill_roots as builtinSkillRootsJson
+         FROM conversations
+        WHERE id = ?`).get(conversationId);
+        if (!row)
+            return;
+        let roots = parseConversationBuiltinSkillRoots(row.builtinSkillRootsJson);
+        if (enabled) {
+            if (!roots.includes(BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL)) {
+                roots = [...roots, BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL];
+            }
+        }
+        else {
+            roots = roots.filter((r) => r !== BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL);
+        }
+        this.db.prepare(`UPDATE conversations
+          SET ui_panel_enabled = ?,
+              builtin_skill_roots = ?,
+              updated_at = ?
+        WHERE id = ?`).run(enabled ? 1 : 0, serializeConversationBuiltinSkillRoots(roots), Date.now(), conversationId);
+    }
+    setConversationActiveProject(conversationId, activeProjectId) {
+        const conversation = this.getConversation(conversationId);
+        if (!conversation)
+            return null;
+        const resolvedActiveProjectId = this.resolveConversationActiveProjectId(conversation.agentId ?? null, activeProjectId ?? null);
+        this.db.prepare(`UPDATE conversations
+          SET active_project_id = ?, updated_at = ?
+        WHERE id = ?`).run(resolvedActiveProjectId, Date.now(), conversationId);
+        return this.getConversation(conversationId);
+    }
+    deleteConversation(id) {
+        this.db.prepare('DELETE FROM conversation_prompt_queue WHERE conversation_id = ?').run(id);
+        hardDeletePanelsForConversation(this.db, id);
+        this.clearWorkspaceToolMaintenanceConversationLinks(id);
+        this.db.prepare('DELETE FROM conversations WHERE id = ?').run(id);
+    }
+    clearWorkspaceToolMaintenanceConversationLinks(conversationId) {
+        this.db.prepare(`UPDATE workspace_tools
+          SET maintenance_conversation_id = NULL,
+              updated_at = ?
+        WHERE maintenance_conversation_id = ?`).run(Date.now(), conversationId);
+    }
+    deleteRunStateForSession(sessionKey) {
+        const runIds = this.db.prepare(`SELECT run_id as runId FROM runs WHERE session_key = ?`).all(sessionKey);
+        for (const run of runIds) {
+            this.db.prepare('DELETE FROM delivery_checkpoints WHERE run_id = ?').run(run.runId);
+            this.db.prepare('DELETE FROM events WHERE run_id = ?').run(run.runId);
+            this.db.prepare('DELETE FROM run_debug_inputs WHERE run_id = ?').run(run.runId);
+        }
+        this.db.prepare('DELETE FROM run_debug_inputs WHERE session_key = ?').run(sessionKey);
+        this.db.prepare('DELETE FROM runs WHERE session_key = ?').run(sessionKey);
+    }
+    deleteBindingStateForSession(sessionKey) {
+        const bindingKeys = this.db.prepare(`SELECT binding_key as bindingKey
+       FROM bindings
+       WHERE session_key = ?`).all(sessionKey);
+        for (const binding of bindingKeys) {
+            this.db.prepare('DELETE FROM jobs WHERE binding_key = ?').run(binding.bindingKey);
+            this.db.prepare('DELETE FROM tool_policies WHERE binding_key = ?').run(binding.bindingKey);
+            this.db.prepare('DELETE FROM delivery_checkpoints WHERE binding_key = ?').run(binding.bindingKey);
+            this.db.prepare('DELETE FROM ui_prefs WHERE binding_key = ?').run(binding.bindingKey);
+            this.db.prepare('DELETE FROM tool_allow_prefixes WHERE binding_key = ?').run(binding.bindingKey);
+        }
+        this.db.prepare('DELETE FROM bindings WHERE session_key = ?').run(sessionKey);
+    }
+    deleteWorkspaceSessionsForAgent(agentId) {
+        if (!this.tableExists('workspace_sessions'))
+            return;
+        const rows = this.db.prepare(`SELECT workspace_session_id as workspaceSessionId,
+              session_key as sessionKey
+         FROM workspace_sessions
+        WHERE agent_id = ?`).all(agentId);
+        for (const row of rows) {
+            this.db.prepare('DELETE FROM workspace_sessions WHERE workspace_session_id = ?').run(row.workspaceSessionId);
+            this.db.prepare('DELETE FROM claude_session_user_messages WHERE session_key = ?').run(row.sessionKey);
+            this.deleteRunStateForSession(row.sessionKey);
+            this.deleteBindingStateForSession(row.sessionKey);
+            this.db.prepare('DELETE FROM sessions WHERE session_key = ?').run(row.sessionKey);
+        }
+    }
+    deleteConversationRuntimeState(params) {
+        this.db.prepare('DELETE FROM conversation_prompt_queue WHERE conversation_id = ?').run(params.conversationId);
+        hardDeletePanelsForConversation(this.db, params.conversationId);
+        this.clearWorkspaceToolMaintenanceConversationLinks(params.conversationId);
+        clearRollingSummaryStateForConversation(this.db, params.conversationId);
+        this.db.prepare('DELETE FROM run_debug_inputs WHERE conversation_id = ?').run(params.conversationId);
+        this.deleteRunStateForSession(params.sessionKey);
+        this.deleteBindingStateForSession(params.sessionKey);
+        if (params.channelId && params.threadRootId) {
+            this.db.prepare(`DELETE FROM target_participants
+         WHERE channel_id = ? AND thread_root_id = ?`).run(params.channelId, params.threadRootId);
+            this.db.prepare(`DELETE FROM agent_message_checkpoints
+         WHERE channel_id = ? AND thread_root_id = ?`).run(params.channelId, params.threadRootId);
+            this.db.prepare(`DELETE FROM agent_mention_cooldowns
+         WHERE channel_id = ? AND thread_root_id = ?`).run(params.channelId, params.threadRootId);
+            deleteNotificationV2StateForThreadRoots(this.db, {
+                channelId: params.channelId,
+                threadRootIds: [params.threadRootId],
+            });
+            const hasDmThreadContextSnapshots = !!this.db.prepare(`SELECT 1
+         FROM sqlite_master
+         WHERE type = 'table' AND name = 'dm_thread_context_snapshots'
+         LIMIT 1`).get();
+            if (hasDmThreadContextSnapshots) {
+                this.db.prepare(`DELETE FROM dm_thread_context_snapshots
+           WHERE channel_id = ? AND thread_root_id = ?`).run(params.channelId, params.threadRootId);
+            }
+        }
+        this.db.prepare('DELETE FROM conversations WHERE id = ?').run(params.conversationId);
+        this.db.prepare('DELETE FROM sessions WHERE session_key = ?').run(params.sessionKey);
+    }
+    deleteTaskThreadFollowupsForChannel(channelId) {
+        this.db.prepare(`DELETE FROM task_thread_followups
+       WHERE channel_id = ?`).run(channelId);
+    }
+    deleteTaskThreadFollowupsForConversationIds(conversationIds) {
+        const uniqueIds = [...new Set(conversationIds.map((id) => id.trim()).filter(Boolean))];
+        if (uniqueIds.length === 0)
+            return;
+        const placeholders = uniqueIds.map(() => '?').join(', ');
+        this.db.prepare(`DELETE FROM task_thread_followups
+       WHERE source_conversation_id IN (${placeholders})`).run(...uniqueIds);
+    }
+    listChannelTaskThreadRootIds(channelId) {
+        const rows = this.db.prepare(`SELECT message_id as messageId
+       FROM tasks
+       WHERE channel_id = ?
+         AND message_id IS NOT NULL
+         AND trim(message_id) != ''`).all(channelId);
+        return [...new Set(rows.map((row) => buildThreadShortId(row.messageId)))];
+    }
+    listChannelTaskRootMessageIds(channelId) {
+        const rows = this.db.prepare(`SELECT message_id as messageId
+       FROM tasks
+       WHERE channel_id = ?
+         AND message_id IS NOT NULL
+         AND trim(message_id) != ''`).all(channelId);
+        return [...new Set(rows.map((row) => row.messageId))];
+    }
+    listDirectTaskRootMessageIds(channelId, directTarget) {
+        const brokenDmTaskTarget = `#${channelId}`;
+        const rows = this.db.prepare(`SELECT t.message_id as messageId,
+              t.dm_target as dmTarget,
+              cm.target as messageTarget
+       FROM tasks t
+       LEFT JOIN channel_messages cm ON cm.message_id = t.message_id
+       WHERE t.channel_id = ?
+         AND t.message_id IS NOT NULL
+         AND trim(t.message_id) != ''`).all(channelId);
+        const taskRootMessageIds = new Set();
+        for (const row of rows) {
+            if (row.dmTarget === directTarget) {
+                taskRootMessageIds.add(row.messageId);
+                continue;
+            }
+            if (row.dmTarget)
+                continue;
+            if (row.messageTarget === directTarget) {
+                taskRootMessageIds.add(row.messageId);
+                continue;
+            }
+            if (row.messageTarget === brokenDmTaskTarget
+                && (this.hasDirectThreadStateForTarget(channelId, row.messageId, directTarget)
+                    || !this.hasAnyDirectThreadStateForMessage(channelId, row.messageId))) {
+                taskRootMessageIds.add(row.messageId);
+            }
+        }
+        return [...taskRootMessageIds];
+    }
+    hasDirectThreadStateForTarget(channelId, rootMessageId, directTarget) {
+        const directThreadTargetGlob = `${directTarget}:*`;
+        const canonicalThreadRootId = buildThreadShortId(rootMessageId);
+        const threadMessageRow = this.db.prepare(`SELECT 1
+       FROM channel_messages
+       WHERE channel_id = ?
+         AND target GLOB ?
+         AND thread_root_id IN (?, ?)
+       LIMIT 1`).get(channelId, directThreadTargetGlob, canonicalThreadRootId, rootMessageId);
+        if (threadMessageRow)
+            return true;
+        const agentId = channelId.startsWith('dm:') ? channelId.slice('dm:'.length) : null;
+        if (!agentId)
+            return false;
+        const threadConversationRow = this.db.prepare(`SELECT 1
+       FROM conversations
+       WHERE agent_id = ?
+         AND thread_kind = 'direct'
+         AND is_primary_thread = 0
+         AND reply_target GLOB ?
+         AND thread_root_id IN (?, ?)
+       LIMIT 1`).get(agentId, directThreadTargetGlob, canonicalThreadRootId, rootMessageId);
+        return !!threadConversationRow;
+    }
+    hasAnyDirectThreadStateForMessage(channelId, rootMessageId) {
+        const canonicalThreadRootId = buildThreadShortId(rootMessageId);
+        const threadMessageRow = this.db.prepare(`SELECT 1
+       FROM channel_messages
+       WHERE channel_id = ?
+         AND target GLOB 'dm:@*:*'
+         AND thread_root_id IN (?, ?)
+       LIMIT 1`).get(channelId, canonicalThreadRootId, rootMessageId);
+        if (threadMessageRow)
+            return true;
+        const agentId = channelId.startsWith('dm:') ? channelId.slice('dm:'.length) : null;
+        if (!agentId)
+            return false;
+        const threadConversationRow = this.db.prepare(`SELECT 1
+       FROM conversations
+       WHERE agent_id = ?
+         AND thread_kind = 'direct'
+         AND is_primary_thread = 0
+         AND thread_root_id IN (?, ?)
+       LIMIT 1`).get(agentId, canonicalThreadRootId, rootMessageId);
+        return !!threadConversationRow;
+    }
+    listDirectPreservedTaskThreadRootIds(channelId, directTarget) {
+        const taskRootMessageIds = this.listDirectTaskRootMessageIds(channelId, directTarget);
+        if (taskRootMessageIds.length === 0)
+            return [];
+        const taskMessageIdSet = new Set(taskRootMessageIds);
+        const canonicalTaskThreadRootIds = [...new Set(taskRootMessageIds.map((messageId) => buildThreadShortId(messageId)))];
+        const candidateRows = this.db.prepare(`SELECT thread_root_id as threadRootId
+       FROM conversations
+       WHERE channel_id = ? AND thread_kind = 'branch' AND thread_root_id IS NOT NULL
+       UNION
+       SELECT thread_root_id as threadRootId
+       FROM channel_messages
+       WHERE channel_id = ? AND thread_root_id IS NOT NULL
+       UNION
+       SELECT thread_root_id as threadRootId
+       FROM agent_message_checkpoints
+       WHERE channel_id = ? AND trim(thread_root_id) != ''
+       UNION
+       SELECT thread_root_id as threadRootId
+       FROM target_participants
+       WHERE channel_id = ? AND trim(thread_root_id) != ''`).all(channelId, channelId, channelId, channelId);
+        const preservedIds = new Set(canonicalTaskThreadRootIds);
+        for (const row of candidateRows) {
+            const threadRootId = row.threadRootId?.trim();
+            if (!threadRootId)
+                continue;
+            const rootMessageId = findThreadRootMessageId(this.db, channelId, threadRootId);
+            if (rootMessageId && taskMessageIdSet.has(rootMessageId)) {
+                preservedIds.add(threadRootId);
+            }
+        }
+        return [...preservedIds];
+    }
+    listChannelPreservedTaskThreadRootIds(channelId) {
+        const taskRootMessageIds = this.listChannelTaskRootMessageIds(channelId);
+        if (taskRootMessageIds.length === 0)
+            return [];
+        const taskMessageIdSet = new Set(taskRootMessageIds);
+        const canonicalTaskThreadRootIds = this.listChannelTaskThreadRootIds(channelId);
+        const candidateRows = this.db.prepare(`SELECT thread_root_id as threadRootId
+       FROM conversations
+       WHERE channel_id = ? AND thread_kind = 'branch' AND thread_root_id IS NOT NULL
+       UNION
+       SELECT thread_root_id as threadRootId
+       FROM channel_messages
+       WHERE channel_id = ? AND thread_root_id IS NOT NULL
+       UNION
+       SELECT thread_root_id as threadRootId
+       FROM agent_message_checkpoints
+       WHERE channel_id = ? AND trim(thread_root_id) != ''
+       UNION
+       SELECT thread_root_id as threadRootId
+       FROM target_participants
+       WHERE channel_id = ? AND trim(thread_root_id) != ''`).all(channelId, channelId, channelId, channelId);
+        const preservedIds = new Set(canonicalTaskThreadRootIds);
+        for (const row of candidateRows) {
+            const threadRootId = row.threadRootId?.trim();
+            if (!threadRootId)
+                continue;
+            const rootMessageId = findThreadRootMessageId(this.db, channelId, threadRootId);
+            if (rootMessageId && taskMessageIdSet.has(rootMessageId)) {
+                preservedIds.add(threadRootId);
+            }
+        }
+        return [...preservedIds];
+    }
+    /** Returns hostKeys (conversation:{id}:{agentType}) for all conversations of this agent */
+    getAgentHostKeys(agentId) {
+        const rows = this.db.prepare(`SELECT id, agent_type as agentType, node_id as nodeId
+       FROM conversations WHERE agent_id = ? AND node_id IS NOT NULL`).all(agentId);
+        return rows.map((r) => ({ nodeId: r.nodeId, hostKey: `conversation:${r.id}:${r.agentType}` }));
+    }
+    getConversationHostKey(conversationId) {
+        const row = this.db.prepare(`SELECT id, agent_type as agentType, node_id as nodeId
+       FROM conversations WHERE id = ? AND node_id IS NOT NULL`).get(conversationId);
+        if (!row)
+            return null;
+        return { nodeId: row.nodeId, hostKey: `conversation:${row.id}:${row.agentType}` };
+    }
+    /** Clear one conversation's chat/runtime state and rotate it to a new session (keeps workspace files). */
+    clearConversationChat(conversationId) {
+        const row = this.db.prepare(`SELECT id, channel_id as channelId, reply_target as replyTarget, agent_type as agentType,
+              workspace_path as workspacePath, session_key as sessionKey, node_id as nodeId,
+              thread_kind as threadKind, is_primary_thread as isPrimaryThread, agent_id as agentId, user_id as userId
+       FROM conversations
+       WHERE id = ?`).get(conversationId);
+        if (!row)
+            return null;
+        const now = Date.now();
+        this.db.prepare('DELETE FROM conversation_prompt_queue WHERE conversation_id = ?').run(conversationId);
+        if (row.threadKind === 'direct' && row.agentId) {
+            const directTarget = (row.replyTarget ?? '').trim();
+            const dmChannelId = `dm:${row.agentId}`;
+            const directTaskRootMessageIds = this.listDirectTaskRootMessageIds(dmChannelId, directTarget);
+            const preservedTaskThreadRootIds = this.listDirectPreservedTaskThreadRootIds(dmChannelId, directTarget);
+            const preservedTaskThreadRootIdSet = new Set(preservedTaskThreadRootIds);
+            for (const taskThreadRootId of preservedTaskThreadRootIds) {
+                ensureDmThreadContextSnapshot(this.db, {
+                    channelId: dmChannelId,
+                    directTarget,
+                    threadRootId: taskThreadRootId,
+                });
+            }
+            if (directTaskRootMessageIds.length > 0) {
+                const archiveTargetStmt = this.db.prepare(`UPDATE channel_messages
+           SET target = ?
+           WHERE channel_id = ?
+             AND message_id = ?
+             AND thread_root_id IS NULL`);
+                const preserveDmTargetStmt = this.db.prepare(`UPDATE tasks
+           SET dm_target = COALESCE(dm_target, ?)
+           WHERE channel_id = ?
+             AND message_id = ?`);
+                for (const messageId of directTaskRootMessageIds) {
+                    const taskThreadRootId = buildThreadShortId(messageId);
+                    archiveTargetStmt.run(buildClearedTaskRootArchiveTarget(taskThreadRootId), dmChannelId, messageId);
+                    preserveDmTargetStmt.run(directTarget, dmChannelId, messageId);
+                }
+            }
+            const siblingDirectThreadRows = (row.userId
+                ? this.db.prepare(`SELECT id, session_key as sessionKey, node_id as nodeId, agent_type as agentType, thread_root_id as threadRootId
+             FROM conversations
+             WHERE agent_id = ?
+               AND user_id = ?
+               AND thread_kind = 'direct'
+               AND is_primary_thread = 0
+               AND reply_target GLOB ?`).all(row.agentId, row.userId, `${directTarget}:*`)
+                : this.db.prepare(`SELECT id, session_key as sessionKey, node_id as nodeId, agent_type as agentType, thread_root_id as threadRootId
+             FROM conversations
+             WHERE agent_id = ?
+               AND user_id IS NULL
+               AND thread_kind = 'direct'
+               AND is_primary_thread = 0
+               AND reply_target GLOB ?`).all(row.agentId, `${directTarget}:*`));
+            const siblingRowsToDelete = siblingDirectThreadRows.filter((sibling) => !sibling.threadRootId || !preservedTaskThreadRootIdSet.has(sibling.threadRootId));
+            if (preservedTaskThreadRootIds.length > 0) {
+                const taskThreadPlaceholders = preservedTaskThreadRootIds.map(() => '?').join(', ');
+                this.db.prepare(`DELETE FROM channel_messages
+           WHERE channel_id = ? AND (
+             target = ?
+             OR (
+               target GLOB ?
+               AND (
+                 thread_root_id IS NULL
+                 OR thread_root_id NOT IN (${taskThreadPlaceholders})
+               )
+             )
+           )`).run(dmChannelId, directTarget, `${directTarget}:*`, ...preservedTaskThreadRootIds);
+            }
+            else {
+                this.db.prepare(`DELETE FROM channel_messages
+           WHERE channel_id = ?
+             AND (
+               target = ?
+               OR target GLOB ?
+             )`).run(dmChannelId, directTarget, `${directTarget}:*`);
+            }
+            this.deleteTaskThreadFollowupsForConversationIds(siblingRowsToDelete.map((sibling) => sibling.id));
+            for (const sibling of siblingRowsToDelete) {
+                if (sibling.nodeId && this.nodeRegistry) {
+                    this.nodeRegistry.send(sibling.nodeId, {
+                        type: 'host.close',
+                        hostKey: `conversation:${sibling.id}:${sibling.agentType}`,
+                    });
+                }
+                this.deleteConversationRuntimeState({
+                    conversationId: sibling.id,
+                    sessionKey: sibling.sessionKey,
+                    channelId: dmChannelId,
+                    threadRootId: sibling.threadRootId,
+                });
+            }
+        }
+        this.deleteRunStateForSession(row.sessionKey);
+        clearRollingSummaryStateForConversation(this.db, row.id);
+        const newSessionKey = randomUUID();
+        const preset = getRuntimeDriver(row.agentType);
+        createSession(this.db, {
+            sessionKey: newSessionKey,
+            agentCommand: preset.command,
+            agentArgs: preset.args,
+            cwd: row.workspacePath ?? this.config.workspaceRoot,
+            loadSupported: false,
+        });
+        upsertBinding(this.db, { platform: 'web', chatId: row.channelId, threadId: row.id, userId: row.agentType }, newSessionKey);
+        this.db.prepare(`UPDATE conversations
+       SET session_key = ?, status = 'idle',
+           title = CASE WHEN substr(title, 1, 10) = '[platform:' THEN title ELSE '' END,
+           history_reset_at = ?, updated_at = ?
+       WHERE id = ?`).run(newSessionKey, now, now, row.id);
+        this.db.prepare('DELETE FROM sessions WHERE session_key = ?').run(row.sessionKey);
+        return this.getConversation(conversationId);
+    }
+    /** Clear chat history and reset session (keeps workspace files) */
+    clearAgentChat(agentId) {
+        const rows = this.db.prepare(`SELECT id, channel_id as channelId, agent_type as agentType, workspace_path as workspacePath,
+              session_key as sessionKey, node_id as nodeId, created_at as createdAt,
+              thread_kind as threadKind, is_primary_thread as isPrimaryThread
+       FROM conversations
+       WHERE agent_id = ?
+       ORDER BY is_primary_thread DESC, updated_at DESC`).all(agentId);
+        if (rows.length === 0)
+            return [];
+        const now = Date.now();
+        this.deleteTaskThreadFollowupsForConversationIds(rows.map((row) => row.id));
+        this.db.prepare('DELETE FROM conversation_prompt_queue WHERE agent_id = ?').run(agentId);
+        clearRollingSummaryStateForAgent(this.db, agentId);
+        this.db.prepare(`DELETE FROM channel_messages WHERE channel_id = ?`).run(`dm:${agentId}`);
+        this.deleteTaskThreadFollowupsForChannel(`dm:${agentId}`);
+        this.db.prepare(`DELETE FROM agent_message_checkpoints WHERE agent_id = ?`).run(agentId);
+        this.deleteAgentNotificationState(agentId);
+        for (const row of rows) {
+            this.deleteRunStateForSession(row.sessionKey);
+            const newSessionKey = randomUUID();
+            const preset = getRuntimeDriver(row.agentType);
+            createSession(this.db, {
+                sessionKey: newSessionKey,
+                agentCommand: preset.command,
+                agentArgs: preset.args,
+                cwd: row.workspacePath ?? this.config.workspaceRoot,
+                loadSupported: false,
+            });
+            upsertBinding(this.db, { platform: 'web', chatId: row.channelId, threadId: row.id, userId: row.agentType }, newSessionKey);
+            this.db.prepare(`UPDATE conversations
+         SET session_key = ?, status = 'idle',
+             title = CASE WHEN substr(title, 1, 10) = '[platform:' THEN title ELSE '' END,
+             history_reset_at = ?, updated_at = ?
+         WHERE id = ?`).run(newSessionKey, now, now, row.id);
+            this.db.prepare('DELETE FROM sessions WHERE session_key = ?').run(row.sessionKey);
+        }
+        return this.listConversations({ agentId });
+    }
+    resetAgent(agentId) {
+        const rows = this.db.prepare(`SELECT id, channel_id as channelId, agent_type as agentType, workspace_path as workspacePath,
+              session_key as sessionKey, node_id as nodeId, created_at as createdAt,
+              thread_kind as threadKind, is_primary_thread as isPrimaryThread
+       FROM conversations
+       WHERE agent_id = ?
+       ORDER BY is_primary_thread DESC, updated_at DESC`).all(agentId);
+        if (rows.length === 0)
+            return [];
+        const now = Date.now();
+        const dmChannelId = `dm:${agentId}`;
+        this.deleteTaskThreadFollowupsForConversationIds(rows.map((row) => row.id));
+        this.db.prepare('DELETE FROM conversation_prompt_queue WHERE agent_id = ?').run(agentId);
+        clearRollingSummaryStateForAgent(this.db, agentId);
+        this.db.prepare(`DELETE FROM channel_messages WHERE channel_id = ?`).run(dmChannelId);
+        this.deleteTaskThreadFollowupsForChannel(dmChannelId);
+        this.db.prepare(`DELETE FROM tasks WHERE channel_id = ?`).run(dmChannelId);
+        deleteTaskEventsForChannel(this.db, dmChannelId);
+        this.db.prepare(`DELETE FROM channel_task_sequences WHERE channel_id = ?`).run(dmChannelId);
+        deleteTargetParticipantsForChannel(this.db, dmChannelId);
+        const hasDmThreadContextSnapshots = this.db
+            .prepare(`SELECT 1 as hasRow
+         FROM sqlite_master
+         WHERE type = 'table' AND name = 'dm_thread_context_snapshots'
+         LIMIT 1`)
+            .get();
+        if (hasDmThreadContextSnapshots) {
+            this.db.prepare(`DELETE FROM dm_thread_context_snapshots WHERE channel_id = ?`).run(dmChannelId);
+        }
+        this.db.prepare(`DELETE FROM agent_message_checkpoints WHERE agent_id = ?`).run(agentId);
+        this.deleteAgentNotificationState(agentId);
+        for (const row of rows) {
+            this.deleteRunStateForSession(row.sessionKey);
+            const newSessionKey = randomUUID();
+            const preset = getRuntimeDriver(row.agentType);
+            createSession(this.db, {
+                sessionKey: newSessionKey,
+                agentCommand: preset.command,
+                agentArgs: preset.args,
+                cwd: row.workspacePath ?? this.config.workspaceRoot,
+                loadSupported: false,
+            });
+            upsertBinding(this.db, { platform: 'web', chatId: row.channelId, threadId: row.id, userId: row.agentType }, newSessionKey);
+            this.db.prepare(`UPDATE conversations
+         SET session_key = ?, status = 'idle',
+             title = CASE WHEN substr(title, 1, 10) = '[platform:' THEN title ELSE '' END,
+             history_reset_at = ?, updated_at = ?
+         WHERE id = ?`).run(newSessionKey, now, now, row.id);
+            this.db.prepare('DELETE FROM sessions WHERE session_key = ?').run(row.sessionKey);
+        }
+        return this.listConversations({ agentId });
+    }
+    async dispatchToNode(conversationId, promptText) {
+        const conversation = this.getConversation(conversationId);
+        this.assertAgentNotDeleting(conversation?.agentId);
+        await this.executionDispatcher.dispatchPrompt(conversationId, promptText);
+    }
+    async submitPrompt(conversationId, promptText, options) {
+        const currentConversation = this.getConversation(conversationId);
+        this.assertAgentNotDeleting(currentConversation?.agentId);
+        const result = await this.executionDispatcher.submitPrompt(conversationId, promptText, options);
+        const conversation = this.getConversation(conversationId);
+        if (conversation?.agentId) {
+            const agent = this.getAgent(conversation.agentId);
+            if (agent) {
+                refreshConversationSummary(this.db, agent, conversationId);
+            }
+        }
+        return result;
+    }
+    async onConversationSettled(conversationId) {
+        const conversation = this.getConversation(conversationId);
+        if (this.isAgentDeletionInProgress(conversation?.agentId))
+            return;
+        await maybeRotateCodexConversationAfterSettlement({
+            db: this.db,
+            config: this.config,
+            conversationId,
+            nodeRegistry: this.nodeRegistry,
+            codexAppServerBroker: this.codexAppServerBroker,
+            agentRuntimeCleanupBroker: this.agentRuntimeCleanupBroker,
+        });
+        await this.executionDispatcher.handleConversationSettled(conversationId);
+    }
+    handleRunAccepted(runId, conversationId) {
+        return this.executionDispatcher.handleRunAccepted(runId, conversationId);
+    }
+    handleNodeHostSnapshotCurrentRun(params) {
+        return this.executionDispatcher.handleNodeHostSnapshotCurrentRun(params);
+    }
+    handleRunFinished(runId, conversationId, options) {
+        return this.executionDispatcher.handleRunFinished(runId, conversationId, options);
+    }
+    handleRunSteerResult(params) {
+        return this.executionDispatcher.handleRunSteerResult(params);
+    }
+    handleRunDeliveryAck(params) {
+        return ackNotificationDelivery(this.db, params);
+    }
+    async sendBestEffortSystemNoticeToActiveRun(params) {
+        return this.executionDispatcher.sendBestEffortSystemNoticeToActiveRun(params);
+    }
+    rejectPendingDispatchesForNode(nodeId, errorMessage) {
+        this.executionDispatcher.rejectPendingDispatchesForNode(nodeId, errorMessage);
+    }
+    rejectPendingSteersForNode(nodeId, errorMessage) {
+        this.executionDispatcher.rejectPendingSteersForNode(nodeId, errorMessage);
+    }
+    rejectPendingSteersForRun(runId, conversationId, errorMessage) {
+        this.executionDispatcher.rejectPendingSteersForRun(runId, conversationId, errorMessage);
+    }
+    recoverSteerAcks() {
+        this.executionDispatcher.recoverSteerAcks();
+    }
+    // ─── Channel CRUD ───
+    joinChannel(agentId, channelId) {
+        const now = Date.now();
+        const membershipCount = this.db.prepare(`SELECT COUNT(*) as count FROM agent_channel_memberships WHERE agent_id = ?`).get(agentId);
+        const makeHome = Number(membershipCount?.count ?? 0) === 0;
+        this.db.prepare(`INSERT OR IGNORE INTO agent_channel_memberships(agent_id, channel_id, is_home, joined_at)
+       VALUES(?, ?, ?, ?)`).run(agentId, channelId, makeHome ? 1 : 0, now);
+        if (makeHome) {
+            this.db.prepare(`UPDATE agents SET channel_id = ?, updated_at = ? WHERE agent_id = ?`)
+                .run(channelId, now, agentId);
+        }
+    }
+    leaveChannel(agentId, channelId) {
+        const agent = this.getAgent(agentId);
+        this.db.prepare(`DELETE FROM agent_channel_memberships WHERE agent_id = ? AND channel_id = ?`).run(agentId, channelId);
+        deleteTargetParticipantsForAgentInChannel(this.db, { agentId, channelId });
+        if (agent?.channelId === channelId) {
+            const nextHome = this.db.prepare(`SELECT channel_id as channelId
+         FROM agent_channel_memberships
+         WHERE agent_id = ?
+         ORDER BY is_home DESC, joined_at ASC
+         LIMIT 1`).get(agentId);
+            const nextChannelId = nextHome?.channelId ?? 'default';
+            this.db.prepare(`UPDATE agents SET channel_id = ?, updated_at = ? WHERE agent_id = ?`).run(nextChannelId, Date.now(), agentId);
+            this.db.prepare(`UPDATE agent_channel_memberships
+         SET is_home = CASE WHEN channel_id = ? THEN 1 ELSE 0 END
+         WHERE agent_id = ?`).run(nextChannelId, agentId);
+        }
+    }
+    createChannel(params) {
+        const channelId = params.name === 'default' ? 'default' : randomUUID();
+        const now = Date.now();
+        this.db
+            .prepare(`INSERT INTO channels(channel_id, name, workspace_path, description, collaboration_mode, created_at, updated_at)
+         VALUES(?, ?, ?, ?, ?, ?, ?)`)
+            .run(channelId, params.name, params.workspacePath ?? null, params.description ?? null, params.collaborationMode ?? 'mention_only', now, now);
+        return {
+            channelId,
+            name: params.name,
+            workspacePath: params.workspacePath ?? null,
+            description: params.description,
+            collaborationMode: params.collaborationMode ?? 'mention_only',
+            members: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    updateChannel(channelId, req) {
+        const existing = this.getChannel(channelId);
+        if (!existing)
+            return null;
+        const now = Date.now();
+        this.db.prepare(`UPDATE channels
+       SET description = ?, collaboration_mode = ?, updated_at = ?
+       WHERE channel_id = ?`).run(req.description ?? existing.description ?? null, req.collaborationMode ?? existing.collaborationMode ?? 'mention_only', now, channelId);
+        return {
+            ...existing,
+            description: req.description ?? existing.description,
+            collaborationMode: req.collaborationMode ?? existing.collaborationMode,
+            updatedAt: now,
+        };
+    }
+    listChannelBranchConversationsForChatClear(channelId) {
+        return this.listConversations({ channelId }).filter((conversation) => conversation.threadKind === 'branch');
+    }
+    clearChannelChat(channelId) {
+        const rows = this.db.prepare(`SELECT id, channel_id as channelId, agent_type as agentType, workspace_path as workspacePath,
+              session_key as sessionKey, thread_root_id as threadRootId
+       FROM conversations
+       WHERE channel_id = ? AND thread_kind = 'branch'
+       ORDER BY updated_at DESC`).all(channelId);
+        const now = Date.now();
+        const preservedTaskRootMessageIds = this.listChannelTaskRootMessageIds(channelId);
+        const rowsToReset = rows;
+        if (preservedTaskRootMessageIds.length > 0) {
+            const taskRootPlaceholders = preservedTaskRootMessageIds.map(() => '?').join(', ');
+            this.db.prepare(`DELETE FROM channel_messages
+         WHERE channel_id = ?
+           AND (
+             (
+               (thread_root_id IS NULL OR thread_root_id = '')
+               AND message_id NOT IN (${taskRootPlaceholders})
+             )
+             OR (
+               thread_root_id IS NOT NULL
+             )
+           )`).run(channelId, ...preservedTaskRootMessageIds);
+            this.db.prepare(`DELETE FROM agent_message_checkpoints
+         WHERE channel_id = ?`).run(channelId);
+            this.db.prepare(`DELETE FROM target_participants
+         WHERE channel_id = ?`).run(channelId);
+            clearAgentMentionCooldownsForChannelChatClear(this.db, {
+                channelId,
+                preservedThreadRootIds: [],
+            });
+            deleteNotificationV2StateForChannel(this.db, channelId);
+            deletePeerInboxAggregatesForChannel(this.db, channelId);
+        }
+        else {
+            if (preservedTaskRootMessageIds.length > 0) {
+                const taskRootPlaceholders = preservedTaskRootMessageIds.map(() => '?').join(', ');
+                this.db.prepare(`DELETE FROM channel_messages
+           WHERE channel_id = ?
+             AND (
+               thread_root_id IS NOT NULL
+               OR message_id NOT IN (${taskRootPlaceholders})
+             )`).run(channelId, ...preservedTaskRootMessageIds);
+            }
+            else {
+                this.db.prepare(`DELETE FROM channel_messages
+           WHERE channel_id = ?`).run(channelId);
+            }
+            this.db.prepare(`DELETE FROM agent_message_checkpoints WHERE channel_id = ?`).run(channelId);
+            deleteTargetParticipantsForChannel(this.db, channelId);
+            clearAgentMentionCooldownsForChannelChatClear(this.db, { channelId });
+            deleteNotificationV2StateForChannel(this.db, channelId);
+            deletePeerInboxAggregatesForChannel(this.db, channelId);
+        }
+        this.deleteTaskThreadFollowupsForChannel(channelId);
+        if (preservedTaskRootMessageIds.length > 0) {
+            const preserveRootStmt = this.db.prepare(`UPDATE channel_messages
+         SET message_source = ?, target = ?
+         WHERE channel_id = ?
+           AND message_id = ?
+           AND COALESCE(thread_root_id, '') = ''`);
+            for (const messageId of preservedTaskRootMessageIds) {
+                preserveRootStmt.run(CHANNEL_TASK_ROOT_PRESERVED_SOURCE, buildClearedTaskRootArchiveTarget(buildThreadShortId(messageId)), channelId, messageId);
+            }
+        }
+        for (const row of rowsToReset) {
+            this.db.prepare('DELETE FROM conversation_prompt_queue WHERE conversation_id = ?').run(row.id);
+            clearRollingSummaryStateForConversation(this.db, row.id);
+            this.deleteRunStateForSession(row.sessionKey);
+            const newSessionKey = randomUUID();
+            const preset = getRuntimeDriver(row.agentType);
+            createSession(this.db, {
+                sessionKey: newSessionKey,
+                agentCommand: preset.command,
+                agentArgs: preset.args,
+                cwd: row.workspacePath ?? this.config.workspaceRoot,
+                loadSupported: false,
+            });
+            upsertBinding(this.db, { platform: 'web', chatId: row.channelId, threadId: row.id, userId: row.agentType }, newSessionKey);
+            this.db.prepare(`UPDATE conversations
+         SET session_key = ?, status = 'idle',
+             title = CASE WHEN substr(title, 1, 10) = '[platform:' THEN title ELSE '' END,
+             history_reset_at = ?, updated_at = ?
+         WHERE id = ?`).run(newSessionKey, now, now, row.id);
+            this.db.prepare('DELETE FROM sessions WHERE session_key = ?').run(row.sessionKey);
+        }
+        const resetConversationIds = new Set(rowsToReset.map((row) => row.id));
+        return this.listConversations({ channelId }).filter((item) => resetConversationIds.has(item.id));
+    }
+    listChannels() {
+        const rows = this.db
+            .prepare(`SELECT channel_id as channelId, name, workspace_path as workspacePath,
+                description,
+                collaboration_mode as collaborationMode,
+                created_at as createdAt, updated_at as updatedAt
+         FROM channels ORDER BY created_at ASC`)
+            .all();
+        return rows.map((row) => ({
+            ...row,
+            members: this.listChannelMembers(row.channelId),
+        }));
+    }
+    getChannel(channelId) {
+        const row = this.db
+            .prepare(`SELECT channel_id as channelId, name, workspace_path as workspacePath,
+                description,
+                collaboration_mode as collaborationMode,
+                created_at as createdAt, updated_at as updatedAt
+         FROM channels WHERE channel_id = ?`)
+            .get(channelId);
+        if (!row)
+            return null;
+        return {
+            ...row,
+            members: this.listChannelMembers(channelId),
+        };
+    }
+    createResourceSpace(params) {
+        const resourceSpaceId = randomUUID();
+        const now = Date.now();
+        const description = params.description?.trim() || null;
+        const channelId = params.channelId?.trim() || null;
+        const nodeId = params.nodeId?.trim() || null;
+        this.db.prepare(`INSERT INTO resource_spaces(
+        resource_space_id,
+        name,
+        resource_type,
+        backend_type,
+        node_id,
+        root_path,
+        channel_id,
+        description,
+        created_at,
+        updated_at
+      ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(resourceSpaceId, params.name, params.resourceType, params.backendType, nodeId, params.rootPath, channelId, description, now, now);
+        return {
+            resourceSpaceId,
+            name: params.name,
+            resourceType: params.resourceType,
+            backendType: params.backendType,
+            nodeId,
+            rootPath: params.rootPath,
+            channelId,
+            description,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    updateResourceSpace(resourceSpaceId, req) {
+        const existing = this.getResourceSpace(resourceSpaceId);
+        if (!existing)
+            return null;
+        const nextName = req.name ?? existing.name;
+        const nextResourceType = req.resourceType ?? existing.resourceType;
+        const nextBackendType = req.backendType ?? existing.backendType;
+        const nextNodeId = req.nodeId !== undefined ? (req.nodeId?.trim() || null) : (existing.nodeId ?? null);
+        const nextRootPath = req.rootPath ?? existing.rootPath;
+        const nextChannelId = req.channelId !== undefined ? (req.channelId?.trim() || null) : (existing.channelId ?? null);
+        const nextDescription = req.description !== undefined
+            ? (req.description?.trim() || null)
+            : (existing.description ?? null);
+        const now = Date.now();
+        this.db.prepare(`UPDATE resource_spaces
+       SET name = ?,
+           resource_type = ?,
+           backend_type = ?,
+           node_id = ?,
+           root_path = ?,
+           channel_id = ?,
+           description = ?,
+           updated_at = ?
+       WHERE resource_space_id = ?`).run(nextName, nextResourceType, nextBackendType, nextNodeId, nextRootPath, nextChannelId, nextDescription, now, resourceSpaceId);
+        return {
+            resourceSpaceId,
+            name: nextName,
+            resourceType: nextResourceType,
+            backendType: nextBackendType,
+            nodeId: nextNodeId,
+            rootPath: nextRootPath,
+            channelId: nextChannelId,
+            description: nextDescription,
+            createdAt: existing.createdAt,
+            updatedAt: now,
+        };
+    }
+    deleteResourceSpace(resourceSpaceId) {
+        const result = this.db.prepare(`DELETE FROM resource_spaces
+       WHERE resource_space_id = ?`).run(resourceSpaceId);
+        return result.changes > 0;
+    }
+    listResourceSpaces() {
+        return this.db.prepare(`SELECT resource_space_id as resourceSpaceId,
+              name,
+              resource_type as resourceType,
+              backend_type as backendType,
+              node_id as nodeId,
+              root_path as rootPath,
+              channel_id as channelId,
+              description,
+              created_at as createdAt,
+              updated_at as updatedAt
+       FROM resource_spaces
+       ORDER BY created_at ASC`).all();
+    }
+    getResourceSpace(resourceSpaceId) {
+        const row = this.db.prepare(`SELECT resource_space_id as resourceSpaceId,
+              name,
+              resource_type as resourceType,
+              backend_type as backendType,
+              node_id as nodeId,
+              root_path as rootPath,
+              channel_id as channelId,
+              description,
+              created_at as createdAt,
+              updated_at as updatedAt
+       FROM resource_spaces
+       WHERE resource_space_id = ?`).get(resourceSpaceId);
+        return row ?? null;
+    }
+    async handleApproval(conversationId, requestId, decision, selectedActionId, responseText, answers) {
+        return this.executionDispatcher.handleApproval(conversationId, requestId, decision, selectedActionId, responseText, answers);
+    }
+    cancelConversationRun(conversationId, expectedRunId, options) {
+        return this.executionDispatcher.cancelConversationRun(conversationId, expectedRunId, options);
+    }
+    updateStatus(conversationId, status) {
+        this.db
+            .prepare('UPDATE conversations SET status = ?, updated_at = ? WHERE id = ?')
+            .run(status, Date.now(), conversationId);
+    }
+    computeReplyTarget(params) {
+        if (params.threadKind === 'direct') {
+            const userName = resolveDirectUserName(this.db, params.userId, this.config.humanUserName);
+            return buildDirectReplyTarget({
+                isPrimaryThread: params.isPrimaryThread,
+                userName,
+                threadRootId: params.threadRootId,
+                primaryScope: params.isPrimaryThread ? getPlatformDirectReplyScope(params.title) : null,
+            });
+        }
+        const channel = this.getChannel(params.channelId);
+        const channelName = channel?.name ?? params.channelId;
+        const baseTarget = `#${channelName}`;
+        return params.threadRootId ? `${baseTarget}:${params.threadRootId}` : baseTarget;
+    }
+    backfillConversationReplyTargets() {
+        const rows = this.db.prepare(`SELECT id, channel_id as channelId, title,
+              thread_kind as threadKind,
+              is_primary_thread as isPrimaryThread, thread_root_id as threadRootId,
+              user_id as userId, reply_target as replyTarget, surface_kind as surfaceKind
+       FROM conversations
+       WHERE thread_kind = 'direct' OR reply_target IS NULL OR reply_target = '' OR surface_kind IS NULL OR surface_kind = ''`).all();
+        if (rows.length === 0)
+            return;
+        const updateReplyTarget = this.db.prepare(`UPDATE conversations
+       SET reply_target = ?, surface_kind = ?
+       WHERE id = ?`);
+        for (const row of rows) {
+            const canonicalReplyTarget = this.computeReplyTarget({
+                conversationId: row.id,
+                channelId: row.channelId,
+                threadKind: row.threadKind,
+                isPrimaryThread: row.isPrimaryThread !== 0,
+                threadRootId: row.threadRootId ?? null,
+                userId: row.userId ?? null,
+                title: row.title ?? null,
+            });
+            const canonicalSurfaceKind = deriveSurfaceKind(row.threadKind, row.threadRootId ?? null);
+            if ((row.replyTarget ?? '').trim() === canonicalReplyTarget && row.surfaceKind === canonicalSurfaceKind)
+                continue;
+            updateReplyTarget.run(canonicalReplyTarget, canonicalSurfaceKind, row.id);
+        }
+    }
+    // ─── Machine CRUD ───
+    createMachine(params) {
+        const nodeId = randomUUID();
+        const now = Date.now();
+        const envVarKeysJson = JSON.stringify(params.envVarKeys ?? []);
+        this.db.prepare(`INSERT INTO nodes(node_id, hostname, agent_types_json, version, status, last_seen, created_at, display_name, env_var_keys, provisioned_at)
+       VALUES(?, '', '[]', '', 'pending', 0, 0, ?, ?, ?)`).run(nodeId, params.name, envVarKeysJson, now);
+        return {
+            nodeId,
+            name: params.name,
+            hostname: null,
+            agentTypes: [],
+            version: null,
+            status: 'pending',
+            envVarKeys: params.envVarKeys ?? [],
+            lastSeen: null,
+            provisionedAt: now,
+            createdAt: 0,
+        };
+    }
+    listMachines() {
+        const rows = this.db.prepare(`SELECT node_id as nodeId, hostname, agent_types_json as agentTypesJson, version,
+              status, last_seen as lastSeen, created_at as createdAt,
+              display_name as displayName, env_var_keys as envVarKeysJson,
+              provisioned_at as provisionedAt
+       FROM nodes WHERE status != 'deleted' ORDER BY provisioned_at DESC, created_at ASC`).all();
+        return rows.map((row) => {
+            const isOnline = !!this.nodeRegistry?.getNode(row.nodeId);
+            return rowToMachineInfo(row, isOnline);
+        });
+    }
+    getMachine(nodeId) {
+        const row = this.db.prepare(`SELECT node_id as nodeId, hostname, agent_types_json as agentTypesJson, version,
+              status, last_seen as lastSeen, created_at as createdAt,
+              display_name as displayName, env_var_keys as envVarKeysJson,
+              provisioned_at as provisionedAt
+       FROM nodes WHERE node_id = ? AND status != 'deleted'`).get(nodeId);
+        if (!row)
+            return null;
+        const isOnline = !!this.nodeRegistry?.getNode(nodeId);
+        return rowToMachineInfo(row, isOnline);
+    }
+    deleteMachine(nodeId) {
+        const agentIds = this.db.prepare(`SELECT agent_id as agentId FROM agents WHERE node_id = ? AND deleted_at IS NULL`).all(nodeId);
+        for (const agent of agentIds) {
+            this.deleteAgent(agent.agentId);
+        }
+        this.db.prepare(`UPDATE nodes SET status = 'deleted' WHERE node_id = ?`).run(nodeId);
+        if (this.nodeRegistry) {
+            const node = this.nodeRegistry.getNode(nodeId);
+            if (node) {
+                node.ws?.close(4000, 'Machine has been deleted');
+                this.nodeRegistry.unregister(nodeId);
+            }
+        }
+    }
+    rowToAgentInfo(row) {
+        const memberships = this.db.prepare(`SELECT channel_id as channelId FROM agent_channel_memberships WHERE agent_id = ?`).all(row.agentId);
+        const enabledSkillPaths = parseStringArray(row.enabledSkillPathsJson);
+        return {
+            agentId: row.agentId,
+            name: row.name,
+            ...(row.agentRole && row.agentRole !== 'user' ? { agentRole: row.agentRole } : {}),
+            agentType: row.agentType,
+            ...(row.model ? { model: row.model } : {}),
+            ...(row.reasoningEffort ? { reasoningEffort: row.reasoningEffort } : {}),
+            ...(row.agentType === 'claude_sdk' && row.claudePermissionMode ? { claudePermissionMode: row.claudePermissionMode } : {}),
+            ...(row.agentType === 'codex_app_server' && row.codexMode ? { codexMode: row.codexMode } : {}),
+            ...(row.agentType === 'codex_app_server' && row.codexServiceTier ? { codexServiceTier: row.codexServiceTier } : {}),
+            channelId: row.channelId,
+            channelIds: memberships.map((m) => m.channelId),
+            systemPrompt: row.systemPrompt,
+            ...(row.description ? { description: row.description } : {}),
+            envVars: parseEnvVars(row.envVarsJson),
+            disabledToolKinds: normalizeAgentDisabledToolKinds(row.agentType, parseDisabledToolKinds(row.disabledToolKindsJson)),
+            nodeId: row.nodeId,
+            workspacePath: row.workspacePath,
+            projectPath: row.projectPath,
+            projects: this.listAgentProjectBindings(row.agentId),
+            skillRoots: parseStringArray(row.skillRootsJson),
+            ...(enabledSkillPaths !== undefined
+                ? { enabledSkillPaths }
+                : {}),
+            skillSelectionMode: row.enabledSkillPathsJson == null ? 'legacy_all' : 'explicit',
+            memoryNetworkEnabled: row.memoryNetworkEnabled === 1,
+            dreamEnabled: row.dreamEnabled === 1,
+            dreamSchedule: row.dreamSchedule ?? '02:00',
+            dreamMinMessages: row.dreamMinMessages ?? 5,
+            lastDreamAt: row.lastDreamAt ?? null,
+            lastDreamSeq: row.lastDreamSeq ?? null,
+            deletedAt: row.deletedAt ?? null,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    listAgentProjectBindings(agentId) {
+        const rows = this.db.prepare(`SELECT p.project_id as projectId,
+              p.name,
+              p.backend_type as backendType,
+              p.root_path as rootPath,
+              p.node_id as nodeId,
+              p.description as description,
+              b.is_default as isDefault
+         FROM agent_project_bindings b
+         JOIN projects p ON p.project_id = b.project_id
+        WHERE b.agent_id = ?
+          AND p.archived_at IS NULL
+        ORDER BY b.is_default DESC, p.updated_at DESC, p.name COLLATE NOCASE ASC`).all(agentId);
+        return rows.map((row) => ({
+            projectId: row.projectId,
+            name: row.name,
+            backendType: row.backendType,
+            rootPath: row.rootPath,
+            nodeId: row.nodeId,
+            description: row.description,
+            isDefault: row.isDefault !== 0,
+        }));
+    }
+    resolveDefaultConversationActiveProjectId(agentId) {
+        const normalizedAgentId = agentId?.trim();
+        if (!normalizedAgentId)
+            return null;
+        const rows = this.db.prepare(`SELECT b.project_id as projectId,
+              b.is_default as isDefault
+         FROM agent_project_bindings b
+         JOIN projects p ON p.project_id = b.project_id
+        WHERE b.agent_id = ?
+          AND p.archived_at IS NULL
+        ORDER BY b.is_default DESC, b.updated_at DESC`).all(normalizedAgentId);
+        if (rows.length === 0)
+            return null;
+        const defaultRow = rows.find((row) => row.isDefault !== 0);
+        if (defaultRow)
+            return defaultRow.projectId;
+        return rows.length === 1 ? rows[0].projectId : null;
+    }
+    resolveConversationActiveProjectId(agentId, activeProjectId) {
+        const normalizedProjectId = activeProjectId?.trim() || null;
+        if (!normalizedProjectId)
+            return null;
+        const normalizedAgentId = agentId?.trim();
+        if (!normalizedAgentId) {
+            throw new Error('Active project requires an agent-bound conversation.');
+        }
+        const binding = this.db.prepare(`SELECT 1
+         FROM agent_project_bindings b
+         JOIN projects p ON p.project_id = b.project_id
+        WHERE b.agent_id = ?
+          AND b.project_id = ?
+          AND p.archived_at IS NULL
+        LIMIT 1`).get(normalizedAgentId, normalizedProjectId);
+        if (!binding) {
+            throw new Error('Active project is not bound to this agent.');
+        }
+        return normalizedProjectId;
+    }
+    listChannelMembers(channelId) {
+        return this.db.prepare(`SELECT a.agent_id as agentId, a.name
+       FROM agent_channel_memberships m
+       JOIN agents a ON a.agent_id = m.agent_id
+       WHERE m.channel_id = ?
+       ORDER BY a.name COLLATE NOCASE ASC`).all(channelId);
+    }
+}
+function normalizeAgentTypeList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => (typeof item === 'string' ? item.trim() : ''))
+        .filter((item) => item.length > 0);
+}
+function normalizeCodexMode(value) {
+    return value === 'default' || value === 'plan' ? value : null;
+}
+function normalizeClaudePermissionMode(value) {
+    return value === 'default' || value === 'acceptEdits' || value === 'bypassPermissions' ? value : null;
+}
+function normalizeCodexServiceTier(value) {
+    return value === 'fast' || value === 'flex' ? value : null;
+}
+function rowToMachineInfo(row, isOnline) {
+    let agentTypes = [];
+    try {
+        agentTypes = JSON.parse(row.agentTypesJson);
+    }
+    catch { /* ignore */ }
+    let envVarKeys = [];
+    try {
+        const parsed = JSON.parse(row.envVarKeysJson ?? '[]');
+        if (Array.isArray(parsed))
+            envVarKeys = parsed;
+    }
+    catch { /* ignore */ }
+    const status = isOnline ? 'online'
+        : (row.status === 'pending' ? 'pending' : 'offline');
+    return {
+        nodeId: row.nodeId,
+        name: row.displayName || row.hostname || row.nodeId,
+        hostname: row.hostname || null,
+        agentTypes,
+        version: row.version || null,
+        status,
+        envVarKeys,
+        lastSeen: row.lastSeen || null,
+        provisionedAt: row.provisionedAt,
+        createdAt: row.createdAt,
+    };
+}
+function parseEnvVars(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+function parseDisabledToolKinds(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            const out = [];
+            const seen = new Set();
+            for (const value of parsed) {
+                const kind = parseAgentPermissionKind(value);
+                if (!kind || seen.has(kind))
+                    continue;
+                seen.add(kind);
+                out.push(kind);
+            }
+            return out.length > 0 ? out : undefined;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+function parseStringArray(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            return parsed.filter((value) => typeof value === 'string' && value.trim().length > 0);
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+function normalizeEnabledSkillPaths(enabledSkillPaths, skillRoots) {
+    if (!enabledSkillPaths)
+        return [];
+    const seen = new Set();
+    const results = [];
+    for (const rawValue of enabledSkillPaths) {
+        const value = typeof rawValue === 'string' ? rawValue.trim() : '';
+        if (!value)
+            continue;
+        if (!path.isAbsolute(value)) {
+            throw new AgentConfigValidationError('enabledSkillPaths must contain absolute SKILL.md paths');
+        }
+        const resolved = path.resolve(value);
+        if (path.basename(resolved) !== 'SKILL.md') {
+            throw new AgentConfigValidationError('enabledSkillPaths entries must point to SKILL.md files');
+        }
+        if (!isEnabledSkillPathWithinRoots(resolved, skillRoots)) {
+            throw new AgentConfigValidationError('enabledSkillPaths entries must stay within configured skillRoots');
+        }
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        results.push(resolved);
+    }
+    return results;
+}
+function normalizeSkillRootsForStorage(skillRoots) {
+    if (!skillRoots)
+        return undefined;
+    const seen = new Set();
+    const results = [];
+    for (const rawValue of skillRoots) {
+        const value = typeof rawValue === 'string' ? rawValue.trim() : '';
+        if (!value)
+            continue;
+        const normalized = path.isAbsolute(value) ? path.resolve(value) : value;
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        results.push(normalized);
+    }
+    return results;
+}
+function retainEnabledSkillPathsWithinRoots(enabledSkillPaths, skillRoots) {
+    const seen = new Set();
+    const results = [];
+    for (const value of enabledSkillPaths) {
+        const resolved = path.resolve(value);
+        if (path.basename(resolved) !== 'SKILL.md')
+            continue;
+        if (!isEnabledSkillPathWithinRoots(resolved, skillRoots))
+            continue;
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        results.push(resolved);
+    }
+    return results;
+}
+function isEnabledSkillPathWithinRoots(skillPath, skillRoots) {
+    const rootBoundaries = buildSkillRootBoundaries(skillRoots);
+    const lexicalAllowed = rootBoundaries.some((root) => {
+        const relative = path.relative(root.path, skillPath);
+        return relative === 'SKILL.md' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+    });
+    if (!lexicalAllowed)
+        return false;
+    const stat = fs.lstatSync(skillPath, { throwIfNoEntry: false });
+    if (!stat)
+        return true;
+    if (stat.isSymbolicLink())
+        return false;
+    const realPath = fs.realpathSync(skillPath);
+    const rootsWithRealPath = rootBoundaries.filter((root) => root.realPath);
+    if (rootsWithRealPath.length === 0)
+        return true;
+    return rootsWithRealPath.some((root) => {
+        const relative = path.relative(root.realPath, realPath);
+        return (relative === 'SKILL.md' || (!relative.startsWith('..') && !path.isAbsolute(relative)))
+            && !pathHasSymlinkDescendant(root.path, skillPath);
+    });
+}
+function buildSkillRootBoundaries(skillRoots) {
+    const seen = new Set();
+    const roots = [];
+    for (const rawValue of skillRoots ?? []) {
+        const value = typeof rawValue === 'string' ? rawValue.trim() : '';
+        if (!value || !path.isAbsolute(value))
+            continue;
+        const rootPath = path.resolve(value);
+        if (seen.has(rootPath))
+            continue;
+        const stat = fs.statSync(rootPath, { throwIfNoEntry: false });
+        roots.push({
+            path: rootPath,
+            realPath: stat?.isDirectory() ? fs.realpathSync(rootPath) : null,
+        });
+        seen.add(rootPath);
+    }
+    return roots;
+}
+function pathHasSymlinkDescendant(rootPath, skillPath) {
+    const relative = path.relative(rootPath, skillPath);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+        return false;
+    let current = rootPath;
+    const parts = relative.split(path.sep).filter(Boolean);
+    for (const part of parts.slice(0, -1)) {
+        current = path.join(current, part);
+        const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+        if (stat?.isSymbolicLink())
+            return true;
+    }
+    return false;
+}
+function normalizeStringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of value) {
+        const text = typeof item === 'string' ? item.trim() : '';
+        if (!text || seen.has(text))
+            continue;
+        seen.add(text);
+        out.push(text);
+    }
+    return out;
+}