feat(coordinator): 添加团队节点默认最大工具迭代次数配置

添加 DEFAULT_TEAM_NODE_MAX_TOOL_ITERATIONS 配置项以控制团队节点的最大工具迭代次数，
并修改 LocalAgentRunner 中的逻辑来使用此默认值当 envelope 中未指定时。

fix(runtime): 修复团队节点运行成功判断逻辑

更新运行成功判断条件，将 finish_reason 为 "max_tool_iterations_finalized" 的情况
视为运行失败，并添加对原始工具调用输出的检测，避免将其误判为成功完成。

feat(mcp): 添加团队工作流MCP工具类别支持

增加新的本地MCP工具类别 "team_workflow" 及其对应的工具创建功能，
为团队工作流提供本地工具支持。

refactor(engine): 调整AgentLoop最大工具迭代次数设置

将 AgentProfile 中的默认 max_tool_iterations 从 30 增加到 100，
同时移除 TaskExecutionPlanner 构造函数中的重复参数传递。

perf(mcp): 优化MCP连接管理避免重复连接

添加 mcp_connected 标志来跟踪MCP连接状态，确保 connect_all 只执行一次，
提高性能并避免不必要的重复连接。

refactor(skills): 移除技能团队模板相关功能

移除与技能团队模板相关的代码，包括解析、存储和处理逻辑，
简化技能记录结构和加载流程。

feat(process): 增强会话过程投影器功能

添加技能激活快照事件处理，改进团队运行完成消息显示，
并增强技能激活事件的时间戳记录功能。

refactor(tasks): 简化任务尝试编排器团队执行逻辑

移除团队执行相关代码，将所有任务统一按单步执行处理，
简化任务编排器的复杂度并提升执行效率。

fix(evidence): 修复节点证据评估中需求验证逻辑

更新节点证据评估逻辑，跳过自然语言证据需求的确定性验证，
只执行机器可读的需求验证，避免因自然语言需求导致的节点失败。

app-instance/frontend/components/chat-workbench/MessageList.tsx

@@ -4,10 +4,9 @@ import React from 'react';
 import Link from 'next/link';
 import { Bot, CheckCircle2, ChevronRight, Loader2, Paperclip, RefreshCcw, ThumbsUp, User, XCircle } from 'lucide-react';
 
-import type { ChatMessage, ProcessArtifact, ProcessEvent, ProcessRun } from '@/types';
+import type { ChatMessage } from '@/types';
 import { getAccessToken, getFileUrl } from '@/lib/api';
 import { getTaskCardMessageIndexes, hasVisibleChatContent, normalizedMessageText, shouldDisplayChatMessage } from '@/lib/chat-messages';
