@agent-spaces/server 0.1.2 → 0.2.1

package/dist/ws/handler.js

@@ -1,46 +1,11 @@
 import { addConnection, broadcastToWorkspace } from './connection-manager.js';
 import { handleTerminalEvent } from './terminal-handler.js';
-import { createMessage, updateMessage, listMessages } from '../services/message.js';
-import { getChannel, updateChannel } from '../services/channel.js';
-import * as issueService from '../services/issue.js';
-import { createIssueFunctionTools } from '../services/builtin-tools.js';
-import { startScheduler } from '../agents/scheduler-agent.js';
+import { createMessage } from '../services/message.js';
+import { getChannel } from '../services/channel.js';
 import * as agentService from '../services/agent.js';
-import * as wsService from '../services/workspace.js';
-import { runPlanner } from '../agents/planner-agent.js';
-import { createAgentRuntime } from '../adapters/agent-runtime.js';
-import { saveToolDetails } from '../services/tool-detail.js';
-import { readWorkspacePrompt } from '../services/workspace-prompt.js';
-import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+import { runMentionedAgent, stopChannelRuns, handleAnswerQuestion, ensureScheduler, makeContext } from './agent-runner.js';
+import { stripHtml, extractMentionIds } from './html-utils.js';
 const handlers = new Map();
-// Track which workspaces have schedulers running
-const activeSchedulers = new Set();
-const activeChannelRuns = new Map();
-const pendingQuestionRuns = new Map();
-function ensureScheduler(workspaceId, ctx) {
-    if (!activeSchedulers.has(workspaceId)) {
-        activeSchedulers.add(workspaceId);
-        setTimeout(() => {
-            startScheduler(workspaceId, ctx);
-            console.log(`[ws] scheduler started for workspace ${workspaceId}`);
-        }, 10_000);
-        console.log(`[ws] scheduler scheduled for workspace ${workspaceId} in 10000ms`);
-    }
-}
-function makeContext(workspaceId) {
-    return {
-        workspaceId,
-        broadcast: (event, data) => broadcastToWorkspace(workspaceId, event, data),
-        getSession: (sessionId) => agentService.getById(workspaceId, sessionId),
-        updateSessionStatus: (sessionId, status, extra) => agentService.updateStatus(workspaceId, sessionId, status, extra),
-    };
-}
-function getRuntimeBaseURL(provider, apiBase) {
-    if (provider === 'openai-responses-to-anthropic-messages'
-        || provider === 'openai-chat-completions-to-anthropic-messages')
-        return undefined;
-    return apiBase;
-}
 export function registerHandler(event, handler) {
     handlers.set(event, handler);
 }
@@ -82,7 +47,7 @@ for (const evt of terminalEvents) {
         handleTerminalEvent(ws, workspaceId, evt, data);
     });
 }
