@agent-spaces/server 0.3.67 → 0.4.0

package/dist/ws/agent-runner.js

@@ -4,7 +4,7 @@ import { broadcastToWorkspace } from './connection-manager.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, createCommandFunctionTools, createDatabaseFunctionTools, createKanbanFunctionTools } from '../services/builtin-tools/index.js';
+import { createIssueFunctionTools, createCommandFunctionTools, createDatabaseFunctionTools, createKanbanFunctionTools, createWorkflowExecutionFunctionTools } from '../services/builtin-tools/index.js';
 import { startScheduler } from '../agents/scheduler-agent.js';
 import * as agentService from '../services/agent.js';
 import * as wsService from '../services/workspace.js';
@@ -57,17 +57,17 @@ export function stopChannelRuns(workspaceId, channelId) {
             agentId: run.agentId,
             error: 'Stopped by user',
         });
+        const existing = listMessages(workspaceId, channelId).find((m) => m.id === run.messageId);
+        const preservedParts = (existing?.parts ?? []).map((part) => 'status' in part && part.status === 'streaming' ? { ...part, status: 'completed' } : part);
+        const stoppedPart = {
+            id: `error-stopped-${run.agentId}`,
+            type: 'error',
+            title: 'Stopped by user',
+            message: 'The agent run was 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',
-                },
-            ],
+            parts: [...preservedParts, stoppedPart],
         });
         if (message)
             broadcastToWorkspace(workspaceId, 'channel.message.updated', message);
@@ -170,6 +170,7 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
         ...createCommandFunctionTools(workspaceId, preset.tools),
         ...createDatabaseFunctionTools(workspaceId, preset.tools),
         ...createKanbanFunctionTools(workspaceId, preset.tools),
+        ...createWorkflowExecutionFunctionTools(preset.tools),
     ];
     const workingDir = agentService.resolveWorkingDir(workspaceId, preset);
     const startTime = Date.now();
@@ -223,7 +224,10 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
     const liveReasoning = [];
     let agentPrompt = '';
     let runtimeUserPrompt = prompt;
