ICreateTeamParams = {
  name: string;
  agents: {
    agent_type: string;
    agent_name: string;
    conversation_type: string;
    conversation_id: string;
    role: 'leader' | 'teammate';
    model?: TProviderWithModel;
    cli_path?: string;
    custom_agent_id?: string;
  }[]
}

type TTeam = {
  id: string;
  user_id: string;
  name: string;
  workspace: string;
  workspace_mode: 'shared' | 'isolated';
  leader_agent_id: string; // slot_id of leader
  agents: TeamAgent[];
  session_mode?: string; // 'plan', 'auto' 等，新生成的 agent 继承
  created_at: number;
  updated_at: number;
};

type TeamAgent = {
  slot_id: string; // 运行时分配的唯一 slot ID
  conversation_id: string; // 对应的 conversation 记录
  role: 'leader' | 'teammate';
  agent_type: string; // 'claude', 'gemini', 'acp', etc
  agent_name: string; // 用户可见名称
  conversation_type: string; // 'acp', 'aionrs', 'codex', etc
  status: TeammateStatus; // 'pending' | 'idle' | 'active' | 'completed' | 'failed'
  cli_path?: string; // 自定义 CLI 路径
  custom_agent_id?: string; // 自定义 agent ID
  model?: TProviderWithModel; // 模型配置
};

team.get({ id: string }) → Promise<TTeam | null>
team.list({ user_id: string }) → Promise<TTeam[]>

team.remove({ id: string }) → Promise<void>

team.addAgent({
  team_id: string;
  agent: Omit<TeamAgent, 'slot_id'>
}) → Promise<TeamAgent>

team.removeAgent({
  team_id: string;
  slot_id: string
}) → Promise<void>

┌─────────────────────────────────────────────────────────────────────┐
│                      Electron Main Process                           │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ TeamSession (one per team)                                        │ │
│ │  - Owns: Mailbox, TaskManager, TeammateManager, TeamMcpServer    │ │
│ │  - startMcpServer() → TCP server on localhost:random             │ │
│ │  - getStdioConfig(agentSlotId) → injected into session/new       │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ TeamMcpServer (TCP server, src/process/team/mcp/team/)           │ │
│ │  - Listens on localhost + random port                            │ │
│ │  - Auth via one-time random token (crypto.randomUUID)            │ │
│ │  - Exposes MCP tools: team_send_message, team_spawn_agent, ...   │ │
│ └──────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
                           ↓ (环境变量注入)
┌─────────────────────────────────────────────────────────────────────┐
│                    ACP Session (Agent Process)                       │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ stdio MCP Bridge (scripts/team-mcp-stdio.mjs)                    │ │
│ │  - 读环境变量：TEAM_MCP_PORT, TEAM_MCP_TOKEN, TEAM_AGENT_SLOT_ID │ │
│ │  - 连接到 TCP server                                             │ │
│ │  - 桥接 Claude CLI ↔ TCP                                         │ │
│ │  - 注册 MCP resources, tools, prompts                            │ │
│ └──────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘

await ipcBridge.team.ensureSession.invoke({ team_id: team.id });

async startMcpServer(): Promise<StdioMcpConfig> {
  if (!this.mcpStdioConfig) {
    this.mcpStdioConfig = await this.mcpServer.start();
  }
  return this.mcpStdioConfig;
}

getStdioConfig(agentSlotId?: string): StdioMcpConfig | null {
  if (!this.mcpStdioConfig) return null;
  if (!agentSlotId) return this.mcpStdioConfig;
  // 返回副本，agent slot_id 在 env 中
  return this.mcpServer.getStdioConfig(agentSlotId);
}

getStdioConfig(agentSlotId?: string): StdioMcpConfig {
  return {
    name: `aionui-team-${team_id}`,
    command: 'node',
    args: ['/path/to/team-mcp-stdio.js'],
    env: [
      { name: 'TEAM_MCP_PORT', value: String(port) },
      { name: 'TEAM_MCP_TOKEN', value: authToken },
      { name: 'TEAM_AGENT_SLOT_ID', value: agentSlotId },  // 可选
    ]
  };
}