-import { AgentTeamBlock } from '@/components/chat-workbench/AgentTeamBlock';
 import { MarkdownContent } from '@/components/chat-workbench/MarkdownContent';
 import { ScrollArea } from '@/components/ui/scroll-area';
 import {
@@ -268,14 +267,6 @@ function MessageBubble({
   );
 }
 
-type AgentTeamGroup = {
-  rootRun: ProcessRun;
-  memberRuns: ProcessRun[];
-  startedAt: string;
-};
-
-const TERMINAL_RUN_STATUSES = new Set<ProcessRun['status']>(['done', 'error', 'cancelled']);
-
 function shouldHideSystemAgentMessage(message: ChatMessage): boolean {
   if (message.role !== 'assistant' || typeof message.content !== 'string') {
     return false;
@@ -299,72 +290,11 @@ function shouldHideMessage(message: ChatMessage): boolean {
   return !shouldDisplayChatMessage(message);
 }
 
-function parseTimelineTime(value?: string | null): number | null {
-  if (!value) return null;
-  const parsed = new Date(value).getTime();
-  return Number.isFinite(parsed) ? parsed : null;
-}
-
-function buildAgentTeamGroups(processRuns: ProcessRun[]): AgentTeamGroup[] {
-  const runMap = new Map(processRuns.map((run) => [run.run_id, run]));
-  const groups = new Map<string, AgentTeamGroup>();
-
-  for (const run of processRuns) {
-    if (run.actor_type !== 'agent') {
-      continue;
-    }
-
-    let root = run;
-    const seen = new Set<string>([run.run_id]);
-    let parentId = run.parent_run_id ?? null;
-    while (parentId) {
-      const parent = runMap.get(parentId);
-      if (!parent || seen.has(parent.run_id)) {
-        break;
-      }
-      root = parent;
-      seen.add(parent.run_id);
-      parentId = parent.parent_run_id ?? null;
-    }
-
-    const existing = groups.get(root.run_id);
-    if (existing) {
-      existing.memberRuns.push(run);
-      continue;
-    }
-    groups.set(root.run_id, {
-      rootRun: root,
-      memberRuns: [run],
-      startedAt: root.started_at || run.started_at,
-    });
-  }
-
-  return Array.from(groups.values())
-    .map((group) => ({
-      ...group,
-      memberRuns: [...group.memberRuns].sort((a: ProcessRun, b: ProcessRun) => {
-        const at = parseTimelineTime(a.started_at) ?? 0;
-        const bt = parseTimelineTime(b.started_at) ?? 0;
-        return at - bt;
-      }),
-    }))
-    .sort((a, b) => {
-      const at = parseTimelineTime(a.startedAt) ?? 0;
-      const bt = parseTimelineTime(b.startedAt) ?? 0;
-      return at - bt;
-    });
-}
-
 export function MessageList({
   messages,
   isThinking,
   messagesEndRef,
   viewportRef,
-  processRuns,
-  processEvents,
-  processArtifacts,
-  selectedRunId,
-  onSelectRun,
   onFeedback,
   onRequestRevision,
 }: {
@@ -372,11 +302,6 @@ export function MessageList({
   isThinking: boolean;
   messagesEndRef: React.RefObject<HTMLDivElement>;
   viewportRef: React.RefObject<HTMLDivElement>;
-  processRuns: ProcessRun[];
-  processEvents: ProcessEvent[];
-  processArtifacts: ProcessArtifact[];
-  selectedRunId: string | null;
-  onSelectRun: (runId: string) => void;
   onFeedback: (runId: string, feedbackType: 'accept' | 'revise' | 'abandon', comment?: string) => void;
   onRequestRevision: (runId: string) => void;
 }) {
@@ -385,37 +310,6 @@ export function MessageList({
     () => messages.filter((message) => !shouldHideMessage(message)),
     [messages]
   );
-  const teamGroups = React.useMemo(
-    () =>
-      buildAgentTeamGroups(processRuns).filter((group) =>
-        group.memberRuns.some((run) => !TERMINAL_RUN_STATUSES.has(run.status))
-      ),
-    [processRuns]
-  );
-  const timelineItems = React.useMemo(() => {
-    const messageItems = visibleMessages.map((message, index) => ({
-      kind: 'message' as const,
-      key: `${message.role}:${message.timestamp || index}:${index}`,
-      sortTime: parseTimelineTime(message.timestamp) ?? Number.MAX_SAFE_INTEGER / 2 + index,
-      order: index,
-      message,
-      messageIndex: index,
-    }));
-    const teamItems = teamGroups.map((group, index) => ({
-        kind: 'team' as const,
-        key: `team:${group.rootRun.run_id}`,
-        sortTime: parseTimelineTime(group.startedAt) ?? Number.MAX_SAFE_INTEGER / 2 + visibleMessages.length + index,
-        order: visibleMessages.length + index,
-        group,
-      }));
-
-    return [...messageItems, ...teamItems].sort((a, b) => {
-      if (a.sortTime !== b.sortTime) {
-        return a.sortTime - b.sortTime;
-      }
-      return a.order - b.order;
-    });
-  }, [teamGroups, visibleMessages]);
   const taskCardMessageIndexes = React.useMemo(
     () => getTaskCardMessageIndexes(visibleMessages),
     [visibleMessages]
@@ -439,7 +333,7 @@ export function MessageList({
   return (
     <ScrollArea className="h-full px-3 sm:px-5 md:px-8" viewportRef={viewportRef}>
       <div className="mx-auto max-w-5xl space-y-8 py-6 md:py-10">
-        {visibleMessages.length === 0 && teamGroups.length === 0 && !isThinking && (
+        {visibleMessages.length === 0 && !isThinking && (
           <div className="flex flex-col items-center justify-center py-20 text-muted-foreground">
             <Bot className="w-12 h-12 mb-4 opacity-50" />
             <p className="text-lg font-medium text-foreground">Beaver</p>
@@ -447,28 +341,16 @@ export function MessageList({
           </div>
         )}
 
-        {timelineItems.map((item) =>
-          item.kind === 'message' ? (
-            <MessageBubble
-              key={item.key}
-              message={item.message}
-              showTaskCard={taskCardMessageIndexes.has(item.messageIndex)}
-              canSendFeedback={item.messageIndex === latestFeedbackMessageIndex}
-              onFeedback={onFeedback}
-              onRequestRevision={onRequestRevision}
-            />
-          ) : (
-            <AgentTeamBlock
-              key={item.key}
-              rootRun={item.group.rootRun}
-              memberRuns={item.group.memberRuns}
-              events={processEvents}
-              artifacts={processArtifacts}
-              selectedRunId={selectedRunId}
-              onSelectRun={onSelectRun}
-            />
-          )
-        )}
+        {visibleMessages.map((message, index) => (
+          <MessageBubble
+            key={`${message.role}:${message.timestamp || index}:${index}`}
+            message={message}
+            showTaskCard={taskCardMessageIndexes.has(index)}
+            canSendFeedback={index === latestFeedbackMessageIndex}
+            onFeedback={onFeedback}
+            onRequestRevision={onRequestRevision}
+          />
+        ))}
 
         {isThinking && (
           <div className="flex items-center gap-2 text-muted-foreground px-1">