-    let runtimeSessionId = options.resumeSessionId ?? existingMessage?.metadata?.runtimeSessionId;
+    const contextLength = normalizeContextLength(options.contextLength);
+    let runtimeSessionId = contextLength === 0
+        ? undefined
+        : options.resumeSessionId ?? existingMessage?.metadata?.runtimeSessionId;
     const persistentContext = buildPersistentAgentContextDetails({
         workspaceId,
         workingDir: workspace?.boundDirs?.[0] || workingDir,
@@ -247,13 +251,15 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
             runtime,
         };
         trackChannelRun(workspaceId, channelId, activeRun);
-        const history = filterPromptHistory(listMessages(workspaceId, channelId, { limit: 20 }), {
-            excludeMessageIds: [
-                ...(!existingMessage ? [pending.id] : []),
-                ...(options.excludeHistoryMessageIds ?? []),
-            ],
-            excludeReplyIds: options.excludeHistoryReplyIds,
-        });
+        const history = contextLength === 0
+            ? []
+            : filterPromptHistory(listMessages(workspaceId, channelId, { limit: contextLength }), {
+                excludeMessageIds: [
+                    ...(!existingMessage ? [pending.id] : []),
+                    ...(options.excludeHistoryMessageIds ?? []),
+                ],
+                excludeReplyIds: options.excludeHistoryReplyIds,
+            });
         const isRuntimeSessionResume = Boolean(options.resumeSessionId && (preset.runtimeKind === 'claude-code' || preset.runtimeKind === 'codex'));
         runtimeUserPrompt = expandAgentSlashCommandPrompt(prompt, configDir);
         agentPrompt = isRuntimeSessionResume
@@ -851,4 +857,9 @@ function estimateTextTokens(text) {
     const words = nonCjkText.match(/[A-Za-z0-9_]+|[^\sA-Za-z0-9_]/g)?.length ?? 0;
     return Math.max(1, Math.ceil(cjkChars + words * 0.75));
 }
+function normalizeContextLength(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return 20;
+    return Math.min(20, Math.max(0, Math.trunc(value)));
+}
 //# sourceMappingURL=agent-runner.js.map

package/dist/ws/chat-handler.js

@@ -0,0 +1,89 @@
+import { broadcastToWorkspace } from './connection-manager.js';
+import { registerHandler } from './handler.js';
+import * as chatService from '../services/chat.js';
+import { LangChainRuntime } from '../adapters/langchain-runtime.js';
+const activeRuns = new Map();
+export function registerChatHandlers() {
+    // chat.message: { agentId, content }
+    registerHandler('chat.message', (_ws, workspaceId, data) => {
+        const { agentId, content } = data;
+        if (!agentId || !content)
+            return;
+        const agent = chatService.findAgent(agentId);
+        if (!agent) {
+            broadcastToWorkspace(workspaceId, 'chat.agent.error', { agentId, error: 'Agent not found' });
+            return;
+        }
+        // Save user message
+        const userMsg = chatService.saveMessage({ agentId, role: 'user', content });
+        broadcastToWorkspace(workspaceId, 'chat.message.saved', userMsg);
+        // Build runtime config (fixed langchain)
+        const config = {
+            kind: 'langchain',
+            provider: agent.provider,
+            model: agent.model,
+            apiKey: agent.apiKey,
+            baseURL: agent.baseURL,
+        };
+        const runtime = new LangChainRuntime(config);
+        activeRuns.set(agentId, runtime);
+        // Build conversation history from recent messages
+        const recent = chatService.getRecentMessages(agentId, 20);
+        const historyPrompt = recent
+            .slice(0, -1) // exclude the just-saved user message (already in recent)
+            .map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
+            .join('\n\n');
+        const prompt = historyPrompt ? `${historyPrompt}\n\nUser: ${content}\nAssistant:` : content;
+        // Execute with streaming events
+        runtime.execute(prompt, process.cwd(), {
+            systemPrompt: agent.systemPrompt,
+            onEvent: (event) => {
+                switch (event.type) {
+                    case 'output':
+                        broadcastToWorkspace(workspaceId, 'chat.agent.output', { agentId, chunk: event.line });
+                        break;
+                    case 'reasoning':
+                        broadcastToWorkspace(workspaceId, 'chat.agent.thinking', { agentId, chunk: event.text });
+                        break;
+                    case 'tool_use':
+                        broadcastToWorkspace(workspaceId, 'chat.agent.tool_use', { agentId, name: event.name, input: event.input });
+                        break;
+                    case 'tool_result':
+                        broadcastToWorkspace(workspaceId, 'chat.agent.tool_result', { agentId, name: event.toolUseId, result: event.result });
+                        break;
+                }
+            },
+        })
+            .then((result) => {
+            const agentContent = result.output.filter((line) => !line.startsWith('Tool:')).join('\n') || result.summary;
+            const agentMsg = chatService.saveMessage({
+                agentId,
+                role: 'agent',
+                content: agentContent,
+                usage: result.usage,
+            });
+            broadcastToWorkspace(workspaceId, 'chat.agent.completed', { agentId, message: agentMsg });
+        })
+            .catch((err) => {
+            broadcastToWorkspace(workspaceId, 'chat.agent.error', {
+                agentId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        })
+            .finally(() => {
+            activeRuns.delete(agentId);
+        });
+    });
+    // chat.stop: { agentId }
+    registerHandler('chat.stop', (_ws, _workspaceId, data) => {
+        const { agentId } = data;
+        if (!agentId)
+            return;
+        const runtime = activeRuns.get(agentId);
+        if (runtime) {
+            runtime.stop();
+            activeRuns.delete(agentId);
+        }
+    });
+}
+//# sourceMappingURL=chat-handler.js.map

package/dist/ws/connection-manager.js

@@ -1,12 +1,59 @@
+import { randomUUID } from 'node:crypto';
 import { publishWorkspaceEvent } from '../services/notification-hub/index.js';
 const connections = new Map();
+const clientIdIndex = new Map();
+const clientConnectedCallbacks = [];
+const clientDisconnectedCallbacks = [];
+let interactionResponseHandler = null;
 export function addConnection(ws, workspaceId) {
-    connections.set(ws, { ws, workspaceId });
-    ws.on('close', () => connections.delete(ws));
+    const clientId = randomUUID();
+    const conn = { ws, workspaceId, clientId };
+    connections.set(ws, conn);
+    clientIdIndex.set(clientId, conn);
+    ws.on('close', () => {
+        connections.delete(ws);
+        clientIdIndex.delete(clientId);
+        for (const cb of clientDisconnectedCallbacks)
+            cb(clientId);
+    });
+    for (const cb of clientConnectedCallbacks)
+        cb(clientId, ws);
+    return clientId;
 }
 export function removeConnection(ws) {
+    const conn = connections.get(ws);
+    if (conn) {
+        clientIdIndex.delete(conn.clientId);
+        for (const cb of clientDisconnectedCallbacks)
+            cb(conn.clientId);
+    }
     connections.delete(ws);
 }
+export function getClientId(ws) {
+    return connections.get(ws)?.clientId;
+}
+export function getConnectionByClientId(clientId) {
+    return clientIdIndex.get(clientId);
+}
+export function sendToClient(clientId, data) {
+    const conn = clientIdIndex.get(clientId);
+    if (!conn || conn.ws.readyState !== 1)
+        return false;
+    conn.ws.send(JSON.stringify(data));
+    return true;
+}
+export function onClientConnected(cb) {
+    clientConnectedCallbacks.push(cb);
+}
+export function onClientDisconnected(cb) {
+    clientDisconnectedCallbacks.push(cb);
+}
+export function setInteractionResponseHandler(handler) {
+    interactionResponseHandler = handler;
+}
+export function handleInteractionResponse(response, clientId) {
+    interactionResponseHandler?.(response, clientId);
+}
 export function getConnectionsByWorkspace(workspaceId) {
     const result = [];
     for (const [ws, conn] of connections) {

package/dist/ws/execution-channels.js

@@ -0,0 +1,88 @@
+// WS execution channel handlers — register workflow execution control events
+import { getClientId } from './connection-manager.js';
+import { registerHandler } from './handler.js';
+export function registerExecutionChannels(executionManager) {
+    registerHandler('workflow:execute', async (ws, _workspaceId, data) => {
+        const clientId = getClientId(ws);
+        if (!clientId)
+            return;
+        try {
+            const result = await executionManager.execute(data, clientId, (channel, payload) => {
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify({ event: channel, data: payload }));
+                }
+            });
+            ws.send(JSON.stringify({
+                event: 'workflow:execute:result',
+                data: result,
+            }));
+        }
+        catch (err) {
+            ws.send(JSON.stringify({
+                event: 'workflow:execute:error',
+                data: { error: err.message || String(err) },
+            }));
+        }
+    });
+    registerHandler('workflow:pause', (ws, _workspaceId, data) => {
+        const { executionId } = data;
+        if (!executionId)
+            return;
+        try {
+            const result = executionManager.pause(executionId);
+            ws.send(JSON.stringify({ event: 'workflow:pause:result', data: result }));
+        }
+        catch (err) {
+            ws.send(JSON.stringify({ event: 'workflow:pause:error', data: { error: err.message } }));
+        }
+    });
+    registerHandler('workflow:resume', async (ws, _workspaceId, data) => {
+        const { executionId } = data;
+        if (!executionId)
+            return;
+        try {
+            const result = await executionManager.resume(executionId);
+            ws.send(JSON.stringify({ event: 'workflow:resume:result', data: result }));
+        }
+        catch (err) {
+            ws.send(JSON.stringify({ event: 'workflow:resume:error', data: { error: err.message } }));
+        }
+    });
+    registerHandler('workflow:stop', (ws, _workspaceId, data) => {
+        const { executionId } = data;
+        if (!executionId)
+            return;
+        try {
+            const result = executionManager.stop(executionId);
+            ws.send(JSON.stringify({ event: 'workflow:stop:result', data: result }));
+        }
+        catch (err) {
+            ws.send(JSON.stringify({ event: 'workflow:stop:error', data: { error: err.message } }));
+        }
+    });
+    registerHandler('workflow:debug-node', async (ws, _workspaceId, data) => {
+        const clientId = getClientId(ws);
+        if (!clientId)
+            return;
+        try {
+            const result = await executionManager.debugNode(data, clientId);
+            ws.send(JSON.stringify({ event: 'workflow:debug-node:result', data: result }));
+        }
+        catch (err) {
+            ws.send(JSON.stringify({ event: 'workflow:debug-node:error', data: { error: err.message } }));
+        }
+    });
+    registerHandler('workflow:get-execution-recovery', (ws, _workspaceId, data) => {
+        const clientId = getClientId(ws);
+        if (!clientId)
+            return;
+        try {
+            const result = executionManager.getExecutionRecovery(data, clientId);
+            ws.send(JSON.stringify({ event: 'workflow:get-execution-recovery:result', data: result }));
+        }
+        catch (err) {
+            ws.send(JSON.stringify({ event: 'workflow:get-execution-recovery:error', data: { error: err.message } }));
+        }
+    });
+}
+//# sourceMappingURL=execution-channels.js.map

package/dist/ws/handler.js

@@ -1,7 +1,9 @@
-import { addConnection, broadcastToWorkspace } from './connection-manager.js';
+import { addConnection, broadcastToWorkspace, getClientId, handleInteractionResponse } from './connection-manager.js';
 import { handleTerminalEvent, sendTerminalSessions } from './terminal-handler.js';
+import { registerChatHandlers } from './chat-handler.js';
 import { appendMessageReply, createMessage } from '../services/message.js';
 import { getChannel } from '../services/channel.js';
+import { scheduleChannelTitleGeneration } from '../services/generated-title.js';
 import * as agentService from '../services/agent.js';
 import { runMentionedAgent, stopChannelRuns, handleAnswerQuestion, ensureScheduler, makeContext } from './agent-runner.js';
 import { stripHtml, extractMentionIds } from './html-utils.js';
@@ -10,7 +12,7 @@ export function registerHandler(event, handler) {
     handlers.set(event, handler);
 }
 export function handleConnection(ws, workspaceId) {
-    addConnection(ws, workspaceId);
+    const clientId = addConnection(ws, workspaceId);
     const ctx = makeContext(workspaceId);
     ensureScheduler(workspaceId, ctx);
     ws.send(JSON.stringify({
@@ -52,10 +54,12 @@ for (const evt of terminalEvents) {
 }
 // Register channel handlers
 registerHandler('channel.message', (_ws, workspaceId, data) => {
-    const { channelId, content, type, mentions, attachments, replyToMessageId } = data;
+    const { channelId, content, type, mentions, attachments, replyToMessageId, contextLength } = data;
+    const normalizedContextLength = normalizeContextLength(contextLength);
     if (!channelId || (!content && !attachments?.length))
         return;
-    if (!getChannel(workspaceId, channelId))
+    const channel = getChannel(workspaceId, channelId);
+    if (!channel)
         return;
     if (replyToMessageId) {
         const updated = appendMessageReply(workspaceId, channelId, replyToMessageId, {
@@ -72,8 +76,9 @@ registerHandler('channel.message', (_ws, workspaceId, data) => {
             void runMentionedAgent(workspaceId, channelId, agentId, stripHtml(content), {
                 messageId: updated.id,
                 appendUserMessage: stripHtml(content),
-                resumeSessionId: updated.metadata?.runtimeSessionId,
+                resumeSessionId: normalizedContextLength > 0 ? updated.metadata?.runtimeSessionId : undefined,
                 excludeHistoryReplyIds: latestReplyId ? [latestReplyId] : undefined,
+                contextLength: normalizedContextLength,
             });
         }
         return;
@@ -85,13 +90,27 @@ registerHandler('channel.message', (_ws, workspaceId, data) => {
         attachments,
     });
     broadcastToWorkspace(workspaceId, 'channel.message', message);
+    if (!channel.name.trim()) {
+        scheduleChannelTitleGeneration({
+            workspaceId,
+            channelId,
+            requirement: stripHtml(content),
+            broadcast: (event, payload) => broadcastToWorkspace(workspaceId, event, payload),
+        });
+    }
     const agentIds = [...new Set([...(mentions || []), ...extractMentionIds(content)].filter(Boolean))];
     for (const agentId of agentIds) {
         void runMentionedAgent(workspaceId, channelId, agentId, stripHtml(content), {
             excludeHistoryMessageIds: [message.id],
+            contextLength: normalizedContextLength,
         });
     }
 });
+function normalizeContextLength(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return 20;
+    return Math.min(20, Math.max(0, Math.trunc(value)));
+}
 registerHandler('channel.stop', (_ws, workspaceId, data) => {
     const { channelId } = data;
     if (!channelId)
@@ -115,6 +134,14 @@ registerHandler('agent.stop', (_ws, workspaceId, data) => {
         to: 'completed',
     });
 });
+// Workflow interaction response handler
+registerHandler('workflow:interaction', (ws, _workspaceId, data) => {
+    const clientId = getClientId(ws);
+    if (clientId)
+        handleInteractionResponse(data, clientId);
+});
+// Register chat handlers
+registerChatHandlers();
 export { broadcastToWorkspace } from './connection-manager.js';
 export { stopChannelRuns, hasActiveChannelRuns, markInactiveChannelRunsStopped } from './agent-runner.js';
 //# sourceMappingURL=handler.js.map

package/dist/ws/message-parts.js

@@ -1,5 +1,6 @@
 export function buildAgentMessageParts(input) {
-    const lines = normalizeOutputLines(input.output);
+    const extractedReasoning = extractInlineReasoning(normalizeOutputLines(input.output));
+    const lines = extractedReasoning.lines;
     const finalTextRange = findFinalTextRange(lines);
     const finalText = finalTextRange
         ? collapseRepeatedTextBlock(lines.slice(finalTextRange.start, finalTextRange.end + 1)).join('\n').trim()
@@ -7,7 +8,10 @@ export function buildAgentMessageParts(input) {
     const usage = input.usage ?? extractUsage(lines);
     const parts = [];
     const chainItems = buildChainItems(lines, finalTextRange, finalText, input.workspaceRoot, input.toolDetails, input.persistentContext, input.askUserQuestions);
-    const reasoningText = normalizeReasoningText(input.reasoning);
+    const reasoningText = normalizeReasoningText([
+        ...(input.reasoning ?? []),
+        ...extractedReasoning.reasoning.map((text) => ({ text })),
+    ]);
     if (reasoningText) {
         parts.push({
             id: `reasoning-${input.sessionId}`,
@@ -84,16 +88,43 @@ export function normalizeOutputLines(output) {
         .map((line) => line.trimEnd())
         .filter((line) => line.trim());
     const seenInitLines = new Set();
-    return lines.filter((line) => {
-        if (isIgnorableToolProgressLine(line))
-            return false;
-        if (!/^Claude Code initialized\b/i.test(line))
-            return true;
-        if (seenInitLines.has(line))
-            return false;
-        seenInitLines.add(line);
-        return true;
-    });
+    let inAgentSpacesPromptEcho = false;
+    let skipNextUserMessageEchoLine = false;
+    const normalizedLines = [];
+    for (const line of lines) {
+        const cleaned = stripRuntimeNoticePrefix(stripRuntimeLogPrefix(line)).trim();
+        if (!cleaned)
+            continue;
+        if (skipNextUserMessageEchoLine) {
+            skipNextUserMessageEchoLine = false;
+            continue;
+        }
+        if (isAgentSpacesPromptEchoStart(cleaned) || /^Agent runtime configuration:\s*$/i.test(cleaned)) {
+            inAgentSpacesPromptEcho = true;
+            continue;
+        }
+        if (inAgentSpacesPromptEcho) {
+            if (/\bUser message:\s*$/i.test(cleaned)) {
+                inAgentSpacesPromptEcho = false;
+                skipNextUserMessageEchoLine = true;
+            }
+            else if (/\bUser message:/i.test(cleaned)) {
+                inAgentSpacesPromptEcho = false;
+            }
+            continue;
+        }
+        if (isIgnorablePromptEchoLine(cleaned))
+            continue;
+        if (isIgnorableToolProgressLine(cleaned))
+            continue;
+        if (/^Claude Code initialized\b/i.test(cleaned)) {
+            if (seenInitLines.has(cleaned))
+                continue;
+            seenInitLines.add(cleaned);
+        }
+        normalizedLines.push(cleaned);
+    }
+    return normalizedLines;
 }
 export function mergeRuntimeOutput(liveOutput, resultOutput) {
     if (liveOutput.length === 0)
@@ -192,6 +223,52 @@ function normalizeReasoningText(reasoning) {
         .map((item) => item.text.trim())
         .filter(Boolean)).join('\n\n').trim();
 }
+function extractInlineReasoning(lines) {
+    const reasoning = [];
+    const outputLines = [];
+    let buffer = [];
+    let inThinkBlock = false;
+    const flushReasoning = () => {
+        const text = buffer.join('\n').trim();
+        if (text)
+            reasoning.push(text);
+        buffer = [];
+    };
+    for (const line of lines) {
+        let rest = line;
+        let visible = '';
+        while (rest) {
+            if (inThinkBlock) {
+                const closeIndex = rest.search(/<\/think>/i);
+                if (closeIndex < 0) {
+                    buffer.push(rest);
+                    rest = '';
+                    continue;
+                }
+                buffer.push(rest.slice(0, closeIndex));
+                flushReasoning();
+                rest = rest.slice(closeIndex).replace(/^<\/think>/i, '');
+                inThinkBlock = false;
+                continue;
+            }
+            const openIndex = rest.search(/<think>/i);
+            if (openIndex < 0) {
+                visible += rest;
+                rest = '';
+                continue;
+            }
+            visible += rest.slice(0, openIndex);
+            rest = rest.slice(openIndex).replace(/^<think>/i, '');
+            inThinkBlock = true;
+        }
+        const cleaned = visible.trimEnd();
+        if (cleaned.trim())
+            outputLines.push(cleaned);
+    }
+    if (inThinkBlock)
+        flushReasoning();
+    return { lines: outputLines, reasoning };
+}
 function hasTokenUsage(usage) {
     return Boolean(usage.totalTokens || usage.inputTokens || usage.outputTokens || usage.cachedInputTokens || usage.reasoningTokens);
 }
@@ -509,6 +586,47 @@ function isIgnorableToolProgressLine(line) {
         || (isSubagentProgress && /^(Reading|Searching)\s+\S.+$/i.test(trimmed))
         || /^(Read|Search|Grep|Glob|SemanticSearch|WebSearch)\s+running\s+\(\d+s\)$/i.test(trimmed);
 }
+function stripRuntimeNoticePrefix(line) {
+    let next = line.trim();
+    while (next.startsWith('[')) {
+        const closeIndex = next.indexOf(']');
+        if (closeIndex < 0)
+            break;
+        const label = next.slice(1, closeIndex);
+        if (!isStrippableRuntimeNoticeLabel(label))
+            break;
+        next = next.slice(closeIndex + 1).trimStart();
+    }
+    return next;
+}
+function stripRuntimeLogPrefix(line) {
+    return line.replace(/^\[[a-z0-9_-]+\]\s+(?:stdout|stderr)\s*\|\s*/i, '');
+}
+function isStrippableRuntimeNoticeLabel(label) {
+    return /^Tool loop warning:/i.test(label);
+}
+function isAgentSpacesPromptEchoStart(line) {
+    return /^-?\s*Agent Spaces channel tools configured for this channel:/i.test(line);
+}
+function isIgnorablePromptEchoLine(line) {
+    return /^-?\s*Code directories \(boundDirs\):/i.test(line)
+        || /^-?\s*For Bash commands that create or modify files under the current working\b/i.test(line)
+        || /^(directory,|paths\.)$/i.test(line)
+        || /^When asked what MCP servers, skills, runtime tools, or Agent Spaces channel tools you have,/i.test(line)
+        || /^When asked what MCP servers, skills, runtime tools, or Agent Spaces channel\b/i.test(line)
+        || /^tools you have, answer from this configuration only\./i.test(line)
+        || /^Important distinction: MCP servers configured for this agent are only the names in /i.test(line)
+        || /^Important distinction: MCP servers configured for this agent are only the names\b/i.test(line)
+        || /^in "MCP servers configured for this agent"\./i.test(line)
+        || /^are$/i.test(line)
+        || /^built-in runtime tools and must not be listed as agent-configured MCP servers\./i.test(line)
+        || /^Do not infer availability from provider-side function names,/i.test(line)
+        || /^Do not infer availability from provider-side function names, hidden runtime\b/i.test(line)
+        || /^internals, previous sessions, or filesystem settings\./i.test(line)
+        || /^-\s+(Current workspace id|MCP servers configured for this agent|Skills configured for this agent|Runtime tools available through Hermes):/i.test(line)
+        || /^skills$/i.test(line)
+        || /^User message:/i.test(line);
+}
 function stripSubagentProgressPrefix(line) {
     return line.replace(/^\[[^\]]+\]\s+subagent progress\s+\|\s*/i, '');
 }

package/dist/ws/terminal-handler.js

@@ -1,7 +1,15 @@
 import * as ptyService from '../services/pty.js';
 import { broadcastToWorkspace } from './connection-manager.js';
+const DEBUG_TERMINAL_DUP = '[DEBUG-terminal-dup]';
 export function sendTerminalSessions(ws, workspaceId) {
     const existingSessions = ptyService.getSessionsByWorkspace(workspaceId);
+    console.log(DEBUG_TERMINAL_DUP, 'server sendTerminalSessions', {
+        workspaceId,
+        sessions: existingSessions.map(s => ({
+            sessionId: s.id,
+            bufferLength: s.buffer.join('').length,
+        })),
+    });
     ws.send(JSON.stringify({
         event: 'terminal.sessions',
         workspaceId,
@@ -20,13 +28,31 @@ export function handleTerminalEvent(ws, workspaceId, event, data) {
         case 'terminal.create': {
             const payload = data;
             const cwd = payload.cwd || process.env.HOME || process.env.USERPROFILE || (process.platform === 'win32' ? process.env.SYSTEMROOT || 'C:\\' : '/tmp');
+            console.log(DEBUG_TERMINAL_DUP, 'server terminal.create received', {
+                workspaceId,
+                sessionId: payload.sessionId,
+                shell: payload.shell,
+                cwd,
+            });
             try {
                 const sessionId = ptyService.createSession(workspaceId, cwd, (id, output) => {
+                    console.log(DEBUG_TERMINAL_DUP, 'server terminal.output broadcast', {
+                        workspaceId,
+                        sessionId: id,
+                        outputLength: output.length,
+                        preview: output.slice(0, 80),
+                    });
                     broadcastToWorkspace(workspaceId, 'terminal.output', { sessionId: id, data: output });
                 }, (id, exitCode) => {
                     broadcastToWorkspace(workspaceId, 'terminal.closed', { sessionId: id, exitCode });
                 }, payload.shell, undefined, payload.sessionId);
                 const session = ptyService.getSession(sessionId);
+                console.log(DEBUG_TERMINAL_DUP, 'server terminal.created broadcast', {
+                    workspaceId,
+                    sessionId,
+                    cwd,
+                    shell: session?.shell ?? payload.shell,
+                });
                 broadcastToWorkspace(workspaceId, 'terminal.created', { sessionId, cwd, shell: session?.shell ?? payload.shell });
             }
             catch (err) {