type ITeamMcpStatusEvent = {
  team_id: string;
  slot_id?: string; // 可选：具体 agent
  phase: TeamMcpPhase;
  server_count?: number;
  port?: number;
  error?: string;
};

const sendMessage = useCallback(
  async (content: string) => {
    await ipcBridge.team.sendMessage.invoke({ team_id: team.id, content });
  },
  [team.id]
);

POST /api/teams/{team_id}/messages
Body: { content: string; files?: string[] }

tool_name: 'team_send_message'
args: { to: string; message: string; summary?: string }

write(params: {
  team_id: string;
  to_agent_id: string;
  from_agent_id: string;
  content: string;
  type?: 'message' | 'idle_notification' | 'shutdown_request';
  summary?: string;
  files?: string[];
}) → Promise<MailboxMessage>

readUnread(team_id: string, agentId: string)
  → Promise<MailboxMessage[]>  // 原子标记为已读

getHistory(team_id: string, agentId: string, limit?)
  → Promise<MailboxMessage[]>  // 最新优先

type MailboxMessage = {
  id: string;
  team_id: string;
  to_agent_id: string;
  from_agent_id: string;
  type: 'message' | 'idle_notification' | 'shutdown_request';
  content: string;
  summary?: string;
  files?: string[];
  read: boolean;
  created_at: number;
};

{
  team_id: string;
  slot_id: string;
  status: 'pending' | 'idle' | 'active' | 'completed' | 'failed';
  last_message?: string;           // 可选：状态摘要或错误信息
}

{
  team_id: string;
  agent: TeamAgent; // 完整 agent 记录
}

{
  team_id: string;
  slot_id: string;
}

{
  team_id: string;
  slot_id: string;
  old_name: string;
  new_name: string;
}

{
  team_id: string;
  action: 'created' | 'removed' | 'agent_added' | 'agent_removed';
}

{
  team_id: string;
  slot_id?: string;
  phase: TeamMcpPhase;             // 见上文 MCP 状态表
  server_count?: number;
  port?: number;
  error?: string;
}

useEffect(() => {
  // 状态变化
  const unsubStatus = ipcBridge.team.agentStatusChanged.on((event) => {
    if (event.team_id !== team.id) return;
    setStatusMap((prev) => {
      const next = new Map(prev);
      next.set(event.slot_id, { slot_id, status, last_message });
      return next;
    });
  });

  // Agent 生成
  const unsubSpawned = ipcBridge.team.agentSpawned.on((event) => {
    if (event.team_id !== team.id) return;
    void mutateTeam(); // 刷新 team 列表
  });

  // Agent 移除
  const unsubRemoved = ipcBridge.team.agentRemoved.on((event) => {
    if (event.team_id !== team.id) return;
    void mutateTeam();
  });

  // Agent 重命名
  const unsubRenamed = ipcBridge.team.agentRenamed.on((event) => {
    if (event.team_id !== team.id) return;
    void mutateTeam();
  });

  return () => {
    unsubStatus();
    unsubSpawned();
    unsubRemoved();
    unsubRenamed();
  };
}, [team.id, mutateTeam]);

useEffect(() => {
  return ipcBridge.team.listChanged.on(() => {
    void mutate(); // 刷新 team 列表
  });
}, [mutate]);

{
  statusMap: Map<string, { slot_id, status, last_message? }>;
  sendMessage(content: string): Promise<void>;
  addAgent(agent: Omit<TeamAgent, 'slot_id'>): Promise<void>;
  renameAgent(slot_id: string, new_name: string): Promise<void>;
  removeAgent(slot_id: string): Promise<void>;
  mutateTeam(): Promise<void>;  // 刷新 team 记录
}

{
  teams: TTeam[];
  mutate(): Promise<void>;
  removeTeam(id: string): Promise<void>;
}

