awb-agent-manager 1.0.0

package/dist/lib/event-dispatcher.js

@@ -0,0 +1,799 @@
+import { join } from 'node:path';
+import { log } from './logging.js';
+import { loadAgentInfo } from './config.js';
+import { fetchTicketContext, fetchChatRoomHistory, postFsResponse, postChatRoomMessage, } from './rest.js';
+import { recordEvent } from './event-log-recorder.js';
+import { MANAGED_AGENTS_DIR } from './constants.js';
+import { prepareChatAttachments } from './chat-attachment-prep.js';
+import { createAdapter, ADAPTER_CAPABILITIES } from './cli-adapters/index.js';
+import { parseRunProvision, provisionRunWorkspace } from './run-provisioner.js';
+import { fireAndForgetTool } from './mcp-client.js';
+import { mentionTriggerId } from './subagent-manager.js';
+export function parseHarnessConfig(raw) {
+    let obj = raw;
+    if (typeof obj === 'string') {
+        if (!obj.trim())
+            return null;
+        try {
+            obj = JSON.parse(obj);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+        return null;
+    const out = {};
+    if (typeof obj.system_prompt_append === 'string' && obj.system_prompt_append.trim()) {
+        out.system_prompt_append = obj.system_prompt_append;
+    }
+    for (const key of ['allowed_tools', 'disallowed_tools']) {
+        if (Array.isArray(obj[key])) {
+            const list = obj[key].filter((t) => typeof t === 'string' && t.trim());
+            if (list.length > 0)
+                out[key] = list;
+        }
+    }
+    for (const key of ['model', 'permission_mode']) {
+        if (typeof obj[key] === 'string' && obj[key].trim())
+            out[key] = obj[key].trim();
+    }
+    return Object.keys(out).length > 0 ? out : null;
+}
+const EFFORT_LEVELS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+export function parseEffortPreset(raw) {
+    let obj = raw;
+    if (typeof obj === 'string') {
+        if (!obj.trim())
+            return null;
+        try {
+            obj = JSON.parse(obj);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+        return null;
+    if (typeof obj.id !== 'string' || !obj.id.trim())
+        return null;
+    const out = { id: obj.id.trim() };
+    if (typeof obj.label === 'string' && obj.label.trim())
+        out.label = obj.label;
+    if (obj.claude && typeof obj.claude === 'object' && !Array.isArray(obj.claude)) {
+        const c = {};
+        if (typeof obj.claude.model === 'string' && obj.claude.model.trim())
+            c.model = obj.claude.model.trim();
+        if (typeof obj.claude.effort === 'string' && EFFORT_LEVELS.has(obj.claude.effort)) {
+            c.effort = obj.claude.effort;
+        }
+        if (typeof obj.claude.ultracode === 'boolean')
+            c.ultracode = obj.claude.ultracode;
+        if (Object.keys(c).length > 0)
+            out.claude = c;
+    }
+    for (const key of ['codex', 'antigravity']) {
+        const slice = obj[key];
+        if (slice && typeof slice === 'object' && !Array.isArray(slice)) {
+            if (typeof slice.model === 'string' && slice.model.trim()) {
+                out[key] = { model: slice.model.trim() };
+            }
+        }
+    }
+    return out;
+}
+export function parseEnvironmentConfig(raw) {
+    let obj = raw;
+    if (typeof obj === 'string') {
+        if (!obj.trim())
+            return null;
+        try {
+            obj = JSON.parse(obj);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+        return null;
+    const repositories = [];
+    if (Array.isArray(obj.repositories)) {
+        for (const r of obj.repositories) {
+            if (!r || typeof r !== 'object')
+                continue;
+            const url = typeof r.url === 'string' ? r.url.trim() : '';
+            if (!url)
+                continue;
+            const target_dir = typeof r.target_dir === 'string' && r.target_dir.trim() ? r.target_dir.trim() : '';
+            if (!target_dir)
+                continue;
+            repositories.push({
+                url,
+                target_dir,
+                branch: typeof r.branch === 'string' ? r.branch.trim() : '',
+                post_clone_commands: Array.isArray(r.post_clone_commands)
+                    ? r.post_clone_commands.filter((c) => typeof c === 'string' && c.trim())
+                    : [],
+            });
+        }
+    }
+    const env_vars = {};
+    if (obj.env_vars && typeof obj.env_vars === 'object' && !Array.isArray(obj.env_vars)) {
+        for (const [k, v] of Object.entries(obj.env_vars)) {
+            if (typeof k === 'string' && k.trim() && typeof v === 'string')
+                env_vars[k] = v;
+        }
+    }
+    const setup_commands = Array.isArray(obj.setup_commands)
+        ? obj.setup_commands.filter((c) => typeof c === 'string' && c.trim())
+        : [];
+    if (repositories.length === 0 && Object.keys(env_vars).length === 0 && setup_commands.length === 0) {
+        return null;
+    }
+    const timeout = Number(obj.setup_timeout_seconds);
+    return {
+        repositories,
+        env_vars,
+        setup_commands,
+        setup_timeout_seconds: Number.isFinite(timeout) && timeout > 0 ? Math.floor(timeout) : 600,
+        version: Number.isFinite(Number(obj.version)) ? Math.floor(Number(obj.version)) : 0,
+    };
+}
+const AGENT_CHAIN_DEPTH_CAP = 3;
+export class EventDispatcher {
+    #config;
+    #subagentManager;
+    #chatSessionManager;
+    #ticketSessionManager;
+    #fsBrowser;
+    #prompts;
+    #agentManagerCommandHandler;
+    #managedAgentContexts;
+    #worktreeManager;
+    #environmentProvisioner;
+    constructor(config, deps = {}) {
+        this.#config = config;
+        this.#subagentManager = deps.subagentManager ?? null;
+        this.#chatSessionManager = deps.chatSessionManager ?? null;
+        this.#ticketSessionManager = deps.ticketSessionManager ?? null;
+        this.#fsBrowser = deps.fsBrowser ?? null;
+        this.#prompts = deps.prompts ?? null;
+        this.#agentManagerCommandHandler = deps.agentManagerCommandHandler ?? null;
+        this.#managedAgentContexts = deps.managedAgentContexts ?? null;
+        this.#worktreeManager = deps.worktreeManager ?? null;
+        this.#environmentProvisioner = deps.environmentProvisioner ?? null;
+    }
+    async #applyWorktreeCwd(agentContext, ticketId, role) {
+        if (!agentContext || !this.#worktreeManager || !ticketId || !role)
+            return;
+        if (this.#config?.delegation?.worktreeIsolation === false)
+            return;
+        try {
+            const res = await this.#worktreeManager.resolveCwd({
+                baseWorkingDir: agentContext.cwd,
+                worktreesRoot: join(MANAGED_AGENTS_DIR, agentContext.agent_id, 'worktrees'),
+                ticketId,
+                role,
+            });
+            if (res.isWorktree) {
+                log(`[worktree] ticket=${ticketId.slice(0, 8)} role=${role} agent=${agentContext.agent_id.slice(0, 8)} cwd=${res.cwd}${res.reused ? ' (reused)' : ' (new)'}`);
+                agentContext.cwd = res.cwd;
+            }
+            else if (res.reason && res.reason !== 'disabled') {
+                log(`[worktree] isolation skipped for ticket=${ticketId.slice(0, 8)} role=${role}: ${res.reason} — using shared cwd ${agentContext.cwd}`);
+            }
+        }
+        catch (err) {
+            log(`[worktree] resolveCwd failed (${err?.message ?? err}); using shared cwd`);
+        }
+    }
+    async #cleanupTerminalTicketWorktrees(ticketId) {
+        if (!this.#worktreeManager || !this.#worktreeManager.enabled)
+            return;
+        if (this.#config?.delegation?.worktreeIsolation === false)
+            return;
+        if (!this.#managedAgentContexts)
+            return;
+        try {
+            const ticket = await fetchTicketContext(this.#config, ticketId);
+            if (!ticket || !ticket.terminal_entered_at)
+                return;
+            let total = 0;
+            const seenRoots = new Set();
+            for (const ctx of this.#managedAgentContexts.list()) {
+                if (!ctx.working_dir)
+                    continue;
+                const worktreesRoot = join(MANAGED_AGENTS_DIR, ctx.agent_id, 'worktrees');
+                const dedupeKey = `${ctx.working_dir} ${worktreesRoot}`;
+                if (seenRoots.has(dedupeKey))
+                    continue;
+                seenRoots.add(dedupeKey);
+                total += await this.#worktreeManager.removeTicketWorktrees({
+                    baseWorkingDir: ctx.working_dir,
+                    worktreesRoot,
+                    ticketId,
+                });
+            }
+            if (total > 0) {
+                log(`[worktree] terminal ticket=${ticketId.slice(0, 8)} reclaimed ${total} worktree(s)`);
+            }
+        }
+        catch (err) {
+            log(`[worktree] terminal cleanup failed for ticket=${ticketId.slice(0, 8)}: ${err?.message ?? err}`);
+        }
+    }
+    #resolveAgentContext(eventAgentId) {
+        if (!eventAgentId || !this.#managedAgentContexts)
+            return undefined;
+        const ctx = this.#managedAgentContexts.get(eventAgentId);
+        if (!ctx)
+            return undefined;
+        if (!ctx.api_key || !ctx.working_dir || !ctx.mcp_config_path)
+            return undefined;
+        return {
+            agent_id: ctx.agent_id,
+            api_key: ctx.api_key,
+            cwd: ctx.working_dir,
+            mcp_config_path: ctx.mcp_config_path,
+            cli: ctx.cli || 'claude',
+            cli_home_dir: ctx.cli_home_dir,
+            extra_env: ctx.extra_env,
+            credential_provider: ctx.credential_provider ?? null,
+            model: ctx.model ?? null,
+        };
+    }
+    #resolveAgentContextFromMembers(memberIds) {
+        if (!memberIds.length || !this.#managedAgentContexts)
+            return undefined;
+        for (const id of memberIds) {
+            const ctx = this.#resolveAgentContext(id);
+            if (ctx)
+                return ctx;
+        }
+        return undefined;
+    }
+    #senderIsSelf(senderId) {
+        if (!senderId)
+            return false;
+        const selfAgentId = loadAgentInfo()?.agent_id || '';
+        if (selfAgentId && senderId === selfAgentId)
+            return true;
+        return !!this.#managedAgentContexts?.has(senderId);
+    }
+    dispatch(eventType, raw) {
+        if (!raw)
+            return;
+        switch (eventType) {
+            case 'agent_trigger':
+            case 'board_update':
+            case 'chat_request':
+            case 'chat_room_message':
+            case 'comment_mention':
+            case 'fs_request':
+            case 'agent_manager_command':
+                recordEvent(eventType, raw);
+                break;
+            default:
+                return;
+        }
+        switch (eventType) {
+            case 'agent_trigger':
+                return this.handleTrigger(raw);
+            case 'board_update':
+                return this.handleBoardUpdate(raw);
+            case 'chat_request':
+                return this.handleChatRequest(raw);
+            case 'chat_room_message':
+                return this.handleChatRoomMessage(raw);
+            case 'comment_mention':
+                return this.handleCommentMention(raw);
+            case 'fs_request':
+                return this.handleFsRequest(raw);
+            case 'agent_manager_command':
+                return this.#agentManagerCommandHandler
+                    ? this.#agentManagerCommandHandler.handle(raw)
+                    : undefined;
+        }
+    }
+    async handleFsRequest(raw) {
+        let ev;
+        try {
+            ev = JSON.parse(raw);
+        }
+        catch (err) {
+            log(`Failed to parse fs_request: ${err?.message ?? err}`);
+            return;
+        }
+        const requestId = ev.request_id;
+        if (!requestId) {
+            log('fs_request missing request_id — dropped');
+            return;
+        }
+        if (!this.#fsBrowser) {
+            log('handleFsRequest: no FsBrowser wired — lazy-constructing a default. Fix main.ts wiring.');
+            const { FsBrowser } = await import('./fs-browser.js');
+            this.#fsBrowser = new FsBrowser(this.#config, null);
+        }
+        const result = await this.#fsBrowser.handle({
+            op: ev.op,
+            path: ev.path,
+            offset: ev.offset,
+            limit: ev.limit,
+            name: ev.name,
+        });
+        await postFsResponse(this.#config, requestId, result);
+        log(`fs_request ${ev.op} ${ev.path} → ${result.ok ? 'ok' : `err:${result.code || 'FS_ERROR'}`}`);
+    }
+    async handleTrigger(raw) {
+        let ev;
+        try {
+            ev = JSON.parse(raw);
+        }
+        catch (err) {
+            log(`Failed to parse trigger: ${err?.message ?? err}`);
+            return;
+        }
+        const selfAgentId = loadAgentInfo()?.agent_id || '';
+        const eventAgentId = ev.actor_name || ev.agent_id || '';
+        const agentContext = this.#resolveAgentContext(eventAgentId);
+        if (selfAgentId &&
+            eventAgentId &&
+            selfAgentId !== eventAgentId &&
+            !agentContext) {
+            log(`Trigger dropped (not for this agent): target=${eventAgentId} self=${selfAgentId}`);
+            return;
+        }
+        await this.#applyWorktreeCwd(agentContext, ev.ticket_id, ev.action);
+        const harness = parseHarnessConfig(ev.harness_config);
+        if (harness) {
+            log(`Trigger carries harness_config: ticket=${ev.ticket_id} keys=${Object.keys(harness).join(',')}`);
+        }
+        const effortPreset = parseEffortPreset(ev.effort_preset);
+        if (effortPreset) {
+            log(`Trigger carries effort_preset: id=${effortPreset.id}${effortPreset.label ? ` (${effortPreset.label})` : ''} ticket=${ev.ticket_id}`);
+        }
+        const envConfig = parseEnvironmentConfig(ev.environment_config);
+        const envVars = envConfig?.env_vars && Object.keys(envConfig.env_vars).length > 0
+            ? envConfig.env_vars
+            : undefined;
+        if (envConfig && this.#environmentProvisioner) {
+            const provisionAgentId = agentContext?.agent_id || selfAgentId;
+            if (!provisionAgentId) {
+                log(`[env-provision] no agent id resolvable for ticket=${ev.ticket_id} — skipping provisioning`);
+            }
+            else {
+                log(`Trigger carries environment_config: ticket=${ev.ticket_id} repos=${envConfig.repositories.length} setup=${envConfig.setup_commands.length} env_vars=${Object.keys(envConfig.env_vars).length}`);
+                const result = await this.#environmentProvisioner.provision({
+                    agentId: provisionAgentId,
+                    config: envConfig,
+                    ticketId: ev.ticket_id,
+                });
+                if (!result.ok) {
+                    if (!result.reported && ev.ticket_id) {
+                        const detail = (result.steps.length > 0 ? `\n\n실행 단계:\n${result.steps.map((s) => `- ${s}`).join('\n')}` : '');
+                        await fireAndForgetTool(this.#config, 'add_comment', {
+                            ticket_id: ev.ticket_id,
+                            content: `⚠️ **환경 프로비저닝 실패** — 작업을 시작하지 않고 디스패치를 중단했습니다.\n\n` +
+                                `\`\`\`\n${result.error || 'unknown error'}\n\`\`\`${detail}\n\n` +
+                                `Board 환경설정(repositories / setup_commands)을 확인한 뒤 다시 트리거하세요. ` +
+                                `(fingerprint=\`${result.fingerprint.slice(0, 12)}\`, 약 5분 동안 재시도/재알림을 억제합니다.)`,
+                        });
+                    }
+                    log(`Trigger aborted — environment provisioning failed: ticket=${ev.ticket_id} fp=${result.fingerprint.slice(0, 8)} reported=${result.reported === true}`);
+                    return;
+                }
+                if (!result.skipped) {
+                    log(`Environment provisioned for ticket=${ev.ticket_id} fp=${result.fingerprint.slice(0, 8)}`);
+                }
+            }
+        }
+        const delegation = this.#config?.delegation ?? {};
+        const delegationEnabled = delegation.enabled !== false;
+        const persistentTicket = delegation.persistentTicketSessions !== false;
+        if (delegationEnabled && persistentTicket && this.#ticketSessionManager) {
+            try {
+                const ticket = await fetchTicketContext(this.#config, ev.ticket_id);
+                const rolePrompt = ev.role_prompt || '';
+                const ticketPrompt = ev.ticket_prompt || '';
+                const columnPrompt = ev.column_prompt || null;
+                const result = await this.#ticketSessionManager.dispatchTrigger({
+                    ticketId: ev.ticket_id || '',
+                    role: ev.action || '',
+                    triggerId: ev.field_changed || '',
+                    agentId: ev.actor_name || '',
+                    rolePrompt,
+                    ticketPrompt,
+                    columnPrompt,
+                    ticket,
+                    forceRespawn: ev.force_respawn === true,
+                    triggerSource: ev.trigger_source || '',
+                    agentContext,
+                    harness,
+                    effortPreset,
+                    envVars,
+                    maxConcurrentTicketsPerAgent: typeof ev.max_concurrent_tickets_per_agent === 'number'
+                        ? ev.max_concurrent_tickets_per_agent
+                        : undefined,
+                });
+                if (result.dispatched) {
+                    log(`Trigger dispatched to ticket session: ticket=${ev.ticket_id} pid=${result.pid}${result.firstTurn ? ' (new session)' : ''}`);
+                    return;
+                }
+                if (result.reason === 'duplicate_trigger') {
+                    log(`Trigger deduped: ticket=${ev.ticket_id} trigger=${ev.field_changed || ''}`);
+                    return;
+                }
+                if (result.reason === 'circuit_breaker_open') {
+                    log(`Trigger blocked by circuit-breaker: ticket=${ev.ticket_id} — not falling back to one-shot`);
+                    return;
+                }
+                log(`Ticket session dispatch declined (${result.reason}), falling back to one-shot subagent`);
+            }
+            catch (err) {
+                log(`Ticket session path failed: ${err?.message ?? err}, falling back to one-shot subagent`);
+            }
+        }
+        const canDelegate = delegationEnabled && this.#subagentManager && this.#subagentManager.canSpawn();
+        if (canDelegate && this.#subagentManager) {
+            try {
+                const ticket = await fetchTicketContext(this.#config, ev.ticket_id);
+                const rolePrompt = ev.role_prompt || '';
+                const ticketPrompt = ev.ticket_prompt || '';
+                const columnPrompt = ev.column_prompt || null;
+                const taskText = this.#prompts?.composeTriggerPrompt(ticket, rolePrompt, ticketPrompt, ev.ticket_id, columnPrompt) ?? `[trigger] ${ev.ticket_id}`;
+                const result = await this.#subagentManager.spawn({
+                    kind: 'trigger',
+                    taskText,
+                    rolePrompt,
+                    triggerId: ev.field_changed || '',
+                    ticketId: ev.ticket_id || '',
+                    agentId: ev.actor_name || '',
+                    role: ev.action || '',
+                    triggerSource: ev.trigger_source || '',
+                    agentContext,
+                    harness,
+                    effortPreset,
+                    envVars,
+                });
+                if (result.spawned) {
+                    log(`Trigger dispatched to subagent: ticket=${ev.ticket_id} pid=${result.pid}${agentContext ? ` agent=${agentContext.agent_id.slice(0, 8)}` : ''}`);
+                    return;
+                }
+                log(`Subagent spawn declined (${result.reason}); no further fallback in standalone mode`);
+            }
+            catch (err) {
+                log(`Delegation path failed: ${err?.message ?? err}; dropping`);
+            }
+        }
+        log(`Trigger processed (no delegation path spawned): ticket=${ev.ticket_id} role=${ev.action}`);
+    }
+    async handleChatRequest(raw) {
+        let ev;
+        try {
+            ev = JSON.parse(raw);
+        }
+        catch (err) {
+            log(`Failed to parse chat_request: ${err?.message ?? err}`);
+            return;
+        }
+        const payload = ev.payload || {};
+        const agentContext = this.#resolveAgentContext(payload.agent_id || '');
+        const delegation = this.#config?.delegation ?? {};
+        const delegationEnabled = delegation.enabled !== false;
+        const persistentChat = delegation.persistentChatSessions !== false;
+        if (delegationEnabled &&
+            persistentChat &&
+            this.#chatSessionManager &&
+            payload.room_id) {
+            const onProgress = (stage) => {
+                const status = stage === 'thinking' ? 'thinking' : 'composing reply';
+                this.#setChatRoomTyping(payload.room_id, true, status).catch(() => { });
+            };
+            try {
+                const result = await this.#chatSessionManager.dispatch({
+                    roomId: payload.room_id,
+                    agentId: payload.agent_id || agentContext?.agent_id || loadAgentInfo()?.agent_id || '',
+                    senderId: payload.user_id || '',
+                    senderName: '',
+                    createdAt: ev.timestamp || '',
+                    content: payload.new_message || '',
+                    rolePrompt: payload.role_prompt || '',
+                    onProgress,
+                    agentContext,
+                });
+                if (result.dispatched) {
+                    log(`Chat request dispatched to session: room=${payload.room_id} pid=${result.pid}${result.firstTurn ? ' (new session)' : ''}`);
+                    return;
+                }
+                if (result.reason === 'duplicate_chat') {
+                    log(`Chat request deduped: room=${payload.room_id} user=${payload.user_id} ts=${ev.timestamp || ''}`);
+                    return;
+                }
+                log(`Chat session dispatch declined (${result.reason}), falling back to legacy path`);
+            }
+            catch (err) {
+                log(`Chat session path failed: ${err?.message ?? err}, falling back to legacy path`);
+            }
+        }
+        const canDelegate = delegationEnabled && this.#subagentManager && this.#subagentManager.canSpawn();
+        if (canDelegate && this.#subagentManager) {
+            const rolePrompt = payload.role_prompt || '';
+            const history = Array.isArray(payload.history) ? payload.history : [];
+            const newMessage = payload.new_message || '';
+            const usesNativeMcp = createAdapter(agentContext?.cli).has(ADAPTER_CAPABILITIES.NATIVE_MCP);
+            const taskText = this.#prompts?.composeChatPrompt(rolePrompt, history, newMessage, payload.room_id || '', usesNativeMcp) ?? `[chat] ${newMessage}`;
+            try {
+                const result = await this.#subagentManager.spawn({
+                    kind: 'chat',
+                    taskText,
+                    rolePrompt,
+                    chatRequestId: payload.user_id
+                        ? `msg:${payload.user_id}:${ev.timestamp || ''}`
+                        : undefined,
+                    ticketId: payload.ticket_id || '',
+                    agentId: payload.agent_id || '',
+                    roomId: payload.room_id || '',
+                    agentContext,
+                });
+                if (result.spawned) {
+                    log(`Chat request dispatched to subagent: agent=${payload.agent_id} pid=${result.pid}`);
+                    return;
+                }
+                log(`Chat subagent spawn declined (${result.reason}); no further fallback in standalone mode`);
+            }
+            catch (err) {
+                log(`Chat delegation path failed: ${err?.message ?? err}; dropping`);
+            }
+        }
+        log(`Chat request dropped (no delegation path): agent=${payload.agent_id} user=${payload.user_id}`);
+    }
+    async handleCommentMention(raw) {
+        let ev;
+        try {
+            ev = JSON.parse(raw);
+        }
+        catch (err) {
+            log(`Failed to parse comment_mention: ${err?.message ?? err}`);
+            return;
+        }
+        const ticketId = ev.ticket_id || '';
+        const commentId = ev.comment_id || ev.field_changed || '';
+        const agentId = ev.agent_id || ev.actor_name || '';
+        const agentContext = this.#resolveAgentContext(agentId);
+        const mention = {
+            ticket_id: ticketId,
+            comment_id: commentId,
+            actor_name: ev.actor_name || '',
+            actor_id: ev.actor_id || '',
+            content: ev.content || '',
+            mention_source: ev.mention_source || 'direct',
+            role_shortcut: ev.role_shortcut || '',
+        };
+        const delegation = this.#config?.delegation ?? {};
+        const delegationEnabled = delegation.enabled !== false;
+        const persistentTicket = delegation.persistentTicketSessions !== false;
+        if (delegationEnabled && persistentTicket && this.#ticketSessionManager && ticketId) {
+            try {
+                const forwarded = this.#ticketSessionManager.forwardCommentMention(ticketId, mention, ev.agent_id || '');
+                if (forwarded) {
+                    log(`Comment mention forwarded to ticket session: ticket=${ticketId} comment=${commentId}`);
+                    return;
+                }
+            }
+            catch (err) {
+                log(`Ticket session forward failed for comment_mention: ${err?.message ?? err}`);
+            }
+        }
+        const canDelegate = delegationEnabled && this.#subagentManager && this.#subagentManager.canSpawn();
+        if (canDelegate && this.#subagentManager) {
+            try {
+                const ticket = ticketId ? await fetchTicketContext(this.#config, ticketId) : null;
+                const rolePrompt = ev.role_prompt || '';
+                const taskText = this.#prompts?.composeCommentMentionPrompt(ticket, rolePrompt, mention, ticketId) ?? `[mention] ${ticketId} ${commentId}`;
+                const result = await this.#subagentManager.spawn({
+                    kind: 'trigger',
+                    taskText,
+                    rolePrompt,
+                    triggerId: mentionTriggerId(commentId, agentId),
+                    ticketId,
+                    agentId,
+                    role: mention.mention_source === 'role' ? mention.role_shortcut || '' : '',
+                    agentContext,
+                });
+                if (result.spawned) {
+                    log(`Comment mention dispatched to subagent: ticket=${ticketId} comment=${commentId} pid=${result.pid}`);
+                    return;
+                }
+                log(`Comment mention subagent spawn declined (${result.reason}); no further fallback in standalone mode`);
+            }
+            catch (err) {
+                log(`Comment mention delegation failed: ${err?.message ?? err}; dropping`);
+            }
+        }
+        log(`Comment mention dropped (no delegation path): ticket=${ticketId} comment=${commentId}`);
+    }
+    handleBoardUpdate(raw) {
+        try {
+            const ev = JSON.parse(raw);
+            if (ev.entity_type === 'ticket' && ev.action === 'moved' && ev.ticket_id) {
+                void this.#cleanupTerminalTicketWorktrees(ev.ticket_id);
+            }
+            if (this.#ticketSessionManager && ev.ticket_id) {
+                const forwarded = this.#ticketSessionManager.forwardBoardUpdate(ev.ticket_id, ev);
+                if (forwarded) {
+                    log(`Board update forwarded to ticket session: ticket=${ev.ticket_id} ${ev.entity_type}.${ev.action}`);
+                    return;
+                }
+            }
+            log(`Board update dropped (no live ticket session): ticket=${ev.ticket_id} ${ev.entity_type}.${ev.action}`);
+        }
+        catch (err) {
+            log(`Failed to parse board_update: ${err?.message ?? err}`);
+        }
+    }
+    async #setChatRoomTyping(roomId, isTyping, status = null) {
+        try {
+            const agentInfo = loadAgentInfo();
+            const url = `${this.#config.url.replace(/\/$/, '')}/api/agent/chat-rooms/${encodeURIComponent(roomId)}/typing`;
+            await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'X-Agent-Key': this.#config.apiKey,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    agent_id: agentInfo?.agent_id || '',
+                    agent_name: agentInfo?.agent_name || agentInfo?.name || 'Agent',
+                    is_typing: isTyping,
+                    status,
+                }),
+                signal: AbortSignal.timeout(5000),
+            });
+        }
+        catch (err) {
+            log(`setChatRoomTyping failed: ${err?.message ?? err}`);
+        }
+    }
+    async handleChatRoomMessage(raw) {
+        let ev;
+        try {
+            ev = JSON.parse(raw);
+        }
+        catch (err) {
+            log(`Failed to parse chat_room_message: ${err?.message ?? err}`);
+            return;
+        }
+        const p = ev.payload || ev;
+        if (p.type === 'progress') {
+            log(`Chat room message is progress heartbeat (room=${p.room_id} sender=${p.sender_name || p.sender_id}) — skipping delegation`);
+            return;
+        }
+        const memberIds = Array.isArray(p.agent_member_ids) ? p.agent_member_ids : [];
+        const agentContext = this.#resolveAgentContextFromMembers(memberIds);
+        if (p.sender_type === 'agent') {
+            if (this.#senderIsSelf(p.sender_id)) {
+                this.#chatSessionManager?.recordRoomMessage(p);
+                log(`Chat room message from self (${p.sender_name || p.sender_id}) — skipping delegation`);
+                return;
+            }
+            const depth = typeof p.agent_chain_depth === 'number' ? p.agent_chain_depth : 0;
+            if (depth >= AGENT_CHAIN_DEPTH_CAP) {
+                this.#chatSessionManager?.recordRoomMessage(p);
+                log(`Chat room message from agent (${p.sender_name || p.sender_id}) — agent_chain_depth=${depth} ` +
+                    `>= cap ${AGENT_CHAIN_DEPTH_CAP}, skipping delegation to break loop`);
+                return;
+            }
+        }
+        let runContext = agentContext;
+        const runProvision = parseRunProvision(p.run_provision);
+        if (runProvision) {
+            log(`Chat room run dispatch: kind=${runProvision.kind} run=${runProvision.run_id.slice(0, 8)} ` +
+                `folder=${runProvision.workspace_folder} checkout=${runProvision.checkout_mode} ` +
+                `repo=${runProvision.repo ? runProvision.repo.url : 'none'}`);
+            const result = await provisionRunWorkspace(runProvision);
+            if (!result.ok) {
+                const responder = agentContext?.agent_id || loadAgentInfo()?.agent_id || '';
+                if (p.room_id && responder) {
+                    const detail = result.steps.length > 0 ? `\n\n실행 단계:\n${result.steps.map((s) => `- ${s}`).join('\n')}` : '';
+                    await postChatRoomMessage(this.#config, p.room_id, responder, `⚠️ **런 작업폴더 프로비저닝 실패** — 작업을 시작하지 않고 디스패치를 중단했습니다.\n\n` +
+                        `\`\`\`\n${result.error || 'unknown error'}\n\`\`\`${detail}\n\n` +
+                        `시나리오의 repo / branch / checkout 설정을 확인한 뒤 다시 실행하세요.`).catch(() => { });
+                }
+                const completeTool = runProvision.kind === 'qa' ? 'complete_qa_run' : 'complete_security_run';
+                await fireAndForgetTool(this.#config, completeTool, {
+                    run_id: runProvision.run_id,
+                    workspace_id: runProvision.workspace_id,
+                    status: 'error',
+                    summary: `작업폴더 프로비저닝 실패: ${result.error || 'unknown error'}`,
+                });
+                if (p.room_id)
+                    await this.#setChatRoomTyping(p.room_id, false, '').catch(() => { });
+                log(`Chat room run dispatch aborted — provisioning failed: run=${runProvision.run_id.slice(0, 8)} dir=${result.dir}`);
+                return;
+            }
+            if (agentContext)
+                runContext = { ...agentContext, cwd: result.dir };
+            log(`Run workspace ready: run=${runProvision.run_id.slice(0, 8)} dir=${result.dir}`);
+        }
+        if (p.room_id) {
+            await this.#setChatRoomTyping(p.room_id, true, '👀 reading context');
+        }
+        const onProgress = p.room_id
+            ? (stage) => {
+                const status = stage === 'thinking' ? 'thinking' : 'composing reply';
+                this.#setChatRoomTyping(p.room_id, true, status).catch(() => { });
+            }
+            : undefined;
+        const delegation = this.#config?.delegation ?? {};
+        const delegationEnabled = delegation.enabled !== false;
+        const persistentChat = delegation.persistentChatSessions !== false;
+        if (delegationEnabled && persistentChat && this.#chatSessionManager && p.room_id) {
+            const responderAgentId = agentContext?.agent_id || loadAgentInfo()?.agent_id || '';
+            try {
+                const result = await this.#chatSessionManager.dispatch({
+                    roomId: p.room_id,
+                    agentId: responderAgentId,
+                    senderId: p.sender_id || '',
+                    senderName: p.sender_name || '',
+                    createdAt: p.created_at || '',
+                    content: p.content || '',
+                    rolePrompt: p.role_prompt || '',
+                    onProgress,
+                    agentContext: runContext,
+                    attachments: Array.isArray(p.attachments) ? p.attachments : [],
+                });
+                this.#chatSessionManager?.recordRoomMessage(p);
+                if (result.dispatched) {
+                    log(`Chat room message dispatched to session: room=${p.room_id} ` +
+                        `agent=${responderAgentId.slice(0, 8)} pid=${result.pid}` +
+                        `${result.firstTurn ? ' (new session)' : ''}`);
+                    return;
+                }
+                if (result.reason === 'duplicate_chat') {
+                    log(`Chat room message deduped: room=${p.room_id} sender=${p.sender_id} ts=${p.created_at || ''}`);
+                    return;
+                }
+                log(`Chat room session dispatch declined (${result.reason}), falling back to legacy path`);
+            }
+            catch (err) {
+                log(`Chat room session path failed: ${err?.message ?? err}, falling back to legacy path`);
+            }
+        }
+        const canDelegate = delegationEnabled && this.#subagentManager && this.#subagentManager.canSpawn();
+        if (canDelegate && this.#subagentManager) {
+            try {
+                await this.#setChatRoomTyping(p.room_id, true, 'thinking');
+                const history = await fetchChatRoomHistory(this.#config, p.room_id);
+                const rolePrompt = p.role_prompt || '';
+                const prepared = await prepareChatAttachments(this.#config, p.room_id, Array.isArray(p.attachments) ? p.attachments : [], { fetchImages: false });
+                const usesNativeMcp = createAdapter(agentContext?.cli).has(ADAPTER_CAPABILITIES.NATIVE_MCP);
+                const taskText = this.#prompts?.composeChatRoomPrompt(p.room_id, history, {
+                    content: p.content || '',
+                    sender_name: p.sender_name || '',
+                    sender_id: p.sender_id || '',
+                }, prepared, usesNativeMcp) ?? `[chat_room] ${p.content || ''}`;
+                const result = await this.#subagentManager.spawn({
+                    kind: 'chat',
+                    taskText,
+                    rolePrompt,
+                    chatRequestId: `msg:${p.sender_id}:${p.created_at || ''}`,
+                    ticketId: '',
+                    agentId: agentContext?.agent_id || '',
+                    roomId: p.room_id || '',
+                    agentContext: runContext,
+                });
+                if (result.spawned) {
+                    await this.#setChatRoomTyping(p.room_id, true, 'composing reply');
+                    log(`Chat room message dispatched to subagent: room=${p.room_id} pid=${result.pid}`);
+                    return;
+                }
+                log(`Chat room subagent spawn declined (${result.reason}); no further fallback in standalone mode`);
+            }
+            catch (err) {
+                log(`Chat room delegation path failed: ${err?.message ?? err}; dropping`);
+            }
+        }
+        log(`Chat room message dropped (no delegation path): room=${p.room_id} sender=${p.sender_name || p.sender_id}`);
+    }
+}
+//# sourceMappingURL=event-dispatcher.js.map