@yeaft/webchat-agent 0.1.106 → 0.1.113

package/connection/message-router.js

@@ -17,7 +17,7 @@ import {
 import {
   createCrewSession, handleCrewHumanInput, handleCrewControl,
   addRoleToSession, removeRoleFromSession,
-  handleListCrewSessions, handleCheckCrewExists, handleDeleteCrewDir, resumeCrewSession, removeFromCrewIndex,
+  handleListCrewSessions, handleCheckCrewExists, handleDeleteCrewDir, resumeCrewSession, removeFromCrewIndex, hideCrewSession,
   handleLoadCrewHistory
 } from '../crew.js';
 import { sendToServer, flushMessageBuffer } from './buffer.js';
@@ -240,7 +240,7 @@ export async function handleMessage(msg) {
       break;
 
     case 'delete_crew_session':
-      await removeFromCrewIndex(msg.sessionId);
+      await hideCrewSession(msg.sessionId);
       (await import('../conversation.js')).sendConversationList();
       break;
 

package/conversation.js

@@ -85,11 +85,11 @@ export async function sendConversationList() {
       type: 'crew',
     });
   }
-  // 追加索引中已停止的 crew sessions（不重复）
+  // 追加索引中已停止的 crew sessions（不重复，跳过 hidden）
   try {
     const index = await loadCrewIndex();
     for (const entry of index) {
-      if (!activeCrewIds.has(entry.sessionId)) {
+      if (!activeCrewIds.has(entry.sessionId) && !entry.hidden) {
         list.push({
           id: entry.sessionId,
           workDir: entry.projectDir,

package/crew/persistence.js

@@ -76,6 +76,44 @@ export async function removeFromCrewIndex(sessionId) {
   // 这些文件在 recreate 时会被复用（合并统计数据 + 恢复消息历史）
 }
 
+/**
+ * 隐藏 crew session（UI 删除 = 隐藏，不是真删）
+ * 在 crew-index 条目上标记 hidden: true + hiddenAt 时间戳，
+ * 同时从内存 crewSessions Map 中移除（停止运行态）。
+ * 不修改 session.json，不从 index 中移除条目。
+ */
+export async function hideCrewSession(sessionId) {
+  const { crewSessions } = await import('./session.js');
+
+  const index = await loadCrewIndex();
+  const entry = index.find(e => e.sessionId === sessionId);
+  if (entry) {
+    entry.hidden = true;
+    entry.hiddenAt = Date.now();
+    await saveCrewIndex(index);
+    console.log(`[Crew] Hidden session ${sessionId} in index`);
+  }
+  // 从内存中移除（停止运行态，防止 sendConversationList 加入）
+  if (crewSessions.has(sessionId)) {
+    crewSessions.delete(sessionId);
+    console.log(`[Crew] Removed session ${sessionId} from active sessions`);
+  }
+}
+
+/**
+ * 取消隐藏 crew session（用户主动恢复时调用）
+ */
+export async function unhideCrewSession(sessionId) {
+  const index = await loadCrewIndex();
+  const entry = index.find(e => e.sessionId === sessionId);
+  if (entry && entry.hidden) {
+    delete entry.hidden;
+    delete entry.hiddenAt;
+    await saveCrewIndex(index);
+    console.log(`[Crew] Unhidden session ${sessionId} in index`);
+  }
+}
+
 // =====================================================================
 // Session Metadata (.crew/session.json)
 // =====================================================================

package/crew/routing.js

@@ -27,12 +27,18 @@ export function parseRoutes(text) {
     const toMatch = block.match(/to:\s*(.+)/i);
     if (!toMatch) continue;
 
-    const summaryMatch = block.match(/summary:\s*([\s\S]+)/i);
+    // ★ Clean `to` value: take only the first word (strip parenthetical notes, extra text)
+    // e.g. "pm (决策者)" → "pm", "dev-1 // main dev" → "dev-1"
+    const toRaw = toMatch[1].trim().toLowerCase();
+    const toClean = toRaw.split(/[\s(]/)[0];
+
+    // ★ summary: match until next known field (task:/taskTitle:) or end of block
+    const summaryMatch = block.match(/summary:\s*([\s\S]+?)(?=\n\s*(?:task|taskTitle)\s*:|$)/i);
     const taskMatch = block.match(/^task:\s*(.+)/im);
     const taskTitleMatch = block.match(/^taskTitle:\s*(.+)/im);
 
     routes.push({
-      to: toMatch[1].trim().toLowerCase(),
+      to: toClean,
       summary: summaryMatch ? summaryMatch[1].trim() : '',
       taskId: taskMatch ? taskMatch[1].trim() : null,
       taskTitle: taskTitleMatch ? taskTitleMatch[1].trim() : null
@@ -42,6 +48,59 @@ export function parseRoutes(text) {
   return routes;
 }
 
+/**
+ * Resolve a ROUTE `to` value to an actual role name in the session.
+ *
+ * Resolution order:
+ * 1. Exact match: `to` matches a role name directly (e.g. "dev-1")
+ * 2. roleType match: `to` matches a role's roleType (e.g. "developer" → "dev-1")
+ * 3. Short prefix match: `to` matches the SHORT_PREFIX of a roleType (e.g. "dev" → "dev-1")
+ * 4. Same-group dispatch: if sender is in a multi-instance group (e.g. dev-1),
+ *    and `to` matches the roleType/prefix of another group (e.g. "reviewer"),
+ *    route to the instance with matching groupIndex (e.g. rev-1)
+ *
+ * For multi-instance matches (2/3), prefer the instance with the same groupIndex
+ * as the sender. Falls back to the first instance if no groupIndex match.
+ *
+ * @param {string} to - raw route target from ROUTE block
+ * @param {object} session - crew session
+ * @param {string} [fromRole] - sending role name (for groupIndex matching)
+ * @returns {string|null} resolved role name, or null if unresolvable
+ */
+export function resolveRoleName(to, session, fromRole) {
+  // 1. Exact match
+  if (session.roles.has(to)) return to;
+
+  // Build candidate list by roleType and short prefix
+  const fromRoleConfig = fromRole ? session.roles.get(fromRole) : null;
+  const fromGroupIndex = fromRoleConfig?.groupIndex || 0;
+
+  let candidates = [];
+
+  for (const [name, config] of session.roles) {
+    // 2. roleType match (e.g. "developer" → dev-1, dev-2, dev-3)
+    if (config.roleType === to) {
+      candidates.push({ name, groupIndex: config.groupIndex || 0 });
+    }
+    // 3. Short prefix match (e.g. "dev" → developer roleType → dev-1)
+    //    Match if the role name starts with `to-` (e.g. "dev" matches "dev-1", "dev-2")
+    else if (name.startsWith(to + '-') && /^\d+$/.test(name.slice(to.length + 1))) {
+      candidates.push({ name, groupIndex: config.groupIndex || 0 });
+    }
+  }
+
+  if (candidates.length === 0) return null;
+
+  // 4. Prefer same groupIndex as sender
+  if (fromGroupIndex > 0) {
+    const sameGroup = candidates.find(c => c.groupIndex === fromGroupIndex);
+    if (sameGroup) return sameGroup.name;
+  }
+
+  // Fall back to first candidate
+  return candidates[0].name;
+}
+
 /**
  * 执行路由
  */
@@ -68,7 +127,9 @@ export async function executeRoute(session, fromRole, route) {
     // 更新工作看板：推断状态
     const { getMessages } = await import('../crew-i18n.js');
     const m = getMessages(session.language || 'zh-CN');
-    const toRoleConfig = session.roles.get(to);
+    // ★ Use resolveRoleName for kanban status lookup too
+    const resolvedKanbanTo = resolveRoleName(to, session, fromRole);
+    const toRoleConfig = session.roles.get(resolvedKanbanTo || to);
     let status = m.kanbanStatusDev;
     if (toRoleConfig) {
       switch (toRoleConfig.roleType) {
@@ -111,13 +172,14 @@ export async function executeRoute(session, fromRole, route) {
   }
 
   // 路由到指定角色
-  if (session.roles.has(to)) {
+  const resolvedTo = resolveRoleName(to, session, fromRole);
+  if (resolvedTo) {
     if (session.humanMessageQueue.length > 0) {
       const { processHumanQueue } = await import('./human-interaction.js');
       await processHumanQueue(session);
     } else {
       const taskPrompt = buildRoutePrompt(fromRole, summary, session);
-      await dispatchToRole(session, to, taskPrompt, fromRole, taskId, taskTitle);
+      await dispatchToRole(session, resolvedTo, taskPrompt, fromRole, taskId, taskTitle);
     }
   } else {
     console.warn(`[Crew] Unknown route target: ${to}`);

package/crew/session.js

@@ -8,7 +8,7 @@ import { getMessages } from '../crew-i18n.js';
 import { initWorktrees } from './worktree.js';
 import { initSharedDir, writeRoleClaudeMd, updateSharedClaudeMd, backupMemoryContent } from './shared-dir.js';
 import {
-  loadCrewIndex, upsertCrewIndex, removeFromCrewIndex,
+  loadCrewIndex, upsertCrewIndex, removeFromCrewIndex, unhideCrewSession,
   loadSessionMeta, saveSessionMeta, loadSessionMessages, getMaxShardIndex
 } from './persistence.js';
 import { sendCrewMessage, sendCrewOutput, sendStatusUpdate } from './ui-messages.js';
@@ -121,6 +121,7 @@ async function findExistingSessionByProjectDir(projectDir) {
     e.projectDir.replace(/\/+$/, '') === normalizedDir
     && (!agentId || !e.agentId || e.agentId === agentId)
     && e.status !== 'completed'
+    && !e.hidden
   );
 
   if (match) {
@@ -428,6 +429,9 @@ export async function handleDeleteCrewDir(msg) {
 export async function resumeCrewSession(msg) {
   const { sessionId, userId, username } = msg;
 
+  // 用户主动恢复 → 清除 hidden 标记（如果有的话）
+  await unhideCrewSession(sessionId);
+
   if (crewSessions.has(sessionId)) {
     const session = crewSessions.get(sessionId);
     const roles = Array.from(session.roles.values());
@@ -465,17 +469,22 @@ export async function resumeCrewSession(msg) {
   const index = await loadCrewIndex();
   const indexEntry = index.find(e => e.sessionId === sessionId);
   if (!indexEntry) {
-    sendCrewMessage({ type: 'error', sessionId, message: 'Crew session not found in index' });
+    console.warn(`[Crew] resumeCrewSession: session ${sessionId} not found in index`);
+    sendCrewMessage({ type: 'crew_session_restore_failed', sessionId, message: 'Crew session not found in index' });
     return;
   }
 
   const meta = await loadSessionMeta(indexEntry.sharedDir);
   if (!meta) {
-    sendCrewMessage({ type: 'error', sessionId, message: 'Crew session metadata not found' });
+    console.warn(`[Crew] resumeCrewSession: session.json not found at ${indexEntry.sharedDir}`);
+    sendCrewMessage({ type: 'crew_session_restore_failed', sessionId, message: 'Crew session metadata not found' });
     return;
   }
 
   const roles = meta.roles || [];
+  if (roles.length === 0) {
+    console.warn(`[Crew] resumeCrewSession: session ${sessionId} has empty roles in session.json`);
+  }
   const decisionMaker = meta.decisionMaker || roles[0]?.name || null;
   const session = {
     id: sessionId,

package/crew.js

@@ -29,6 +29,7 @@ export {
 export {
   loadCrewIndex,
   removeFromCrewIndex,
+  hideCrewSession,
   handleLoadCrewHistory
 } from './crew/persistence.js';
 

package/index.js

@@ -78,7 +78,7 @@ const CONFIG = {
   // 最大上下文 tokens（用于百分比计算的分母）
   maxContextTokens: parseInt(process.env.MAX_CONTEXT_TOKENS || fileConfig.maxContextTokens, 10) || 128000,
   // Auto-compact 阈值（tokens）：context 超过此值时自动触发 compact
-  autoCompactThreshold: parseInt(process.env.AUTO_COMPACT_THRESHOLD || fileConfig.autoCompactThreshold, 10) || 100000
+  autoCompactThreshold: parseInt(process.env.AUTO_COMPACT_THRESHOLD || fileConfig.autoCompactThreshold, 10) || 110000
 };
 
 // 初始化共享上下文

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.106",
+  "version": "0.1.113",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/roleplay-dir.js

@@ -25,7 +25,7 @@ import { getRolePlayMessages } from './roleplay-i18n.js';
 const TEAM_ROLES = {
   dev:     ['pm', 'dev', 'reviewer', 'tester'],
   writing: ['editor', 'writer', 'proofreader'],
-  trading: ['analyst', 'strategist', 'risk-manager'],
+  trading: ['quant', 'strategist', 'risk', 'macro'],
   video:   ['director', 'writer', 'producer'],
   custom:  ['pm', 'dev', 'reviewer', 'tester'], // default same as dev
 };

package/roleplay-i18n.js

@@ -21,7 +21,7 @@ const messages = {
 - 适合轻量级协作和快速迭代`,
     workConventions: '# 工作约定',
     workConventionsContent: `- 文档产出写入 .roleplay/context/ 目录
-- 代码修改使用项目路径的绝对路径
+- 文件操作使用项目路径的绝对路径
 - 每个角色专注自己的职责，不越界
 - **Plan mode 自动退出**：可以进入 plan mode 梳理思路和写计划，但计划写完后必须立即调用 ExitPlanMode 自动退出并直接开始执行，不要等待用户审批。只有在方案有重大歧义、需要用户做选择时才停下来确认`,
     crewRelation: '# 与 .crew 的关系',
@@ -117,14 +117,25 @@ const messages = {
 风格：严谨细致，注重可读性。`,
       },
       // Trading team
+      quant: {
+        heading: '## 📊 量化分析师-西蒙斯 (quant)',
+        content: `你是量化分析师-西蒙斯。团队的数据引擎。
+- 使用 Bash 工具运行 Python 脚本做数据分析
+- 输出量化信号、关键价位、技术指标
+- 可随时被要求换参数重新跑数据
+- 数据格式化为表格或结构化文本
+
+风格：纯数学家，用数据和概率说话。`,
+      },
       strategist: {
-        heading: '## 📋 策略师 (strategist)',
-        content: `你是策略师。你的职责：
-- 综合技术分析和宏观研究做出交易决策
-- 管理整体仓位和风险敞口
-- 协调团队分析方向
+        heading: '## 📐 策略师-索罗斯 (strategist)',
+        content: `你是策略师-索罗斯。团队的决策核心。
+- 综合量化数据和宏观分析，形成投资策略
+- 明确核心假设、验证信号和证伪条件
+- 决定仓位大小和进出场时机
+- 可以要求任何角色提供更多数据
 
-风格：冷静理性，注重概率思维。`,
+风格：反身性思维，基于数据决策。`,
       },
       analyst: {
         heading: '## 📊 技术分析师 (analyst)',
@@ -136,22 +147,24 @@ const messages = {
 风格：数据驱动，图表说话。`,
       },
       macro: {
-        heading: '## 🌐 宏观研究员 (macro)',
-        content: `你是宏观研究员。你的职责：
-- 分析宏观经济数据和政策
-- 评估市场情绪和资金流向
-- 提供宏观背景判断
+        heading: '## 🌐 宏观研究员-达里奥 (macro)',
+        content: `你是宏观研究员-达里奥。团队的宏观视野。
+- 分析宏观经济数据、央行政策、债务周期
+- 输出周期定位、关键驱动因子、情景分析
+- 评估跨资产联动关系
+- 可要求量化分析师跑宏观相关数据
 
-风格：视野开阔，善于关联不同市场。`,
+风格：把经济看成机器，有因果链条。`,
       },
       risk: {
-        heading: '## 🛡️ 风控 (risk)',
-        content: `你是风控。你的职责：
-- 审查交易方案的风险
-- 设定止损和仓位限制
-- 监控已有持仓风险
+        heading: '## 🛡️ 风控官-塔勒布 (risk)',
+        content: `你是风控官-塔勒布。团队的生存保障。
+- 压力测试策略，评估尾部风险
+- 检查仓位合规（单笔≤2%，总敞口≤10%）
+- 审核止损和对冲方案
+- 风险不可接受时直接打回
 
-风格：保守谨慎，底线思维。`,
+风格：反脆弱思维，尾部风险偏执狂。`,
       },
       trader: {
         heading: '## 💰 交易员 (trader)',
@@ -250,10 +263,18 @@ taskTitle: {任务标题}（可选）
 2. **作者** 根据大纲撰写内容
 3. **审校** 检查逻辑一致性、事实准确性和文字质量（不通过 → 返回作者修改）
 4. **编辑** 验收最终成果`,
-    tradingWorkflow: `1. **分析师** 研究市场，输出技术分析和关键价位
-2. **策略师** 综合分析，制定投资策略和仓位方案
-3. **风控官** 压力测试策略，评估尾部风险（不通过 → 返回策略师调整）
-4. **策略师** 确认最终方案并总结`,
+    tradingWorkflow: `1. 用户提出分析需求
+2. **量化分析师** 执行脚本/获取数据，输出量化信号和分析结果
+3. **策略师** 和 **宏观研究员** 分析数据，各自给出观点
+4. **策略师** 综合各方分析，形成初步策略方案
+5. **风控官** 压力测试策略（不通过 → 返回策略师调整）
+6. 多角色可以相互讨论、质疑、补充（不必严格线性流转）
+7. **策略师** 确认最终方案，输出结构化交易建议
+
+关键原则：
+- 量化分析师可以随时被要求重新跑数据或换参数
+- 任何角色都可以 ROUTE 给任何角色提问/质疑
+- 工作流强调"基于数据的迭代优化"`,
     videoWorkflow: `1. **导演** 确定主题、情绪基调和视觉风格
 2. **编剧** 构思故事线，撰写分段脚本
 3. **制片** 审核可行性，生成最终 prompt 序列（不通过 → 返回编剧调整）
@@ -279,7 +300,7 @@ Differences from Crew (multi-process, each role has its own Claude instance):
 - Suitable for lightweight collaboration and rapid iteration`,
     workConventions: '# Work Conventions',
     workConventionsContent: `- Write documentation output to .roleplay/context/ directory
-- Use absolute project path for code changes
+- Use absolute project path for file operations
 - Each role focuses on its own responsibilities`,
     crewRelation: '# Relationship with .crew',
     crewRelationContent: `- .roleplay/context/ can read .crew/context/ content
@@ -370,15 +391,26 @@ Style: Sharp writing, good at using details to move people.`,
 - Confirm content aligns with overall direction
 
 Style: Rigorous and detailed, focused on readability.`,
+      },
+      quant: {
+        heading: '## 📊 Quant-Simons (quant)',
+        content: `You are Quant-Simons. The team's data engine.
+- Use Bash tool to run Python scripts for data analysis
+- Output quantitative signals, key levels, technical indicators
+- Can be asked to re-run with different parameters at any time
+- Format data as tables or structured text
+
+Style: pure mathematician, speaks in data and probability.`,
       },
       strategist: {
-        heading: '## 📋 Strategist (strategist)',
-        content: `You are the Strategist. Your responsibilities:
-- Synthesize technical analysis and macro research for trading decisions
-- Manage overall positions and risk exposure
-- Coordinate team analysis direction
+        heading: '## 📐 Strategist-Soros (strategist)',
+        content: `You are Strategist-Soros. The team's decision core.
+- Synthesize quantitative data and macro analysis into investment strategies
+- Define core hypothesis, validation signals, and falsification conditions
+- Determine position sizing and entry/exit timing
+- Can request any role to provide more data
 
-Style: Calm and rational, probability-focused thinking.`,
+Style: reflexivity thinking, data-driven decisions.`,
       },
       analyst: {
         heading: '## 📊 Technical Analyst (analyst)',
@@ -390,22 +422,24 @@ Style: Calm and rational, probability-focused thinking.`,
 Style: Data-driven, charts speak.`,
       },
       macro: {
-        heading: '## 🌐 Macro Researcher (macro)',
-        content: `You are the Macro Researcher. Your responsibilities:
-- Analyze macroeconomic data and policies
-- Assess market sentiment and fund flows
-- Provide macro context judgment
+        heading: '## 🌐 Macro-Researcher-Dalio (macro)',
+        content: `You are Macro-Researcher-Dalio. The team's macro perspective.
+- Analyze macroeconomic data, central bank policies, debt cycles
+- Output cycle positioning, key drivers, scenario analysis
+- Assess cross-asset correlations
+- Can request quant to run macro-related data analysis
 
-Style: Broad perspective, good at connecting different markets.`,
+Style: sees the economy as a machine with causal chains.`,
       },
       risk: {
-        heading: '## 🛡️ Risk Manager (risk)',
-        content: `You are the Risk Manager. Your responsibilities:
-- Review trading plan risks
-- Set stop-loss and position limits
-- Monitor existing position risk
+        heading: '## 🛡️ Risk-Officer-Taleb (risk)',
+        content: `You are Risk-Officer-Taleb. The team's survival guarantee.
+- Stress-test strategies, assess tail risks
+- Verify position compliance (single trade ≤2%, total exposure ≤10%)
+- Review stop-loss and hedging plans
+- Reject strategies with unacceptable risk
 
-Style: Conservative, bottom-line thinking.`,
+Style: antifragile thinking, tail risk obsessive.`,
       },
       trader: {
         heading: '## 💰 Trader (trader)',
@@ -503,10 +537,18 @@ Rules:
 2. **Writer** writes content based on outline
 3. **Proofreader** checks logical consistency, factual accuracy, and writing quality (if fails → back to Writer)
 4. **Editor** final acceptance of deliverables`,
-    tradingWorkflow: `1. **Analyst** researches market, outputs technical analysis and key levels
-2. **Strategist** synthesizes analysis, formulates investment strategy and position plan
-3. **Risk Manager** stress-tests strategy, assesses tail risks (if fails → back to Strategist)
-4. **Strategist** confirms final plan and summarizes`,
+    tradingWorkflow: `1. User submits analysis request
+2. **Quant** executes scripts/fetches data, outputs quantitative signals and analysis results
+3. **Strategist** and **Macro Researcher** analyze data, each provides perspective
+4. **Strategist** synthesizes all analyses into preliminary strategy
+5. **Risk Officer** stress-tests strategy (if fails → back to Strategist for adjustment)
+6. Roles can freely discuss, challenge, and supplement each other (not strictly linear)
+7. **Strategist** confirms final plan, outputs structured trading recommendation
+
+Key principles:
+- Quant can be asked to re-run data or change parameters at any time
+- Any role can ROUTE to any other role to ask questions or challenge
+- Workflow emphasizes "data-driven iterative optimization"`,
     videoWorkflow: `1. **Director** establishes theme, emotional tone, and visual style
 2. **Screenwriter** conceives storyline, writes segmented script
 3. **Producer** reviews feasibility, generates final prompt sequence (if fails → back to Screenwriter)

package/roleplay.js

@@ -325,8 +325,8 @@ export function buildRolePlaySystemPrompt(config) {
   const workflow = getWorkflow(teamType, roles, isZh);
 
   const prompt = isZh
-    ? buildZhPrompt(roleList, workflow)
-    : buildEnPrompt(roleList, workflow);
+    ? buildZhPrompt(roleList, workflow, teamType)
+    : buildEnPrompt(roleList, workflow, teamType);
 
   // Append .crew context if available
   if (crewContext) {
@@ -339,7 +339,18 @@ export function buildRolePlaySystemPrompt(config) {
   return prompt.trim();
 }
 
-function buildZhPrompt(roleList, workflow) {
+function buildZhPrompt(roleList, workflow, teamType) {
+  const isDevTeam = teamType === 'dev' || teamType === 'custom';
+
+  const outputRules = isDevTeam
+    ? `- 不要在回复开头添加角色名称或"XX视角"等标题，对话界面已经显示了角色信息，直接以角色身份开始回复内容
+- 代码修改使用工具（Read, Edit, Write 等），不要在聊天中贴大段代码
+- 每个角色专注做自己的事，不要代替其他角色
+- Review 和 Test 角色如果发现问题，必须切回 Dev 修复后再继续`
+    : `- 不要在回复开头添加角色名称或"XX视角"等标题，对话界面已经显示了角色信息，直接以角色身份开始回复内容
+- 每个角色专注做自己的事，不要代替其他角色
+- 角色之间可以自由讨论和质疑，鼓励迭代优化`;
+
   return `
 # 多角色协作模式
 
@@ -396,10 +407,7 @@ ${workflow}
 
 ## 输出格式
 
-- 不要在回复开头添加角色名称或"XX视角"等标题，对话界面已经显示了角色信息，直接以角色身份开始回复内容
-- 代码修改使用工具（Read, Edit, Write 等），不要在聊天中贴大段代码
-- 每个角色专注做自己的事，不要代替其他角色
-- Review 和 Test 角色如果发现问题，必须切回 Dev 修复后再继续
+${outputRules}
 
 ## 语言
 
@@ -407,7 +415,18 @@ ${workflow}
 `;
 }
 
-function buildEnPrompt(roleList, workflow) {
+function buildEnPrompt(roleList, workflow, teamType) {
+  const isDevTeam = teamType === 'dev' || teamType === 'custom';
+
+  const outputRules = isDevTeam
+    ? `- Do not add role names or titles like "XX's perspective" at the beginning of responses; the chat UI already displays role information — start directly with the role's content
+- Use tools (Read, Edit, Write, etc.) for code changes, don't paste large code blocks in chat
+- Each role focuses on its own responsibility, don't do other roles' jobs
+- If Review or Test finds issues, must switch back to Dev to fix before continuing`
+    : `- Do not add role names or titles like "XX's perspective" at the beginning of responses; the chat UI already displays role information — start directly with the role's content
+- Each role focuses on its own responsibility, don't do other roles' jobs
+- Roles can freely discuss and challenge each other, iterative optimization is encouraged`;
+
   return `
 # Multi-Role Collaboration Mode
 
@@ -464,10 +483,7 @@ Each role switch must include clear handoff information from the previous role:
 
 ## Output Format
 
-- Do not add role names or titles like "XX's perspective" at the beginning of responses; the chat UI already displays role information — start directly with the role's content
-- Use tools (Read, Edit, Write, etc.) for code changes, don't paste large code blocks in chat
-- Each role focuses on its own responsibility, don't do other roles' jobs
-- If Review or Test finds issues, must switch back to Dev to fix before continuing
+${outputRules}
 
 ## Language
 
@@ -550,22 +566,51 @@ function buildWritingWorkflow(roleNames, isZh) {
 }
 
 function buildTradingWorkflow(roleNames, isZh) {
-  const hasAnalyst = roleNames.includes('analyst');
+  const hasQuant = roleNames.includes('quant');
   const hasStrategist = roleNames.includes('strategist');
-  const hasRiskManager = roleNames.includes('risk-manager');
+  const hasRisk = roleNames.includes('risk');
+  const hasMacro = roleNames.includes('macro');
 
   const steps = [];
 
   if (isZh) {
-    if (hasAnalyst) steps.push(`${steps.length + 1}. **分析师** 研究市场，输出技术分析和关键价位`);
-    if (hasStrategist) steps.push(`${steps.length + 1}. **策略师** 综合分析，制定投资策略和仓位方案`);
-    if (hasRiskManager) steps.push(`${steps.length + 1}. **风控官** 压力测试策略，评估尾部风险（不通过 → 返回策略师调整）`);
-    if (hasStrategist) steps.push(`${steps.length + 1}. **策略师** 确认最终方案并总结`);
+    steps.push(`${steps.length + 1}. 用户提出分析需求`);
+    if (hasQuant) steps.push(`${steps.length + 1}. **量化分析师** 执行脚本/获取数据，输出量化信号和分析结果`);
+    if (hasStrategist && hasMacro) {
+      steps.push(`${steps.length + 1}. **策略师** 和 **宏观研究员** 分析数据，各自给出观点`);
+    } else if (hasStrategist) {
+      steps.push(`${steps.length + 1}. **策略师** 分析数据，给出观点`);
+    } else if (hasMacro) {
+      steps.push(`${steps.length + 1}. **宏观研究员** 分析数据，给出观点`);
+    }
+    if (hasStrategist) steps.push(`${steps.length + 1}. **策略师** 综合各方分析，形成初步策略方案`);
+    if (hasRisk) steps.push(`${steps.length + 1}. **风控官** 压力测试策略（不通过 → 返回策略师调整）`);
+    steps.push(`${steps.length + 1}. 多角色可以相互讨论、质疑、补充（不必严格线性流转）`);
+    if (hasStrategist) steps.push(`${steps.length + 1}. **策略师** 确认最终方案，输出结构化交易建议`);
+    steps.push('');
+    steps.push('关键原则：');
+    if (hasQuant) steps.push('- 量化分析师可以随时被要求重新跑数据或换参数');
+    steps.push('- 任何角色都可以 ROUTE 给任何角色提问/质疑');
+    steps.push('- 工作流强调"基于数据的迭代优化"');
   } else {
-    if (hasAnalyst) steps.push(`${steps.length + 1}. **Analyst** researches market, outputs technical analysis and key levels`);
-    if (hasStrategist) steps.push(`${steps.length + 1}. **Strategist** synthesizes analysis, formulates investment strategy and position plan`);
-    if (hasRiskManager) steps.push(`${steps.length + 1}. **Risk Manager** stress-tests strategy, assesses tail risks (if fails → back to Strategist)`);
-    if (hasStrategist) steps.push(`${steps.length + 1}. **Strategist** confirms final plan and summarizes`);
+    steps.push(`${steps.length + 1}. User submits analysis request`);
+    if (hasQuant) steps.push(`${steps.length + 1}. **Quant** executes scripts/fetches data, outputs quantitative signals`);
+    if (hasStrategist && hasMacro) {
+      steps.push(`${steps.length + 1}. **Strategist** and **Macro Researcher** analyze data, each provides perspective`);
+    } else if (hasStrategist) {
+      steps.push(`${steps.length + 1}. **Strategist** analyzes data, provides perspective`);
+    } else if (hasMacro) {
+      steps.push(`${steps.length + 1}. **Macro Researcher** analyzes data, provides perspective`);
+    }
+    if (hasStrategist) steps.push(`${steps.length + 1}. **Strategist** synthesizes all analyses into preliminary strategy`);
+    if (hasRisk) steps.push(`${steps.length + 1}. **Risk Officer** stress-tests strategy (if fails → back to Strategist)`);
+    steps.push(`${steps.length + 1}. Roles can freely discuss, challenge, and supplement (not strictly linear)`);
+    if (hasStrategist) steps.push(`${steps.length + 1}. **Strategist** confirms final plan, outputs structured recommendation`);
+    steps.push('');
+    steps.push('Key principles:');
+    if (hasQuant) steps.push('- Quant can be asked to re-run data or change parameters at any time');
+    steps.push('- Any role can ROUTE to any other role to ask questions or challenge');
+    steps.push('- Workflow emphasizes "data-driven iterative optimization"');
   }
 
   return steps.join('\n');