// Role 和 Status
type TeammateRole = 'leader' | 'teammate';
type TeammateStatus = 'pending' | 'idle' | 'active' | 'completed' | 'failed';
type WorkspaceMode = 'shared' | 'isolated';

// 单个 Agent 配置
type TeamAgent = {
  slot_id: string; // 运行时唯一标识
  conversation_id: string;
  role: TeammateRole;
  agent_type: string; // 'claude', 'gemini', 'acp', etc
  agent_name: string; // 用户显示名称
  conversation_type: string; // 'acp', 'aionrs', 'codex', etc
  status: TeammateStatus;
  cli_path?: string;
  custom_agent_id?: string;
  model?: TProviderWithModel; // 模型配置
};

// 完整 Team 记录
type TTeam = {
  id: string;
  user_id: string;
  name: string;
  workspace: string; // 工作目录路径
  workspace_mode: WorkspaceMode; // 'shared' or 'isolated'
  leader_agent_id: string; // 指向 agents[*].slot_id
  agents: TeamAgent[];
  session_mode?: string; // 'plan', 'auto', etc
  created_at: number;
  updated_at: number;
};

// MCP 状态
type TeamMcpPhase =
  | 'tcp_ready'
  | 'tcp_error'
  | 'session_injecting'
  | 'session_ready'
  | 'session_error'
  | 'load_failed'
  | 'degraded'
  | 'config_write_failed'
  | 'mcp_tools_waiting'
  | 'mcp_tools_ready';

// Mailbox 消息
type MailboxMessage = {
  id: string;
  team_id: string;
  to_agent_id: string;
  from_agent_id: string;
  type: 'message' | 'idle_notification' | 'shutdown_request';
  content: string;
  summary?: string;
  files?: string[];
  read: boolean;
  created_at: number;
};

// 共享任务板
type TeamTask = {
  id: string;
  team_id: string;
  subject: string;
  description?: string;
  status: 'pending' | 'in_progress' | 'completed' | 'deleted';
  owner?: string; // slot_id
  blocked_by: string[]; // task ids
  blocks: string[]; // task ids
  metadata: Record<string, unknown>;
  created_at: number;
  updated_at: number;
};

// Idle 通知（agent 发送）
type IdleNotification = {
  type: 'idle_notification';
  idle_reason: 'available' | 'interrupted' | 'failed';
  summary: string;
  completed_task_id?: string;
  failure_reason?: string;
};

-- Team 元数据
CREATE TABLE teams (
  id TEXT PRIMARY KEY,
  user_id TEXT NOT NULL,
  name TEXT NOT NULL,
  workspace TEXT NOT NULL,
  workspace_mode TEXT NOT NULL,        -- 'shared' or 'isolated'
  lead_agent_id TEXT NOT NULL,         -- slot_id
  agents TEXT NOT NULL,                -- JSON array
  session_mode TEXT,
  created_at INTEGER NOT NULL,
  updated_at INTEGER NOT NULL
);

-- Mailbox 消息
CREATE TABLE mailbox (
  id TEXT PRIMARY KEY,
  team_id TEXT NOT NULL,
  to_agent_id TEXT NOT NULL,
  from_agent_id TEXT NOT NULL,
  type TEXT NOT NULL,                  -- 'message' | 'idle_notification' | ...
  content TEXT NOT NULL,
  summary TEXT,
  files TEXT,                          -- JSON array
  read INTEGER NOT NULL,               -- 0 or 1
  created_at INTEGER NOT NULL
);

-- 共享任务板
CREATE TABLE tasks (
  id TEXT PRIMARY KEY,
  team_id TEXT NOT NULL,
  subject TEXT NOT NULL,
  description TEXT,
  status TEXT NOT NULL,                -- 'pending' | 'in_progress' | 'completed' | 'deleted'
  owner TEXT,                          -- slot_id
  blocked_by TEXT NOT NULL,            -- JSON array
  blocks TEXT NOT NULL,                -- JSON array
  metadata TEXT NOT NULL,              -- JSON object
  created_at INTEGER NOT NULL,
  updated_at INTEGER NOT NULL
);