-// Register channel handler
+// Register channel handlers
 registerHandler('channel.message', (_ws, workspaceId, data) => {
     const { channelId, content, type, mentions, attachments } = data;
     if (!channelId || (!content && !attachments?.length))
@@ -107,1169 +72,12 @@ registerHandler('channel.stop', (_ws, workspaceId, data) => {
         return;
     stopChannelRuns(workspaceId, channelId);
 });
-registerHandler('channel.answer_question', (_ws, workspaceId, data) => {
-    const { channelId, messageId, questionId, answer } = data;
-    const trimmed = answer?.trim();
-    if (!channelId || !messageId || !questionId || !trimmed)
-        return;
-    const message = listMessages(workspaceId, channelId).find((item) => item.id === messageId);
-    if (!message)
-        return;
-    const updatedParts = message.parts?.map((part) => {
-        if (part.type !== 'ask_user_question' || part.id !== questionId)
-            return part;
-        return { ...part, status: 'answered', answer: trimmed };
-    });
-    const updated = updateMessage(workspaceId, channelId, messageId, {
-        status: 'streaming',
-        parts: updatedParts,
-    });
-    if (updated)
-        broadcastToWorkspace(workspaceId, 'channel.message.updated', updated);
-    const key = questionRunKey(workspaceId, channelId, messageId, questionId);
-    const pending = pendingQuestionRuns.get(key);
-    pendingQuestionRuns.delete(key);
-    if (!pending)
-        return;
-    const seedQuestion = questionFromAnsweredPart(updatedParts, questionId);
-    void runMentionedAgent(workspaceId, channelId, pending.agentConfigId, [
-        'The user answered your previous question.',
-        `Question: ${pending.question}`,
-        `Answer: ${trimmed}`,
-        'Continue from this answer and complete the original task.',
-    ].join('\n'), {
-        messageId,
-        seedOutput: normalizeOutputLines([message.content]),
-        seedQuestions: seedQuestion ? [seedQuestion] : [],
-    });
-});
-async function runMentionedAgent(workspaceId, channelId, agentConfigId, prompt, options = {}) {
-    const preset = agentService.listPresets(workspaceId)?.find((agent) => agent.id === agentConfigId);
-    if (!preset || preset.enabled === false)
-        return;
-    const session = agentService.create(workspaceId, preset.role, preset.id);
-    broadcastToWorkspace(workspaceId, 'agent.started', session);
-    agentService.updateStatus(workspaceId, session.id, 'active');
-    broadcastToWorkspace(workspaceId, 'agent.status_changed', {
-        agentId: session.id,
-        from: 'idle',
-        to: 'active',
-    });
-    const configDir = agentService.getAgentConfigDir(workspaceId, preset);
-    const mcpServers = agentService.getMcpServers(preset.mcps);
-    const skills = agentService.getAvailableSkillNames(configDir, preset.skills);
-    const workspace = wsService.getById(workspaceId);
-    const { channel, issue } = resolveIssueChannelContext(workspaceId, channelId);
-    const functionTools = createIssueFunctionTools(workspaceId, channel, {
-        senderId: preset.id,
-        senderRole: preset.role,
-    }, preset.tools);
-    const startTime = Date.now();
-    const existingMessage = options.messageId
-        ? listMessages(workspaceId, channelId).find((message) => message.id === options.messageId)
-        : undefined;
-    const pending = existingMessage
-        ? updateMessage(workspaceId, channelId, existingMessage.id, {
-            status: 'streaming',
-            metadata: {
-                ...existingMessage.metadata,
-                agentSessionId: session.id,
-                runtime: preset.runtimeKind,
-                model: preset.modelId,
-                duration: 0,
-            },
-        }) ?? existingMessage
-        : createMessage(workspaceId, channelId, {
-            senderId: preset.id,
-            senderRole: preset.role,
-            content: 'Agent is processing...',
-            type: 'text',
-            status: 'streaming',
-            metadata: {
-                agentSessionId: session.id,
-                runtime: preset.runtimeKind,
-                model: preset.modelId,
-                duration: 0,
-            },
-            parts: [
-                {
-                    id: `reasoning-${session.id}`,
-                    type: 'reasoning',
-                    text: 'Preparing agent runtime and loading conversation context...',
-                    status: 'streaming',
-                },
-            ],
-        });
-    broadcastToWorkspace(workspaceId, existingMessage ? 'channel.message.updated' : 'channel.message', pending);
-    let activeRun;
-    const liveReasoning = [];
-    try {
-        const runtime = createAgentRuntime({
-            kind: preset.runtimeKind,
-            provider: preset.modelProvider,
-            model: preset.modelId,
-            apiKey: preset.apiKey,
-            baseURL: getRuntimeBaseURL(preset.modelProvider, preset.apiBase),
-            adapterBaseURL: preset.apiBase,
-            ...getThinkingRuntimeConfig(preset),
-        });
-        activeRun = {
-            agentId: session.id,
-            agentConfigId,
-            messageId: pending.id,
-            runtime,
-        };
-        trackChannelRun(workspaceId, channelId, activeRun);
-        const history = listMessages(workspaceId, channelId, { limit: 20 });
-        const liveOutput = [...(options.seedOutput ?? [])];
-        const askUserQuestions = [...(options.seedQuestions ?? [])];
-        const toolDetails = new Map();
-        const toolUseDetailIds = new Map();
-        let lastLiveUpdate = 0;
-        const broadcastLiveParts = (force = false) => {
-            const now = Date.now();
-            if (!force && now - lastLiveUpdate < 120)
-                return;
-            lastLiveUpdate = now;
-            const parts = buildAgentMessageParts({
-                sessionId: session.id,
-                workspaceRoot: workspace?.boundDirs?.[0],
-                presetName: preset.name || preset.role,
-                role: preset.role,
-                model: preset.modelId,
-                systemPrompt: preset.systemPrompt,
-                mcpServers: Object.keys(mcpServers ?? {}),
-                skills,
-                builtInTools: buildBuiltInTools(functionTools, channel, issue),
-                output: liveOutput,
-                reasoning: liveReasoning,
-                toolDetails,
-                askUserQuestions,
-                success: true,
-            });
-            if (parts.length === 0)
-                return;
-            const status = askUserQuestions.some((question) => !question.answer) ? 'waiting_for_user' : 'streaming';
-            const live = updateMessage(workspaceId, channelId, pending.id, {
-                content: liveOutput.join('\n') || pending.content,
-                status,
-                parts,
-                metadata: {
-                    ...pending.metadata,
-                    duration: Date.now() - startTime,
-                },
-            });
-            if (live)
-                broadcastToWorkspace(workspaceId, 'channel.message.updated', live);
-        };
-        const result = await runtime.execute(buildAgentPrompt(workspaceId, preset.systemPrompt, prompt, history, {
-            mcpServers: Object.keys(mcpServers ?? {}),
-            skills,
-            boundDirs: workspace?.boundDirs,
-            builtInTools: buildBuiltInTools(functionTools, channel, issue),
-        }), agentService.resolveWorkingDir(workspaceId, preset), {
-            maxTurns: 100,
-            functionTools,
-            mcpServers,
-            skills,
-            configDir,
-            sandboxDirs: preset.sandboxDirs,
-            onEvent: (event) => {
-                if (event.type === 'reasoning') {
-                    liveReasoning.push({ text: event.text, status: event.status });
-                    broadcastToWorkspace(workspaceId, 'agent.output', { agentId: session.id, data: event.text });
-                    broadcastLiveParts();
-                    return;
-                }
-                if (event.type === 'tool_use') {
-                    if (event.name === 'AskUserQuestion') {
-                        const question = parseAskUserQuestion(event.id, event.input);
-                        askUserQuestions.push(question);
-                        pendingQuestionRuns.set(questionRunKey(workspaceId, channelId, pending.id, question.id), {
-                            agentConfigId,
-                            question: question.question,
-                        });
-                        broadcastLiveParts(true);
-                        return;
-                    }
-                    // Intercept TodoWrite to persist todos to channel
-                    if (event.name === 'TodoWrite' && event.input && typeof event.input === 'object') {
-                        const input = event.input;
-                        if (Array.isArray(input.todos)) {
-                            const todos = input.todos.map((t, index) => ({
-                                id: String(t.id ?? t.activeForm ?? t.subject ?? t.title ?? t.content ?? index),
-                                subject: String(t.subject ?? t.title ?? t.activeForm ?? t.content ?? ''),
-                                description: t.description || t.content ? String(t.description ?? t.content) : undefined,
-                                status: (['pending', 'in_progress', 'completed'].includes(t.status) ? t.status : 'pending'),
-                                activeForm: t.activeForm ? String(t.activeForm) : undefined,
-                            }));
-                            const updated = updateChannel(workspaceId, channelId, { todos });
-                            if (updated)
-                                broadcastToWorkspace(workspaceId, 'channel.updated', updated);
-                        }
-                    }
-                    const detailId = buildToolDetailId(event.id, event.line);
-                    toolUseDetailIds.set(event.id, detailId);
-                    toolDetails.set(detailId, {
-                        id: detailId,
-                        workspaceId,
-                        channelId,
-                        messageId: pending.id,
-                        title: summarizeToolLine(event.line, workspace?.boundDirs?.[0]).title,
-                        raw: event.line,
-                        input: event.input,
-                        createdAt: new Date().toISOString(),
-                    });
-                    saveToolDetails(workspaceId, channelId, Array.from(toolDetails.values()));
-                    liveOutput.push(event.line);
-                    broadcastToWorkspace(workspaceId, 'agent.output', { agentId: session.id, data: event.line });
-                    broadcastLiveParts();
-                    return;
-                }
-                if (event.type === 'tool_result') {
-                    const askedQuestion = event.toolUseId
-                        ? askUserQuestions.find((question) => question.toolUseId === event.toolUseId)
-                        : undefined;
-                    if (askedQuestion)
-                        return;
-                    const detail = findToolDetailForResult(event.toolUseId, event.result, toolUseDetailIds, toolDetails, workspace?.boundDirs?.[0]);
-                    if (detail && isAgentSpacesIssueTool(detail.raw || detail.title)) {
-                        const updatedChannel = getChannel(workspaceId, channelId);
-                        if (updatedChannel)
-                            broadcastToWorkspace(workspaceId, 'channel.updated', updatedChannel);
-                        const updatedIssue = updatedChannel?.issueId ? issueService.getById(workspaceId, updatedChannel.issueId) : null;
-                        if (updatedIssue) {
-                            broadcastToWorkspace(workspaceId, isCreateCurrentChannelIssueTool(detail.raw || detail.title) ? 'issue.created' : 'issue.updated', updatedIssue);
-                        }
-                    }
-                    if (detail) {
-                        detail.output = event.result;
-                        detail.updatedAt = new Date().toISOString();
-                        saveToolDetails(workspaceId, channelId, [detail]);
-                    }
-                    return;
-                }
-                if (event.type !== 'output')
-                    return;
-                liveOutput.push(event.line);
-                broadcastToWorkspace(workspaceId, 'agent.output', { agentId: session.id, data: event.line });
-                broadcastLiveParts();
-            },
-        });
-        broadcastLiveParts(true);
-        if (activeRun.stopped)
-            return;
-        const displayOutput = mergeRuntimeOutput(liveOutput, result.output);
-        if (shouldWaitForUserAnswer(askUserQuestions, result.summary, result.error, displayOutput)) {
-            const waitingOutput = stripAskUserQuestionErrorLines(liveOutput);
-            const waiting = updateMessage(workspaceId, channelId, pending.id, {
-                content: waitingOutput.join('\n') || pending.content,
-                type: 'text',
-                status: 'waiting_for_user',
-                metadata: {
-                    agentSessionId: session.id,
-                    runtime: preset.runtimeKind,
-                    model: preset.modelId,
-                    summary: 'Waiting for user answer',
-                    duration: Date.now() - startTime,
-                },
-                parts: buildAgentMessageParts({
-                    sessionId: session.id,
-                    workspaceRoot: workspace?.boundDirs?.[0],
-                    presetName: preset.name || preset.role,
-                    role: preset.role,
-                    model: preset.modelId,
-                    systemPrompt: preset.systemPrompt,
-                    mcpServers: Object.keys(mcpServers ?? {}),
-                    skills,
-                    output: waitingOutput,
-                    reasoning: liveReasoning,
-                    toolDetails,
-                    askUserQuestions,
-                    success: true,
-                }),
-            });
-            if (waiting)
-                broadcastToWorkspace(workspaceId, 'channel.message.updated', waiting);
-            agentService.updateStatus(workspaceId, session.id, 'blocked');
-            broadcastToWorkspace(workspaceId, 'agent.status_changed', {
-                agentId: session.id,
-                from: 'active',
-                to: 'blocked',
-            });
-            return;
-        }
-        if (liveOutput.length === 0) {
-            for (const line of result.output) {
-                broadcastToWorkspace(workspaceId, 'agent.output', { agentId: session.id, data: line });
-            }
-        }
-        agentService.complete(workspaceId, session.id, result.success ? undefined : result.error, {
-            runtime: preset.runtimeKind,
-            model: preset.modelId,
-            summary: result.summary,
-            output: displayOutput,
-            durationMs: Date.now() - startTime,
-            usage: result.usage,
-            costUsd: result.costUsd,
-        });
-        broadcastToWorkspace(workspaceId, 'agent.completed', {
-            agentId: session.id,
-            result: {
-                success: result.success,
-                summary: result.summary,
-                artifacts: result.artifacts,
-                error: result.error,
-            },
-            error: result.error,
-        });
-        const reply = updateMessage(workspaceId, channelId, pending.id, {
-            content: result.success ? displayOutput.join('\n') : result.error || displayOutput.join('\n'),
-            type: 'text',
-            status: result.success ? 'completed' : 'error',
-            metadata: {
-                agentSessionId: session.id,
-                runtime: preset.runtimeKind,
-                model: preset.modelId,
-                summary: result.summary,
-                duration: Date.now() - startTime,
-            },
-            parts: buildAgentMessageParts({
-                sessionId: session.id,
-                workspaceRoot: workspace?.boundDirs?.[0],
-                presetName: preset.name || preset.role,
-                role: preset.role,
-                model: preset.modelId,
-                usage: result.usage,
-                systemPrompt: preset.systemPrompt,
-                mcpServers: Object.keys(mcpServers ?? {}),
-                skills,
-                builtInTools: buildBuiltInTools(functionTools, channel, issue),
-                output: displayOutput,
-                reasoning: liveReasoning,
-                toolDetails,
-                askUserQuestions,
-                success: result.success,
-                error: result.error,
-            }),
-        });
-        if (reply)
-            broadcastToWorkspace(workspaceId, 'channel.message.updated', reply);
-    }
-    catch (err) {
-        if (activeRun?.stopped)
-            return;
-        const error = err instanceof Error ? err.message : String(err);
-        agentService.complete(workspaceId, session.id, error, {
-            runtime: preset.runtimeKind,
-            model: preset.modelId,
-            summary: error,
-            output: [error],
-            durationMs: Date.now() - startTime,
-        });
-        broadcastToWorkspace(workspaceId, 'agent.error', { agentId: session.id, error });
-        const reply = updateMessage(workspaceId, channelId, pending.id, {
-            content: error,
-            type: 'text',
-            status: 'error',
-            metadata: {
-                agentSessionId: session.id,
-                runtime: preset.runtimeKind,
-                model: preset.modelId,
-                duration: Date.now() - startTime,
-            },
-            parts: buildAgentMessageParts({
-                sessionId: session.id,
-                workspaceRoot: workspace?.boundDirs?.[0],
-                presetName: preset.name || preset.role,
-                role: preset.role,
-                model: preset.modelId,
-                systemPrompt: preset.systemPrompt,
-                mcpServers: Object.keys(mcpServers ?? {}),
-                skills,
-                builtInTools: buildBuiltInTools(functionTools, channel, issue),
-                output: [error],
-                reasoning: liveReasoning,
-                toolDetails: new Map(),
-                askUserQuestions: [],
-                success: false,
-                error,
-            }),
-        });
-        if (reply)
-            broadcastToWorkspace(workspaceId, 'channel.message.updated', reply);
-    }
-    finally {
-        untrackChannelRun(workspaceId, channelId, session.id);
-    }
-}
-function resolveIssueChannelContext(workspaceId, channelId) {
-    let channel = getChannel(workspaceId, channelId);
-    let issue = channel?.issueId ? issueService.getById(workspaceId, channel.issueId) : null;
-    if (issue || channel?.type !== 'issue')
-        return { channel, issue };
-    issue = issueService.list(workspaceId).find((item) => item.channelId === channelId) ?? null;
-    channel = getChannel(workspaceId, channelId);
-    return { channel, issue };
-}
-function isAgentSpacesIssueTool(name) {
-    return Boolean(name && /(?:agent-spaces\.)?(?:CreateCurrentChannelIssue|ViewCurrentChannelIssue|AddCurrentChannelComment)/.test(name));
-}
-function isCreateCurrentChannelIssueTool(name) {
-    return Boolean(name && /(?:agent-spaces\.)?CreateCurrentChannelIssue/.test(name));
-}
-function channelRunKey(workspaceId, channelId) {
-    return `${workspaceId}:${channelId}`;
-}
-function trackChannelRun(workspaceId, channelId, run) {
-    const key = channelRunKey(workspaceId, channelId);
-    const runs = activeChannelRuns.get(key) ?? new Map();
-    runs.set(run.agentId, run);
-    activeChannelRuns.set(key, runs);
-}
-function untrackChannelRun(workspaceId, channelId, agentId) {
-    const key = channelRunKey(workspaceId, channelId);
-    const runs = activeChannelRuns.get(key);
-    if (!runs)
-        return;
-    runs.delete(agentId);
-    if (runs.size === 0)
-        activeChannelRuns.delete(key);
-}
-function stopChannelRuns(workspaceId, channelId) {
-    const runs = activeChannelRuns.get(channelRunKey(workspaceId, channelId));
-    if (!runs || runs.size === 0) {
-        markInactiveChannelRunsStopped(workspaceId, channelId);
-        return;
-    }
-    for (const run of runs.values()) {
-        run.stopped = true;
-        run.runtime.stop();
-        agentService.complete(workspaceId, run.agentId, 'Stopped by user');
-        broadcastToWorkspace(workspaceId, 'agent.status_changed', {
-            agentId: run.agentId,
-            from: 'active',
-            to: 'crashed',
-        });
-        broadcastToWorkspace(workspaceId, 'agent.error', {
-            agentId: run.agentId,
-            error: 'Stopped by user',
-        });
-        const message = updateMessage(workspaceId, channelId, run.messageId, {
-            content: 'Stopped by user',
-            status: 'error',
-            parts: [
-                {
-                    id: `terminal-stopped-${run.agentId}`,
-                    type: 'terminal',
-                    output: 'Stopped by user',
-                    status: 'error',
-                },
-            ],
-        });
-        if (message)
-            broadcastToWorkspace(workspaceId, 'channel.message.updated', message);
-    }
-}
-export function hasActiveChannelRuns(workspaceId, channelId) {
-    return Boolean(activeChannelRuns.get(channelRunKey(workspaceId, channelId))?.size);
-}
-export function markInactiveChannelRunsStopped(workspaceId, channelId) {
-    if (hasActiveChannelRuns(workspaceId, channelId))
-        return [];
-    const stopped = [];
-    for (const message of listMessages(workspaceId, channelId)) {
-        if (message.status !== 'pending' && message.status !== 'streaming')
-            continue;
-        const updated = updateMessage(workspaceId, channelId, message.id, {
-            content: message.content || 'Stopped by user',
-            status: 'error',
-            parts: message.parts?.map((part) => {
-                if ('status' in part && part.status === 'streaming') {
-                    return { ...part, status: 'completed' };
-                }
-                return part;
-            }),
-        });
-        if (updated) {
-            stopped.push(updated);
-            broadcastToWorkspace(workspaceId, 'channel.message.updated', updated);
-        }
-    }
-    return stopped;
-}
-function buildAgentMessageParts(input) {
-    const lines = normalizeOutputLines(input.output);
-    const finalTextRange = findFinalTextRange(lines);
-    const finalText = finalTextRange
-        ? collapseRepeatedTextBlock(lines.slice(finalTextRange.start, finalTextRange.end + 1)).join('\n').trim()
-        : '';
-    const usage = input.usage ?? extractUsage(lines);
-    const parts = [];
-    const chainItems = buildChainItems(lines, finalTextRange, finalText, input.workspaceRoot, input.toolDetails);
-    const reasoningText = normalizeReasoningText(input.reasoning);
-    if (reasoningText) {
-        parts.push({
-            id: `reasoning-${input.sessionId}`,
-            type: 'reasoning',
-            text: reasoningText,
-            status: input.success ? 'completed' : 'streaming',
-        });
-    }
-    if (chainItems.length > 0) {
-        parts.push({
-            id: `chain-${input.sessionId}`,
-            type: 'chain',
-            chains: chainItems,
-        });
-    }
-    for (const subagent of extractSubagentBlocks(lines, input.sessionId, input.toolDetails)) {
-        parts.push(subagent);
-    }
-    for (const question of input.askUserQuestions ?? []) {
-        parts.push({
-            id: question.id,
-            type: 'ask_user_question',
-            question: question.question,
-            choices: question.choices,
-            status: question.answer ? 'answered' : 'requested',
-            answer: question.answer,
-            toolUseId: question.toolUseId,
-        });
-    }
-    if (hasTokenUsage(usage)) {
-        parts.push({
-            id: `context-${input.sessionId}`,
-            type: 'context',
-            usedTokens: getTotalTokens(usage),
-            maxTokens: 128_000,
-            modelId: input.model,
-            usage,
-        });
-    }
-    if (input.error) {
-        parts.push({
-            id: `terminal-error-${input.sessionId}`,
-            type: 'terminal',
-            output: input.error,
-            status: 'error',
-        });
-    }
-    if (finalText && finalText !== input.error) {
-        parts.push({
-            id: `text-${input.sessionId}`,
-            type: 'text',
-            text: finalText,
-        });
-    }
-    return parts;
-}
-function normalizeReasoningText(reasoning) {
-    if (!reasoning?.length)
-        return '';
-    return collapseRepeatedTextBlock(reasoning
-        .map((item) => item.text.trim())
-        .filter(Boolean)).join('\n\n').trim();
-}
-function hasTokenUsage(usage) {
-    return Boolean(usage.totalTokens || usage.inputTokens || usage.outputTokens || usage.cachedInputTokens || usage.reasoningTokens);
-}
-function getTotalTokens(usage) {
-    return usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0) + (usage.cachedInputTokens ?? 0) + (usage.reasoningTokens ?? 0);
-}
-function normalizeOutputLines(output) {
-    const lines = output
-        .flatMap((line) => line.split(/\r?\n/))
-        .map((line) => line.trimEnd())
-        .filter((line) => line.trim());
-    const seenInitLines = new Set();
-    return lines.filter((line) => {
-        if (!/^Claude Code initialized\b/i.test(line))
-            return true;
-        if (seenInitLines.has(line))
-            return false;
-        seenInitLines.add(line);
-        return true;
-    });
-}
-function mergeRuntimeOutput(liveOutput, resultOutput) {
-    if (liveOutput.length === 0)
-        return resultOutput;
-    const finalResult = resultOutput.at(-1)?.trim();
-    if (!finalResult)
-        return liveOutput;
-    if (liveOutput.some((line) => normalizeMessageText(line) === normalizeMessageText(finalResult))) {
-        return liveOutput;
-    }
-    return [...liveOutput, finalResult];
-}
-function collapseRepeatedTextBlock(lines) {
-    let next = [...lines];
-    while (next.length > 1 && next.length % 2 === 0) {
-        const middle = next.length / 2;
-        const first = next.slice(0, middle);
-        const second = next.slice(middle);
-        if (!sameTextBlock(first, second))
-            break;
-        next = first;
-    }
-    return next;
-}
-function sameTextBlock(left, right) {
-    if (left.length !== right.length)
-        return false;
-    return normalizeMessageText(left.join('\n')) === normalizeMessageText(right.join('\n'));
-}
-function findFinalTextRange(lines) {
-    let end = -1;
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (isFinalAnswerLine(lines[index])) {
-            end = index;
-            break;
-        }
-    }
-    if (end < 0)
-        return null;
-    let start = end;
-    for (let index = end - 1; index >= 0; index -= 1) {
-        if (!isFinalAnswerLine(lines[index]))
-            break;
-        start = index;
-    }
-    return { start, end };
-}
-function buildChainItems(lines, finalTextRange, finalText, workspaceRoot, toolDetails) {
-    let toolIndex = 0;
-    let messageIndex = 0;
-    const items = [];
-    const toolDetailMatchCounts = new Map();
-    let messageBuffer = [];
-    const flushMessageBuffer = () => {
-        if (messageBuffer.length === 0)
-            return;
-        const text = messageBuffer.join('\n').trim();
-        if (text) {
-            items.push({
-                id: `message-${messageIndex}`,
-                title: summarizeMessageTitle(text),
-                text,
-                kind: 'message',
-                status: 'completed',
-            });
-            messageIndex += 1;
-        }
-        messageBuffer = [];
-    };
-    for (let index = 0; index < lines.length; index += 1) {
-        if (finalTextRange && index >= finalTextRange.start && index <= finalTextRange.end)
-            continue;
-        const line = lines[index];
-        if (finalText && isSameMessageText(line, finalText))
-            continue;
-        if (isSubagentToolLine(line))
-            continue;
-        if (isToolLikeLine(line)) {
-            flushMessageBuffer();
-            items.push(buildToolTodo(line, toolIndex, workspaceRoot, toolDetails, toolDetailMatchCounts));
-            toolIndex += 1;
-            continue;
-        }
-        if (isFinalAnswerLine(line)) {
-            messageBuffer.push(line);
-        }
-    }
-    flushMessageBuffer();
-    return items.slice(0, 40);
-}
-function isSameMessageText(left, right) {
-    return normalizeMessageText(left) === normalizeMessageText(right);
-}
-function normalizeMessageText(text) {
-    return text.trim().replace(/\s+/g, ' ');
-}
-function summarizeMessageTitle(text) {
-    const normalized = text.trim().replace(/\s+/g, ' ');
-    if (!normalized)
-        return 'AI message';
-    return normalized.length > 80 ? `${normalized.slice(0, 77)}...` : normalized;
-}
-function isToolLikeLine(line) {
-    return /^(Using|Tool:|Read|Write|Edit|MultiEdit|Bash|Search|Grep|Glob|Todo|Task|Web|Fetch|Claude Code initialized|Codex initialized|.+ running \(\d+s\))/i.test(line.trim());
-}
-function isFinalAnswerLine(line) {
-    return !isToolLikeLine(line) && !/^(\[.*\]|Agent runtime configuration:|Conversation history:)/.test(line.trim());
-}
-function isSubagentToolLine(line) {
-    return /^Tool:\s*Task\b/i.test(line.trim());
-}
-function buildToolTodo(line, index, workspaceRoot, toolDetails, toolDetailMatchCounts) {
-    const summary = summarizeToolLine(line, workspaceRoot);
-    const detailId = findToolDetailId(line, toolDetails, toolDetailMatchCounts);
-    return {
-        id: `tool-${index}`,
-        title: summary.title,
-        description: summary.description,
-        status: 'completed',
-        toolName: summary.toolName,
-        filePath: summary.filePath,
-        command: summary.command,
-        detailId,
-    };
-}
-function summarizeToolLine(line, workspaceRoot) {
-    const trimmed = line.trim();
-    const toolName = extractToolName(trimmed);
-    const inputDescription = extractQuotedField(trimmed, 'description');
-    const filePath = toWorkspaceRelativePath(extractQuotedField(trimmed, 'file_path') ?? extractQuotedField(trimmed, 'path'), workspaceRoot);
-    const command = extractQuotedField(trimmed, 'command') ?? extractCommand(trimmed, toolName);
-    const baseName = filePath?.split(/[\\/]/).filter(Boolean).at(-1);
-    if (toolName) {
-        if (filePath) {
-            return {
-                title: `${humanizeToolName(toolName)} ${baseName ?? filePath}`,
-                description: inputDescription ?? filePath,
-                toolName,
-                filePath,
-            };
-        }
-        if (command) {
-            return {
-                title: `${humanizeToolName(toolName)} command`,
-                description: inputDescription,
-                toolName,
-                command,
-            };
-        }
-        // Glob/Grep/Search: extract path + pattern + glob for header
-        const searchSummary = extractSearchParams(trimmed, toolName, workspaceRoot);
-        if (searchSummary) {
-            return { ...searchSummary, toolName };
-        }
-        const todoCount = extractTodoCount(trimmed);
-        if (todoCount !== undefined) {
-            return {
-                title: `Update ${todoCount} ${todoCount === 1 ? 'todo' : 'todos'}`,
-                toolName,
-            };
-        }
-        return {
-            title: humanizeToolName(toolName),
-            toolName,
-        };
-    }
-    return { title: trimmed };
-}
-function extractSearchParams(line, toolName, workspaceRoot) {
-    if (!/^(Glob|Grep|Search|SemanticSearch|WebSearch|WebFetch|Fetch)$/i.test(toolName))
-        return null;
-    const pattern = extractQuotedField(line, 'pattern') ?? extractQuotedField(line, 'query');
-    const glob = extractQuotedField(line, 'glob');
-    const searchPath = toWorkspaceRelativePath(extractQuotedField(line, 'path'), workspaceRoot);
-    const url = extractQuotedField(line, 'url');
-    const label = humanizeToolName(toolName);
-    // WebSearch/WebFetch/Fetch: show url or query
-    if (/^(WebSearch|WebFetch|Fetch)$/i.test(toolName)) {
-        if (url)
-            return { title: `${label} ${truncate(url, 60)}` };
-        if (pattern)
-            return { title: `${label} ${truncate(pattern, 60)}` };
-        return { title: label };
-    }
-    // Glob: "Find files **/*.ts in src/components"
-    if (/^Glob$/i.test(toolName)) {
-        const parts = [];
-        if (pattern)
-            parts.push(truncate(pattern, 50));
-        else if (glob)
-            parts.push(truncate(glob, 50));
-        const title = parts.length ? `${label} ${parts.join(' ')}` : label;
-        const descParts = [];
-        if (pattern && glob)
-            descParts.push(`glob: ${glob}`);
-        if (searchPath)
-            descParts.push(`in ${searchPath}`);
-        return { title, description: descParts.length ? descParts.join(', ') : undefined };
-    }
-    // Grep/Search/SemanticSearch: "Search pomodoro|timer in src/"
-    const parts = [];
-    if (pattern)
-        parts.push(truncate(pattern, 40));
-    const title = parts.length ? `${label} ${parts.join(' ')}` : label;
-    const descParts = [];
-    if (glob)
-        descParts.push(`glob: ${glob}`);
-    if (searchPath)
-        descParts.push(`in ${searchPath}`);
-    return { title, description: descParts.length ? descParts.join(', ') : undefined };
-}
-function truncate(str, max) {
-    return str.length > max ? `${str.slice(0, max - 3)}...` : str;
-}
-function extractToolName(line) {
-    return line.match(/^Tool:\s*([A-Za-z][\w-]*)\b/)?.[1]
-        ?? line.match(/^([A-Za-z][\w-]*)\s+running\s+\(\d+s\)/)?.[1]
-        ?? line.match(/^([A-Za-z][\w-]*):?\s+/)?.[1];
-}
-function humanizeToolName(toolName) {
-    const labels = {
-        Read: 'Read',
-        Write: 'Write',
-        Edit: 'Edit',
-        MultiEdit: 'Edit',
-        Bash: 'Run',
-        TodoWrite: 'Update todos',
-        Grep: 'Search',
-        Glob: 'Find files',
-        Search: 'Search',
-        SemanticSearch: 'Semantic search',
-        WebSearch: 'Web search',
-        WebFetch: 'Fetch',
-        Fetch: 'Fetch',
-        Task: 'Run subagent',
-    };
-    return labels[toolName] ?? toolName.replace(/([a-z])([A-Z])/g, '$1 $2');
-}
-function extractQuotedField(line, key) {
-    const quoted = line.match(new RegExp(`\\b${key}=([\"'])(.*?)\\1`))?.[2];
-    if (quoted)
-        return quoted;
-    const json = line.match(new RegExp(`"${key}"\\s*:\\s*"([^"]+)"`))?.[1];
-    return json;
-}
-function extractCommand(line, toolName) {
-    if (!toolName || !/^(Bash|Shell|Command)$/i.test(toolName))
-        return undefined;
-    const command = line.replace(/^Tool:\s*/i, '').replace(new RegExp(`^${toolName}:?\\s*`, 'i'), '').trim();
-    return command || undefined;
-}
-function extractTodoCount(line) {
-    const matches = line.match(/"content"\s*:/g);
-    return matches?.length;
-}
-function toWorkspaceRelativePath(path, workspaceRoot) {
-    if (!path)
-        return undefined;
-    if (!workspaceRoot || !path.startsWith(workspaceRoot))
-        return path;
-    return path.slice(workspaceRoot.length).replace(/^[/\\]/, '');
-}
-function findToolDetailId(line, toolDetails, matchCounts) {
-    if (!toolDetails)
-        return undefined;
-    const targetMatchIndex = matchCounts?.get(line) ?? 0;
-    let matchIndex = 0;
-    for (const [id, detail] of toolDetails) {
-        if (detail.raw !== line)
-            continue;
-        if (matchIndex === targetMatchIndex) {
-            matchCounts?.set(line, targetMatchIndex + 1);
-            return id;
-        }
-        matchIndex += 1;
-    }
-    return undefined;
-}
-function findToolDetailForResult(toolUseId, result, toolUseDetailIds, toolDetails, workspaceRoot) {
-    const detailId = toolUseId ? toolUseDetailIds.get(toolUseId) : undefined;
-    const byId = detailId ? toolDetails.get(detailId) : undefined;
-    if (byId)
-        return byId;
-    const resultFilePath = extractResultFilePath(result, workspaceRoot);
-    if (resultFilePath) {
-        const details = Array.from(toolDetails.values()).reverse();
-        for (const detail of details) {
-            if (detail.output !== undefined)
-                continue;
-            const inputFilePath = extractInputFilePath(detail.input, workspaceRoot);
-            if (inputFilePath === resultFilePath)
-                return detail;
-        }
-    }
-    if (isSubagentToolResult(result)) {
-        const detail = Array.from(toolDetails.values()).reverse().find((candidate) => {
-            return candidate.output === undefined && /^Tool:\s*Task\b/i.test(candidate.raw);
-        });
-        if (detail)
-            return detail;
-    }
-    return Array.from(toolDetails.values()).reverse().find((detail) => detail.output === undefined);
-}
-function isSubagentToolResult(result) {
-    if (!result || typeof result !== 'object' || Array.isArray(result))
-        return false;
-    const record = result;
-    return (typeof record.agentId === 'string'
-        || typeof record.agentType === 'string'
-        || (record.status === 'completed' && Array.isArray(record.content)));
-}
-function extractResultFilePath(result, workspaceRoot) {
-    if (!result || typeof result !== 'object')
-        return undefined;
-    const record = result;
-    const file = record.file;
-    if (file && typeof file === 'object') {
-        const filePath = file.filePath;
-        if (typeof filePath === 'string')
-            return toWorkspaceRelativePath(filePath, workspaceRoot);
-    }
-    const filePath = record.filePath;
-    if (typeof filePath === 'string')
-        return toWorkspaceRelativePath(filePath, workspaceRoot);
-    return undefined;
-}
-function extractInputFilePath(input, workspaceRoot) {
-    if (!input || typeof input !== 'object')
-        return undefined;
-    const record = input;
-    const filePath = record.file_path ?? record.path;
-    return typeof filePath === 'string' ? toWorkspaceRelativePath(filePath, workspaceRoot) : undefined;
-}
-function buildToolDetailId(id, line) {
-    const key = `${id}:${line}`;
-    let hash = 0;
-    for (let index = 0; index < key.length; index += 1) {
-        hash = ((hash << 5) - hash + key.charCodeAt(index)) | 0;
-    }
-    return `tool-${Math.abs(hash).toString(36)}`;
-}
-function questionRunKey(workspaceId, channelId, messageId, questionId) {
-    return `${workspaceId}:${channelId}:${messageId}:${questionId}`;
-}
-function parseAskUserQuestion(toolUseId, input) {
-    const record = input && typeof input === 'object' ? input : {};
-    const rawQuestions = Array.isArray(record.questions) ? record.questions : [];
-    const first = rawQuestions.find((item) => item && typeof item === 'object');
-    const question = typeof first?.question === 'string' && first.question.trim()
-        ? first.question.trim()
-        : '请选择一个选项：';
-    const options = Array.isArray(first?.options) ? first.options : [];
-    const choices = options
-        .map((option) => {
-        if (typeof option === 'string')
-            return option;
-        if (!option || typeof option !== 'object')
-            return '';
-        const value = option;
-        return typeof value.label === 'string' ? value.label : '';
-    })
-        .filter(Boolean);
-    return {
-        id: `ask-user-${toolUseId}`,
-        toolUseId,
-        question,
-        choices,
-    };
-}
-function questionFromAnsweredPart(parts, questionId) {
-    const part = parts?.find((item) => item.type === 'ask_user_question' && item.id === questionId);
-    if (!part || part.type !== 'ask_user_question')
-        return undefined;
-    return {
-        id: part.id,
-        toolUseId: part.toolUseId,
-        question: part.question,
-        choices: part.choices ?? [],
-        answer: part.answer,
-    };
-}
-function shouldWaitForUserAnswer(questions, summary, error, output) {
-    if (!questions.some((question) => !question.answer))
-        return false;
-    if (summary === 'Waiting for user answer')
-        return true;
-    const text = [error ?? '', ...output].join('\n');
-    return !text.trim() || isAskUserQuestionError(text);
-}
-function stripAskUserQuestionErrorLines(output) {
-    return output.filter((line) => !isAskUserQuestionError(line));
-}
-function isAskUserQuestionError(error) {
-    return /Answer questions\?/i.test(error);
-}
-function extractUsage(lines) {
-    const usage = {};
-    for (const line of lines) {
-        const lower = line.toLowerCase();
-        if (!lower.includes('token'))
-            continue;
-        const input = line.match(/\bin(?:put)?[=:\s]+([\d,]+)/i)?.[1];
-        const output = line.match(/\bout(?:put)?[=:\s]+([\d,]+)/i)?.[1];
-        const total = line.match(/\btokens?[=:\s]+([\d,]+)/i)?.[1];
-        if (input)
-            usage.inputTokens = Number(input.replace(/,/g, ''));
-        if (output)
-            usage.outputTokens = Number(output.replace(/,/g, ''));
-        if (total)
-            usage.totalTokens = Number(total.replace(/,/g, ''));
-    }
-    return usage;
-}
-function extractSubagentBlocks(lines, sessionId, toolDetails) {
-    const matchCounts = new Map();
-    return lines
-        .map((line, index) => {
-        const match = line.match(/^Tool:\s*Task\b\s*(.*)$/i);
-        if (!match)
-            return null;
-        const name = line.match(/\bdescription=(["'])(.*?)\1/i)?.[2] || `Subagent ${index + 1}`;
-        const prompt = line.match(/\bprompt=(["'])(.*?)\1/i)?.[2];
-        const detailId = findToolDetailId(line, toolDetails, matchCounts);
-        const detail = detailId ? toolDetails?.get(detailId) : undefined;
-        const output = stringifySubagentOutput(detail?.output);
-        return {
-            id: `subagent-${sessionId}-${index}`,
-            type: 'subagent',
-            name,
-            instructions: prompt,
-            output,
-        };
-    })
-        .filter((part) => Boolean(part));
-}
-function stringifySubagentOutput(output) {
-    if (output === undefined || output === null)
-        return undefined;
-    if (typeof output === 'string')
-        return output.trim() || undefined;
-    if (Array.isArray(output)) {
-        const text = output.flatMap((item) => {
-            if (typeof item === 'string')
-                return [item];
-            if (!item || typeof item !== 'object')
-                return [];
-            const record = item;
-            return typeof record.text === 'string' ? [record.text] : [];
-        }).join('\n').trim();
-        return text || undefined;
-    }
-    if (typeof output === 'object') {
-        const record = output;
-        if (typeof record.result === 'string' && record.result.trim())
-            return record.result.trim();
-        if (typeof record.summary === 'string' && record.summary.trim())
-            return record.summary.trim();
-        if (Array.isArray(record.content))
-            return stringifySubagentOutput(record.content);
-    }
-    return undefined;
-}
-function buildAgentPrompt(workspaceId, systemPrompt, userPrompt, history = [], runtimeConfig) {
-    const parts = [];
-    const trimmedSystemPrompt = systemPrompt?.trim();
-    if (trimmedSystemPrompt)
-        parts.push(trimmedSystemPrompt);
-    if (runtimeConfig) {
-        const configLines = [
-            'Agent runtime configuration:',
-            `- MCP servers configured for this agent: ${runtimeConfig.mcpServers.length ? runtimeConfig.mcpServers.join(', ') : 'none'}`,
-            `- Skills configured for this agent: ${runtimeConfig.skills.length ? runtimeConfig.skills.join(', ') : 'none'}`,
-            '- Runtime tools available through Claude Code: Read, Write, Edit, MultiEdit, Bash, Grep, Glob, Task, TodoWrite, WebFetch, WebSearch',
-            `- Agent Spaces channel tools configured for this channel: ${runtimeConfig.builtInTools?.length ? runtimeConfig.builtInTools.map((tool) => tool.name).join(', ') : 'none'}`,
-        ];
-        if (runtimeConfig.boundDirs?.length) {
-            configLines.push(`- Code directories (boundDirs): ${runtimeConfig.boundDirs.join(', ')}`);
-        }
-        configLines.push('- For Bash commands that create or modify files under the current working directory, use relative paths such as `mkdir -p css js` instead of absolute paths.');
-        if (runtimeConfig.builtInTools?.length) {
-            configLines.push(...formatBuiltInToolContext(runtimeConfig.builtInTools));
-        }
-        if (isIssueContextLookup(userPrompt)) {
-            configLines.push('Current issue lookup rule:', '- The user is asking for the current channel issue.', '- If Agent Spaces channel tools include ViewCurrentChannelIssue, call that function tool first and answer from the tool result.', '- Do not use Bash, Glob, Grep, or project files to infer the current channel issue.', '- If ViewCurrentChannelIssue is not configured but CreateCurrentChannelIssue is configured, say this channel is not bound to an issue yet.', '- If no Agent Spaces channel issue tool is configured, say the issue tool is unavailable.');
-        }
-        configLines.push('When asked what MCP servers, skills, runtime tools, or Agent Spaces channel tools you have, answer from this configuration only. Do not infer availability from provider-side function names or hidden runtime internals.');
-        parts.push(configLines.join('\n'));
-    }
-    if (history.length > 0) {
-        parts.push('Conversation history:');
-        for (const msg of history) {
-            const role = msg.senderId === 'user' ? 'User' : (msg.senderRole || 'Agent');
-            parts.push(`[${role}]: ${stripHtml(msg.content)}`);
-        }
-    }
-    parts.push(`User message:\n${userPrompt}`);
-    return prependWorkspacePrompt(workspaceId, parts.join('\n\n'));
-}
-function prependWorkspacePrompt(workspaceId, prompt) {
-    const workspacePrompt = readWorkspacePrompt(workspaceId).trim();
-    if (!workspacePrompt)
-        return prompt;
-    return `${workspacePrompt}\n\n${prompt}`;
-}
-function isIssueContextLookup(userPrompt) {
-    const text = stripHtml(userPrompt).toLowerCase();
-    return /当前频道.*议题|议题内容|current channel.*issue|issue.*current channel/.test(text);
-}
-function buildBuiltInTools(functionTools, channel, issue) {
-    if (!functionTools.length || !channel)
-        return [];
-    const issueTitle = issue?.title ?? channel.name;
-    return functionTools.map((functionTool) => ({
-        name: functionTool.name,
-        description: functionTool.description,
-        channelId: channel.id,
-        issueId: channel.issueId,
-        issueTitle,
-    }));
-}
-function formatBuiltInToolContext(tools) {
-    const firstTool = tools[0];
-    const firstIssueTool = tools.find((tool) => tool.issueId);
-    const lines = [
-        'Built-in issue tool rules:',
-        '- These are real function-call tools exposed through the agent-spaces MCP server.',
-        '- Tool calls must use the current channel id.',
-    ];
-    if (firstTool?.channelId)
-        lines.push(`- Current channel id: ${firstTool.channelId}`);
-    if (firstIssueTool?.issueId) {
-        lines.push(`- Current channel issue id: ${firstIssueTool.issueId}`);
-        lines.push(`- Current channel issue title: ${firstIssueTool.issueTitle || 'Untitled issue'}`);
-    }
-    else {
-        lines.push('- Current channel is not bound to an issue yet. Use CreateCurrentChannelIssue before viewing or commenting.');
-    }
-    for (const tool of tools) {
-        lines.push(`- ${tool.name}: ${tool.description}`);
-    }
-    return lines;
-}
-function stripHtml(content) {
-    return content
-        .replace(/<span[^>]*data-type=["']mention["'][^>]*data-label=["']([^"']+)["'][^>]*><\/span>/gi, '@$1')
-        .replace(/<[^>]+>/g, ' ')
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&amp;/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-function extractMentionIds(content) {
-    const ids = new Set();
-    const mentionPattern = /<span[^>]*data-type=["']mention["'][^>]*>/gi;
-    for (const match of content.matchAll(mentionPattern)) {
-        const id = match[0].match(/\sdata-id=["']([^"']+)["']/i)?.[1];
-        if (id)
-            ids.add(decodeHtml(id));
-    }
-    return [...ids];
-}
-function decodeHtml(value) {
-    return value
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&amp;/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>');
-}
+registerHandler('channel.answer_question', handleAnswerQuestion);
 // Register agent handlers
 registerHandler('agent.start', (_ws, workspaceId, data) => {
     const { role, issueId } = data;
-    const ctx = makeContext(workspaceId);
     if (role === 'planner' && issueId) {
-        runPlanner(workspaceId, issueId, ctx).catch((err) => {
-            console.error(`[ws] planner error:`, err);
-        });
+        console.warn(`[ws] planner start ignored; issue automation is workflow-driven workspaceId=${workspaceId} issueId=${issueId}`);
     }
 });
 registerHandler('agent.stop', (_ws, workspaceId, data) => {
@@ -1281,5 +89,6 @@ registerHandler('agent.stop', (_ws, workspaceId, data) => {
         to: 'completed',
     });
 });
-export { broadcastToWorkspace };
+export { broadcastToWorkspace } from './connection-manager.js';
+export { stopChannelRuns, hasActiveChannelRuns, markInactiveChannelRunsStopped } from './agent-runner.js';
 //# sourceMappingURL=handler.js.map