@yeaft/webchat-agent 0.0.209 → 0.0.210

package/crew-i18n.js

@@ -0,0 +1,374 @@
+/**
+ * Crew Mode i18n — localized template strings for crew system prompts and files.
+ *
+ * Supported languages: 'zh-CN' (default), 'en'
+ * Session language is set at creation and never changes.
+ */
+
+const messages = {
+  'zh-CN': {
+    // buildRoleSystemPrompt
+    teamCollab: '# 团队协作',
+    teamCollabIntro: (goal) => goal ? `你正在一个 AI 团队中工作。项目目标是: ${goal}` : '你正在一个 AI 团队中工作。等待用户提出任务或问题。',
+    teamMembers: '团队成员:',
+    decisionMakerTag: '决策者',
+
+    routingRules: '# 路由规则',
+    routingIntro: '当你完成当前任务并需要将结果传递给其他角色时，在你的回复最末尾添加一个 ROUTE 块：',
+    routeTargets: '可用的路由目标:',
+    humanTarget: '人工（只在决策者也无法决定时使用）',
+    routeNotes: (dm) => `注意：
+- 如果你的工作还没完成，不需要添加 ROUTE 块
+- 如果你遇到不确定的问题，@ 决策者 "${dm}"，而不是直接 @ human
+- 如果你是决策者且遇到需要人类判断的问题，才 @ human
+- 可以一次发多个 ROUTE 块来并行分配任务给不同角色
+- ROUTE 块必须在回复的最末尾
+- 当你的任务已完成且不需要其他角色继续时，ROUTE 回决策者 "${dm}" 做总结
+- 在正文中可用 @角色name 提及某个角色（如 @developer），但这不会触发路由，仅供阅读`,
+
+    // Decision maker sections
+    toolUsage: '# 工具使用',
+    toolUsageContent: (isDevTeam) =>
+      `PM 可以使用所有工具，包括 Read、Grep、Glob、Bash、Edit、Write。${isDevTeam ? '代码文件的改动仍建议 ROUTE 给 developer 执行，但不做硬性限制。' : ''}`,
+
+    dmRole: '# 决策者职责',
+    dmRoleContent: `你是团队的决策者。其他角色遇到不确定的情况会请求你的决策。
+- 如果你有足够的信息做出决策，直接决定并 @相关角色执行
+- 如果你需要更多信息，@具体角色请求补充
+- 如果问题超出你的能力范围或需要业务判断，@human 请人类决定
+- 你可以随时审查其他角色的工作并给出反馈`,
+
+    dmDevExtra: `
+- PM 不做代码分析。收到需求后直接将原始需求 ROUTE 给空闲 dev 做技术分析，dev 分析完返回 PM，PM 再拆分任务并直接分配执行。
+- PM 拥有 commit + push + tag 的自主权。只要修改没有大的 regression 影响（测试全通过），PM 可以自行决定 commit、push 和 tag，无需等待人工确认。只有当改动会直接影响对话交互逻辑时，才需要人工介入审核。`,
+
+    collabMode: '# 协作模式',
+    collabModeContent: `这是一个协作讨论团队，不走严格的 PM→执行→审查→测试 工作流。
+- 角色之间可以自由讨论、相互请教、提出不同意见
+- 不需要严格的"分配→执行→审查"流程，鼓励角色之间直接对话
+- 当一个角色需要另一个角色的输入时，直接 ROUTE 给对方并说明需要什么
+- 决策者负责把控整体方向和最终决策，但日常讨论不需要经过决策者中转
+- 每次 ROUTE 仍建议包含 task 和 taskTitle 字段，用于消息按 feature 分组显示`,
+
+    execGroupStatus: '# 执行组状态',
+    parallelRules: '# 并行任务调度规则',
+    parallelRulesContent: (maxGroup) => `你有 ${maxGroup} 个开发组可以并行工作。拆分任务时：
+1. 每个子任务分配 task-id（如 task-1）和 taskTitle（如 "实现登录页面"）
+2. 优先分配给**空闲**的开发组，避免给忙碌的 dev 发新任务
+3. 一次可以发**多个 ROUTE 块**来并行分配任务：`,
+    parallelExample: `4. 每个 dev 完成后会独立经过 reviewer 和 tester 审核，最后 ROUTE 回你
+5. 等待**所有子任务完成**后再做汇总报告
+6. **每次 ROUTE 都必须包含 task 和 taskTitle 字段，不能省略。没有 task 字段的 ROUTE 会导致消息无法按 feature 分组显示**`,
+
+    groupBusy: (task) => `忙:${task}`,
+    groupBusyShort: '忙',
+    groupIdle: '空闲',
+    groupLabel: (g) => `组${g}`,
+
+    workflowEnd: '# 工作流终结点',
+    workflowEndContent: (isDevTeam) =>
+      `团队的工作流有明确的结束条件。当以下任一条件满足时，你应该给出总结并结束当前工作流：
+${isDevTeam ? '1. **代码已提交** - 所有代码修改已经 commit（如需要，可让 developer 执行 git commit）\n' : ''}${isDevTeam ? '2' : '1'}. **需要用户输入** - 遇到需要用户决定的问题时，@human 提出具体问题，等待用户回复
+${isDevTeam ? '3' : '2'}. **任务完成** - 所有任务已完成，给出完成总结（列出完成了什么${isDevTeam ? '、变更了哪些文件' : ''}、还有什么后续建议）
+
+重要：不要无限循环地在角色之间传递。当工作实质性完成时，主动给出总结并结束。`,
+
+    taskList: '# 任务清单',
+    taskListContent: `你可以在回复中添加 TASKS 块来发布/更新任务清单，团队界面会自动展示：`,
+    taskListNotes: `注意：
+- 每行一个任务，[ ] 表示待办，[x] 表示已完成
+- #taskId 标注对应的 feature ID（如 #task-1），用于精确关联任务完成状态
+- @角色name 标注负责人（可选）
+- 后续回复中可更新 TASKS 块（标记完成的任务）
+- TASKS 块不需要在回复最末尾，可以放在任意位置`,
+    taskExample: `---TASKS---
+- [ ] 任务描述 #task-1 @角色name
+- [x] 已完成的任务 #task-2 @角色name
+---END_TASKS---`,
+
+    featureRecordTitle: '# Feature 工作记录',
+    featureRecordContent: `系统会自动管理 \`context/features/{task-id}.md\` 工作记录文件：
+- PM 分配任务时自动创建文件（包含 task-id、标题、需求描述）
+- 每次 ROUTE 传递时自动追加工作记录（角色名、时间、summary）
+- 你收到的消息中会包含 <task-context> 标签，里面是该任务的完整工作记录
+
+系统还维护以下文件（自动更新，无需手动管理）：
+- \`context/features/index.md\`：所有 feature 的索引（进行中/已完成分类），快速查看项目状态
+- \`context/changelog.md\`：已完成任务的变更记录，每个任务完成时自动追加摘要
+你不需要手动创建或更新这些文件，专注于你的本职工作即可。`,
+
+    devGroupBinding: '# 开发组绑定',
+    devGroupBindingContent: (gi, revLabel, revName, testLabel, testName) =>
+      `你属于开发组 ${gi}。你的搭档：
+- 审查者: ${revLabel} (${revName})
+- 测试: ${testLabel} (${testName})
+
+开发完成后，请同时发两个 ROUTE 块分别给 ${revName} 和 ${testName}：`,
+    devGroupBindingNote: '两者会并行工作，各自完成后独立 ROUTE 回 PM。',
+
+    implLoginPage: '实现登录页面',
+    implLoginSummary: '请实现登录页面，包括表单验证和API调用',
+    implRegisterPage: '实现注册页面',
+    implRegisterSummary: '请实现注册页面，包括邮箱验证',
+    reviewCode: '请审查代码变更',
+    testFeature: '请测试功能',
+
+    // buildInitialTask
+    projectStart: '项目启动！',
+    goalLabel: '目标',
+    firstRoleInstruction: '你是第一个开始工作的角色。请分析目标，开始你的工作。\n完成后，通过 ROUTE 块将结果传递给下一个合适的角色。',
+    availableRoles: '团队中可用的角色:',
+
+    // writeSharedClaudeMd
+    projectGoal: '# 项目目标',
+    projectCodePath: '# 项目代码路径',
+    useAbsolutePath: '所有代码操作请使用此绝对路径。',
+    teamMembersTitle: '# 团队成员',
+    noMembers: '_暂无成员_',
+    workConventions: '# 工作约定',
+    workConventionsContent: `- 文档产出写入 context/ 目录
+- 重要决策记录在 context/decisions.md
+- 代码修改使用项目代码路径的绝对路径`,
+    stuckRules: '# 卡住上报规则',
+    stuckRulesContent: `当你遇到以下情况时，不要自己空转或反复重试，立即 ROUTE 给 PM（pm）请求协调：
+1. 缺少前置依赖（如需要的文件、目录、代码不存在）
+2. 等待其他角色的产出但迟迟没有收到
+3. 任务描述不清楚或有歧义，无法判断正确做法
+4. 遇到超出自己职责范围的问题
+5. 连续尝试 2 次相同操作仍然失败
+上报时请说明：你在做什么任务、卡在哪里、你认为需要谁来协助。PM 会统筹全局，判断是分配给合适的人还是调整任务顺序。`,
+    worktreeRules: '# Worktree 隔离规则',
+    worktreeRulesContent: `- dev/reviewer/tester 角色必须在各自分配的 worktree 中工作，绝对禁止在项目主目录或 main 分支上修改代码
+- 每个角色的 CLAUDE.md 会标明「代码工作目录」，该路径就是你的 worktree，所有文件操作必须使用该路径
+- PM 和 designer 不使用 worktree，他们在项目主目录下以只读方式工作
+- 绝对禁止在其他开发组的 worktree 中操作代码
+- 代码完成并通过 review 后，dev 自己提 PR 合并到 main 分支
+- PM 不做 cherry-pick，只负责打 tag
+- 每次新任务/新 feature 必须基于最新的 main 分支创建新的 worktree，确保在最新代码上开发`,
+    featureRecordShared: `# Feature 工作记录
+系统自动管理 \`context/features/{task-id}.md\` 工作记录文件：
+- PM 通过 ROUTE 分配任务（带 task + taskTitle 字段）时自动创建
+- 每次角色 ROUTE 传递时自动追加工作记录
+- 角色收到消息时自动注入对应 task 文件内容作为上下文
+角色不需要手动创建或更新这些文件。`,
+    sharedMemoryTitle: '# 共享记忆',
+    sharedMemoryDefault: '_团队共同维护，记录重要的共识、决策和信息。_',
+
+    // writeRoleClaudeMd
+    roleTitle: (label) => `# 角色: ${label}`,
+    codeWorkDir: '# 代码工作目录',
+    codeWorkDirNote: '所有代码操作请使用此路径。不要使用项目主目录。',
+    personalMemory: '# 个人记忆',
+    personalMemoryDefault: '_在这里记录重要的信息、决策、进展和待办事项。_',
+
+    // ensureTaskFile
+    featureLabel: 'Feature',
+    statusPending: '待开发',
+    assigneeLabel: '负责人',
+    createdAtLabel: '创建时间',
+    requirementDesc: '## 需求描述',
+    workRecord: '## 工作记录',
+
+    // updateFeatureIndex
+    featureIndex: '# Feature Index',
+    lastUpdated: '最后更新',
+    inProgressGroup: (n) => `## 进行中 (${n})`,
+    completedGroup: (n) => `## 已完成 (${n})`,
+    colTaskId: 'task-id',
+    colTitle: '标题',
+    colCreatedAt: '创建时间',
+
+    // appendChangelog
+    changelogTitle: '# Changelog',
+    completedAt: '完成时间',
+    summaryLabel: '摘要',
+    noSummary: '（无详细摘要）',
+  },
+
+  'en': {
+    // buildRoleSystemPrompt
+    teamCollab: '# Team Collaboration',
+    teamCollabIntro: (goal) => goal ? `You are working in an AI team. The project goal is: ${goal}` : 'You are working in an AI team. Waiting for the user to assign tasks or questions.',
+    teamMembers: 'Team members:',
+    decisionMakerTag: 'Decision Maker',
+
+    routingRules: '# Routing Rules',
+    routingIntro: 'When you finish your current task and need to pass the result to another role, add a ROUTE block at the very end of your reply:',
+    routeTargets: 'Available routing targets:',
+    humanTarget: 'Human (only when the decision maker cannot decide)',
+    routeNotes: (dm) => `Notes:
+- If your work is not yet complete, do not add a ROUTE block
+- If you encounter an uncertain issue, @ the decision maker "${dm}" instead of directly @ human
+- Only @ human if you are the decision maker and the issue requires human judgment
+- You can send multiple ROUTE blocks to assign tasks to different roles in parallel
+- ROUTE blocks must be at the very end of your reply
+- When your task is complete and no further role handoff is needed, ROUTE back to the decision maker "${dm}" for summary
+- You can mention a role by @roleName in the body text (e.g., @developer) for reference only — this does not trigger routing`,
+
+    // Decision maker sections
+    toolUsage: '# Tool Usage',
+    toolUsageContent: (isDevTeam) =>
+      `PM can use all tools including Read, Grep, Glob, Bash, Edit, Write.${isDevTeam ? ' Code changes are still recommended to ROUTE to developer, but not strictly required.' : ''}`,
+
+    dmRole: '# Decision Maker Responsibilities',
+    dmRoleContent: `You are the team's decision maker. Other roles will request your decision when they encounter uncertainties.
+- If you have enough information, make the decision directly and @ the relevant role to execute
+- If you need more information, @ a specific role and request details
+- If the issue is beyond your capability or requires business judgment, @human to let a human decide
+- You can review other roles' work and provide feedback at any time`,
+
+    dmDevExtra: `
+- PM does not analyze code. Upon receiving requirements, directly ROUTE the raw requirements to an idle dev for technical analysis. After dev analyzes, PM splits tasks and assigns execution.
+- PM has autonomy for commit + push + tag. As long as changes have no significant regression impact (all tests pass), PM can decide to commit, push and tag without waiting for manual confirmation. Only when changes directly affect conversation interaction logic should manual review be required.`,
+
+    collabMode: '# Collaboration Mode',
+    collabModeContent: `This is a collaborative discussion team — no strict PM→Execute→Review→Test workflow.
+- Roles can freely discuss, consult each other, and raise different opinions
+- No strict "assign→execute→review" process — direct dialogue between roles is encouraged
+- When a role needs input from another, directly ROUTE to them and explain what's needed
+- The decision maker oversees the overall direction and final decisions, but daily discussions don't need to go through the decision maker
+- Each ROUTE should still include task and taskTitle fields for message grouping by feature`,
+
+    execGroupStatus: '# Execution Group Status',
+    parallelRules: '# Parallel Task Scheduling Rules',
+    parallelRulesContent: (maxGroup) => `You have ${maxGroup} dev groups that can work in parallel. When splitting tasks:
+1. Assign each sub-task a task-id (e.g., task-1) and taskTitle (e.g., "Implement login page")
+2. Prioritize assigning to **idle** dev groups — avoid sending new tasks to busy devs
+3. You can send **multiple ROUTE blocks** to assign tasks in parallel:`,
+    parallelExample: `4. Each dev will independently go through reviewer and tester review, then ROUTE back to you
+5. Wait until **all sub-tasks are completed** before providing a summary report
+6. **Every ROUTE must include task and taskTitle fields — they cannot be omitted. ROUTEs without a task field will prevent messages from being grouped by feature**`,
+
+    groupBusy: (task) => `busy:${task}`,
+    groupBusyShort: 'busy',
+    groupIdle: 'idle',
+    groupLabel: (g) => `Group${g}`,
+
+    workflowEnd: '# Workflow Termination',
+    workflowEndContent: (isDevTeam) =>
+      `The team's workflow has clear end conditions. When any of the following conditions are met, you should provide a summary and conclude the current workflow:
+${isDevTeam ? '1. **Code committed** - All code changes have been committed (if needed, let developer execute git commit)\n' : ''}${isDevTeam ? '2' : '1'}. **User input needed** - When encountering issues that require user decision, @human with a specific question and wait for reply
+${isDevTeam ? '3' : '2'}. **Task completed** - All tasks are done, provide a completion summary (list what was accomplished${isDevTeam ? ', which files were changed' : ''}, and any follow-up suggestions)
+
+Important: Do not loop endlessly between roles. When work is substantively complete, proactively provide a summary and conclude.`,
+
+    taskList: '# Task List',
+    taskListContent: `You can add a TASKS block in your reply to publish/update a task list, which the team interface will display automatically:`,
+    taskListNotes: `Notes:
+- One task per line, [ ] for to-do, [x] for completed
+- #taskId marks the corresponding feature ID (e.g., #task-1) for precise task completion tracking
+- @roleName marks the assignee (optional)
+- You can update the TASKS block in subsequent replies (mark completed tasks)
+- TASKS block does not need to be at the end of the reply — it can be placed anywhere`,
+    taskExample: `---TASKS---
+- [ ] Task description #task-1 @roleName
+- [x] Completed task #task-2 @roleName
+---END_TASKS---`,
+
+    featureRecordTitle: '# Feature Work Records',
+    featureRecordContent: `The system automatically manages \`context/features/{task-id}.md\` work record files:
+- Automatically created when PM assigns tasks (includes task-id, title, requirement description)
+- Work records are appended automatically on each ROUTE handoff (role name, time, summary)
+- Your received messages will include <task-context> tags containing the complete work record for that task
+
+The system also maintains these files (auto-updated, no manual management needed):
+- \`context/features/index.md\`: Index of all features (categorized as in-progress/completed) for quick project status overview
+- \`context/changelog.md\`: Change log of completed tasks, with summary appended when each task completes
+You don't need to manually create or update these files — focus on your core work.`,
+
+    devGroupBinding: '# Dev Group Binding',
+    devGroupBindingContent: (gi, revLabel, revName, testLabel, testName) =>
+      `You belong to dev group ${gi}. Your partners:
+- Reviewer: ${revLabel} (${revName})
+- Tester: ${testLabel} (${testName})
+
+After development is complete, send two ROUTE blocks simultaneously to ${revName} and ${testName}:`,
+    devGroupBindingNote: 'Both will work in parallel and independently ROUTE back to PM when done.',
+
+    implLoginPage: 'Implement login page',
+    implLoginSummary: 'Please implement the login page including form validation and API calls',
+    implRegisterPage: 'Implement registration page',
+    implRegisterSummary: 'Please implement the registration page including email verification',
+    reviewCode: 'Please review code changes',
+    testFeature: 'Please test the feature',
+
+    // buildInitialTask
+    projectStart: 'Project started!',
+    goalLabel: 'Goal',
+    firstRoleInstruction: 'You are the first role to start working. Analyze the goal and begin your work.\nWhen done, pass the result to the next appropriate role via a ROUTE block.',
+    availableRoles: 'Available roles in the team:',
+
+    // writeSharedClaudeMd
+    projectGoal: '# Project Goal',
+    projectCodePath: '# Project Code Path',
+    useAbsolutePath: 'Use this absolute path for all code operations.',
+    teamMembersTitle: '# Team Members',
+    noMembers: '_No members yet_',
+    workConventions: '# Work Conventions',
+    workConventionsContent: `- Write documentation output to context/ directory
+- Record important decisions in context/decisions.md
+- Use the project code path (absolute path) for code changes`,
+    stuckRules: '# Escalation Rules',
+    stuckRulesContent: `When you encounter the following situations, do not spin or retry repeatedly — immediately ROUTE to PM (pm) for coordination:
+1. Missing prerequisites (required files, directories, or code don't exist)
+2. Waiting for another role's output that hasn't arrived
+3. Task description is unclear or ambiguous, cannot determine the correct approach
+4. Encountered issues outside your role's scope
+5. Same operation has failed after 2 consecutive attempts
+When escalating, explain: what task you're working on, where you're stuck, and who you think should assist. PM will coordinate globally and decide whether to assign to the right person or adjust task order.`,
+    worktreeRules: '# Worktree Isolation Rules',
+    worktreeRulesContent: `- dev/reviewer/tester roles must work in their assigned worktrees — modifying code in the main project directory or main branch is strictly prohibited
+- Each role's CLAUDE.md specifies the "Code Work Directory" — that path is your worktree, all file operations must use that path
+- PM and designer don't use worktrees — they work read-only in the main project directory
+- Operating code in another dev group's worktree is strictly prohibited
+- After code passes review, dev creates a PR to merge into main branch
+- PM doesn't cherry-pick, only manages tags
+- Each new task/feature must create a new worktree based on the latest main branch to ensure development on latest code`,
+    featureRecordShared: `# Feature Work Records
+The system automatically manages \`context/features/{task-id}.md\` work record files:
+- Automatically created when PM assigns tasks via ROUTE (with task + taskTitle fields)
+- Work records are appended on each role ROUTE handoff
+- Task file content is auto-injected as context when a role receives a message
+Roles don't need to manually create or update these files.`,
+    sharedMemoryTitle: '# Shared Memory',
+    sharedMemoryDefault: '_Team-maintained shared knowledge, decisions, and information._',
+
+    // writeRoleClaudeMd
+    roleTitle: (label) => `# Role: ${label}`,
+    codeWorkDir: '# Code Work Directory',
+    codeWorkDirNote: 'Use this path for all code operations. Do not use the main project directory.',
+    personalMemory: '# Personal Memory',
+    personalMemoryDefault: '_Record important information, decisions, progress, and to-do items here._',
+
+    // ensureTaskFile
+    featureLabel: 'Feature',
+    statusPending: 'Pending',
+    assigneeLabel: 'Assignee',
+    createdAtLabel: 'Created',
+    requirementDesc: '## Requirement Description',
+    workRecord: '## Work Record',
+
+    // updateFeatureIndex
+    featureIndex: '# Feature Index',
+    lastUpdated: 'Last updated',
+    inProgressGroup: (n) => `## In Progress (${n})`,
+    completedGroup: (n) => `## Completed (${n})`,
+    colTaskId: 'task-id',
+    colTitle: 'Title',
+    colCreatedAt: 'Created',
+
+    // appendChangelog
+    changelogTitle: '# Changelog',
+    completedAt: 'Completed',
+    summaryLabel: 'Summary',
+    noSummary: '(No detailed summary)',
+  }
+};
+
+/**
+ * Get a localized string for the given session language.
+ * Falls back to 'zh-CN' for unknown languages.
+ */
+export function getMessages(language) {
+  return messages[language] || messages['zh-CN'];
+}

package/crew.js

@@ -19,6 +19,7 @@ import { homedir } from 'os';
 import { execFile as execFileCb } from 'child_process';
 import { promisify } from 'util';
 import ctx from './context.js';
+import { getMessages } from './crew-i18n.js';
 
 const execFile = promisify(execFileCb);
 
@@ -329,6 +330,7 @@ async function saveSessionMeta(session) {
     username: session.username,
     agentId: session.agentId || null,
     teamType: session.teamType || 'dev',
+    language: session.language || 'zh-CN',
     costUsd: session.costUsd,
     totalInputTokens: session.totalInputTokens,
     totalOutputTokens: session.totalOutputTokens,
@@ -714,6 +716,7 @@ export async function resumeCrewSession(msg) {
     username: username || meta.username,
     agentId: meta.agentId || ctx.CONFIG?.agentName || null,
     teamType: meta.teamType || 'dev',
+    language: meta.language || 'zh-CN',
     createdAt: meta.createdAt || Date.now()
   };
   crewSessions.set(sessionId, session);
@@ -801,6 +804,7 @@ export async function createCrewSession(msg) {
     roles: rawRoles = [],     // [{ name, displayName, icon, description, claudeMd, model, budget, isDecisionMaker, count }]
     maxRounds = 20,
     teamType = 'dev',
+    language = 'zh-CN',
     userId,
     username
   } = msg;
@@ -853,6 +857,7 @@ export async function createCrewSession(msg) {
     username,
     agentId: ctx.CONFIG?.agentName || null,
     teamType,
+    language,
     createdAt: Date.now()
   };
 
@@ -890,7 +895,7 @@ export async function createCrewSession(msg) {
     // 初始化共享区（角色目录 + CLAUDE.md）
     session.initProgress = 'roles';
     sendStatusUpdate(session);
-    await initSharedDir(sharedDir, goal, roles, projectDir, sharedKnowledge);
+    await initSharedDir(sharedDir, goal, roles, projectDir, sharedKnowledge, language);
 
     // 初始化 git worktrees
     const groupIndices = [...new Set(roles.filter(r => r.groupIndex > 0).map(r => r.groupIndex))];
@@ -904,7 +909,7 @@ export async function createCrewSession(msg) {
     for (const role of roles) {
       if (role.groupIndex > 0 && worktreeMap.has(role.groupIndex)) {
         role.workDir = worktreeMap.get(role.groupIndex);
-        await writeRoleClaudeMd(sharedDir, role);
+        await writeRoleClaudeMd(sharedDir, role, language);
       }
     }
 
@@ -923,7 +928,7 @@ export async function createCrewSession(msg) {
     if (goal && roles.length > 0 && session.status === 'running') {
       const firstRole = roles.find(r => r.name === 'pm') || roles[0];
       if (firstRole) {
-        const initialPrompt = buildInitialTask(goal, firstRole, roles);
+        const initialPrompt = buildInitialTask(goal, firstRole, roles, language);
         await dispatchToRole(session, firstRole.name, initialPrompt, 'system');
       }
     }
@@ -985,7 +990,7 @@ export async function addRoleToSession(msg) {
     }
 
     // 初始化角色目录（CLAUDE.md + memory.md）
-    await initRoleDir(session.sharedDir, r);
+    await initRoleDir(session.sharedDir, r, session.language || 'zh-CN');
 
     console.log(`[Crew] Role added: ${r.name} (${r.displayName}) to session ${sessionId}`);
 
@@ -1113,7 +1118,7 @@ export async function handleUpdateCrewSession(msg) {
  *       └── {roleName}/
  *           └── CLAUDE.md ← 角色定义 + 个人记忆
  */
-async function initSharedDir(sharedDir, goal, roles, projectDir, sharedKnowledge = '') {
+async function initSharedDir(sharedDir, goal, roles, projectDir, sharedKnowledge = '', language = 'zh-CN') {
   await fs.mkdir(sharedDir, { recursive: true });
   await fs.mkdir(join(sharedDir, 'context'), { recursive: true });
   await fs.mkdir(join(sharedDir, 'sessions'), { recursive: true });
@@ -1121,17 +1126,17 @@ async function initSharedDir(sharedDir, goal, roles, projectDir, sharedKnowledge
 
   // 初始化每个角色的目录
   for (const role of roles) {
-    await initRoleDir(sharedDir, role);
+    await initRoleDir(sharedDir, role, language);
   }
 
   // 生成 .crew/CLAUDE.md（共享级）
-  await writeSharedClaudeMd(sharedDir, goal, roles, projectDir, sharedKnowledge);
+  await writeSharedClaudeMd(sharedDir, goal, roles, projectDir, sharedKnowledge, language);
 }
 
 /**
  * 初始化角色目录: .crew/roles/{roleName}/CLAUDE.md
  */
-async function initRoleDir(sharedDir, role) {
+async function initRoleDir(sharedDir, role, language = 'zh-CN') {
   const roleDir = join(sharedDir, 'roles', role.name);
   await fs.mkdir(roleDir, { recursive: true });
 
@@ -1141,7 +1146,7 @@ async function initRoleDir(sharedDir, role) {
     await fs.access(claudeMdPath);
     // 已存在，不覆盖（保留角色自己写入的记忆）
   } catch {
-    await writeRoleClaudeMd(sharedDir, role);
+    await writeRoleClaudeMd(sharedDir, role, language);
   }
 }
 
@@ -1149,50 +1154,32 @@ async function initRoleDir(sharedDir, role) {
  * 写入 .crew/CLAUDE.md — 共享级（所有角色自动继承）
  * 记忆直接写在 CLAUDE.md 中，Claude Code 会自动加载
  */
-async function writeSharedClaudeMd(sharedDir, goal, roles, projectDir, sharedKnowledge = '') {
+async function writeSharedClaudeMd(sharedDir, goal, roles, projectDir, sharedKnowledge = '', language = 'zh-CN') {
+  const m = getMessages(language);
   const sharedMemoryContent = sharedKnowledge
-    ? `# 共享记忆\n${sharedKnowledge}\n`
-    : `# 共享记忆\n_团队共同维护，记录重要的共识、决策和信息。_\n`;
+    ? `${m.sharedMemoryTitle}\n${sharedKnowledge}\n`
+    : `${m.sharedMemoryTitle}\n${m.sharedMemoryDefault}\n`;
 
-  const claudeMd = `# 项目目标
+  const claudeMd = `${m.projectGoal}
 ${goal}
 
-# 项目代码路径
+${m.projectCodePath}
 ${projectDir}
-所有代码操作请使用此绝对路径。
-
-# 团队成员
-${roles.length > 0 ? roles.map(r => `- ${roleLabel(r)}(${r.name}): ${r.description}${r.isDecisionMaker ? ' (决策者)' : ''}`).join('\n') : '_暂无成员_'}
-
-# 工作约定
-- 文档产出写入 context/ 目录
-- 重要决策记录在 context/decisions.md
-- 代码修改使用项目代码路径的绝对路径
-
-# 卡住上报规则
-当你遇到以下情况时，不要自己空转或反复重试，立即 ROUTE 给 PM（pm）请求协调：
-1. 缺少前置依赖（如需要的文件、目录、代码不存在）
-2. 等待其他角色的产出但迟迟没有收到
-3. 任务描述不清楚或有歧义，无法判断正确做法
-4. 遇到超出自己职责范围的问题
-5. 连续尝试 2 次相同操作仍然失败
-上报时请说明：你在做什么任务、卡在哪里、你认为需要谁来协助。PM 会统筹全局，判断是分配给合适的人还是调整任务顺序。
-
-# Worktree 隔离规则
-- dev/reviewer/tester 角色必须在各自分配的 worktree 中工作，绝对禁止在项目主目录或 main 分支上修改代码
-- 每个角色的 CLAUDE.md 会标明「代码工作目录」，该路径就是你的 worktree，所有文件操作必须使用该路径
-- PM 和 designer 不使用 worktree，他们在项目主目录下以只读方式工作
-- 绝对禁止在其他开发组的 worktree 中操作代码
-- 代码完成并通过 review 后，dev 自己提 PR 合并到 main 分支
-- PM 不做 cherry-pick，只负责打 tag
-- 每次新任务/新 feature 必须基于最新的 main 分支创建新的 worktree，确保在最新代码上开发
-
-# Feature 工作记录
-系统自动管理 \`context/features/{task-id}.md\` 工作记录文件：
-- PM 通过 ROUTE 分配任务（带 task + taskTitle 字段）时自动创建
-- 每次角色 ROUTE 传递时自动追加工作记录
-- 角色收到消息时自动注入对应 task 文件内容作为上下文
-角色不需要手动创建或更新这些文件。
+${m.useAbsolutePath}
+
+${m.teamMembersTitle}
+${roles.length > 0 ? roles.map(r => `- ${roleLabel(r)}(${r.name}): ${r.description}${r.isDecisionMaker ? ` (${m.decisionMakerTag})` : ''}`).join('\n') : m.noMembers}
+
+${m.workConventions}
+${m.workConventionsContent}
+
+${m.stuckRules}
+${m.stuckRulesContent}
+
+${m.worktreeRules}
+${m.worktreeRulesContent}
+
+${m.featureRecordShared}
 
 ${sharedMemoryContent}`;
 
@@ -1203,25 +1190,26 @@ ${sharedMemoryContent}`;
  * 写入 .crew/roles/{roleName}/CLAUDE.md — 角色级
  * 记忆直接追加在此文件中，Claude Code 自动加载
  */
-async function writeRoleClaudeMd(sharedDir, role) {
+async function writeRoleClaudeMd(sharedDir, role, language = 'zh-CN') {
   const roleDir = join(sharedDir, 'roles', role.name);
+  const m = getMessages(language);
 
-  let claudeMd = `# 角色: ${roleLabel(role)}
+  let claudeMd = `${m.roleTitle(roleLabel(role))}
 ${role.claudeMd || role.description}
 `;
 
   // 有独立 worktree 的角色，覆盖代码工作目录
   if (role.workDir) {
     claudeMd += `
-# 代码工作目录
+${m.codeWorkDir}
 ${role.workDir}
-所有代码操作请使用此路径。不要使用项目主目录。
+${m.codeWorkDirNote}
 `;
   }
 
   claudeMd += `
-# 个人记忆
-_在这里记录重要的信息、决策、进展和待办事项。_
+${m.personalMemory}
+${m.personalMemoryDefault}
 `;
 
   await fs.writeFile(join(roleDir, 'CLAUDE.md'), claudeMd);
@@ -1232,7 +1220,7 @@ _在这里记录重要的信息、决策、进展和待办事项。_
  */
 async function updateSharedClaudeMd(session) {
   const roles = Array.from(session.roles.values());
-  await writeSharedClaudeMd(session.sharedDir, session.goal, roles, session.projectDir, session.sharedKnowledge);
+  await writeSharedClaudeMd(session.sharedDir, session.goal, roles, session.projectDir, session.sharedKnowledge, session.language || 'zh-CN');
 }
 
 // =====================================================================
@@ -1257,17 +1245,18 @@ async function ensureTaskFile(session, taskId, taskTitle, assignee, summary) {
 
   await fs.mkdir(featuresDir, { recursive: true });
 
+  const m = getMessages(session.language || 'zh-CN');
   const now = new Date().toISOString();
-  const content = `# Feature: ${taskTitle}
+  const content = `# ${m.featureLabel}: ${taskTitle}
 - task-id: ${taskId}
-- 状态: 待开发
-- 负责人: ${assignee}
-- 创建时间: ${now}
+- ${m.statusPending}
+- ${m.assigneeLabel}: ${assignee}
+- ${m.createdAtLabel}: ${now}
 
-## 需求描述
+${m.requirementDesc}
 ${summary}
 
-## 工作记录
+${m.workRecord}
 `;
 
   await fs.writeFile(filePath, content);
@@ -1340,6 +1329,7 @@ async function updateFeatureIndex(session) {
   const featuresDir = join(session.sharedDir, 'context', 'features');
   await fs.mkdir(featuresDir, { recursive: true });
 
+  const m = getMessages(session.language || 'zh-CN');
   const completed = session._completedTaskIds || new Set();
   const allFeatures = Array.from(session.features.values());
 
@@ -1349,23 +1339,24 @@ async function updateFeatureIndex(session) {
   const inProgress = allFeatures.filter(f => !completed.has(f.taskId));
   const done = allFeatures.filter(f => completed.has(f.taskId));
 
-  const now = new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
-  let content = `# Feature Index\n> 最后更新: ${now}\n`;
+  const locale = (session.language === 'en') ? 'en-US' : 'zh-CN';
+  const now = new Date().toLocaleString(locale, { timeZone: 'Asia/Shanghai' });
+  let content = `${m.featureIndex}\n> ${m.lastUpdated}: ${now}\n`;
 
-  content += `\n## 进行中 (${inProgress.length})\n`;
+  content += `\n${m.inProgressGroup(inProgress.length)}\n`;
   if (inProgress.length > 0) {
-    content += '| task-id | 标题 | 创建时间 |\n|---------|------|----------|\n';
+    content += `| ${m.colTaskId} | ${m.colTitle} | ${m.colCreatedAt} |\n|---------|------|----------|\n`;
     for (const f of inProgress) {
-      const date = f.createdAt ? new Date(f.createdAt).toLocaleDateString('zh-CN') : '-';
+      const date = f.createdAt ? new Date(f.createdAt).toLocaleDateString(locale) : '-';
       content += `| ${f.taskId} | ${f.taskTitle} | ${date} |\n`;
     }
   }
 
-  content += `\n## 已完成 (${done.length})\n`;
+  content += `\n${m.completedGroup(done.length)}\n`;
   if (done.length > 0) {
-    content += '| task-id | 标题 | 创建时间 |\n|---------|------|----------|\n';
+    content += `| ${m.colTaskId} | ${m.colTitle} | ${m.colCreatedAt} |\n|---------|------|----------|\n`;
     for (const f of done) {
-      const date = f.createdAt ? new Date(f.createdAt).toLocaleDateString('zh-CN') : '-';
+      const date = f.createdAt ? new Date(f.createdAt).toLocaleDateString(locale) : '-';
       content += `| ${f.taskId} | ${f.taskTitle} | ${date} |\n`;
     }
   }
@@ -1383,6 +1374,8 @@ async function appendChangelog(session, taskId, taskTitle) {
   await fs.mkdir(contextDir, { recursive: true });
   const changelogPath = join(contextDir, 'changelog.md');
 
+  const m = getMessages(session.language || 'zh-CN');
+
   // 读取 feature 文件提取最后一条工作记录作为摘要
   const taskContent = await readTaskFile(session, taskId);
   let summaryText = '';
@@ -1397,7 +1390,7 @@ async function appendChangelog(session, taskId, taskTitle) {
     }
   }
   if (!summaryText) {
-    summaryText = '（无详细摘要）';
+    summaryText = m.noSummary;
   }
 
   // 限制摘要长度
@@ -1405,8 +1398,9 @@ async function appendChangelog(session, taskId, taskTitle) {
     summaryText = summaryText.substring(0, 497) + '...';
   }
 
-  const now = new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
-  const entry = `\n## ${taskId}: ${taskTitle}\n- 完成时间: ${now}\n- 摘要: ${summaryText}\n`;
+  const locale = (session.language === 'en') ? 'en-US' : 'zh-CN';
+  const now = new Date().toLocaleString(locale, { timeZone: 'Asia/Shanghai' });
+  const entry = `\n## ${taskId}: ${taskTitle}\n- ${m.completedAt}: ${now}\n- ${m.summaryLabel}: ${summaryText}\n`;
 
   // 如果文件不存在，先写 header
   let exists = false;
@@ -1416,7 +1410,7 @@ async function appendChangelog(session, taskId, taskTitle) {
   } catch {}
 
   if (!exists) {
-    await fs.writeFile(changelogPath, `# Changelog\n${entry}`);
+    await fs.writeFile(changelogPath, `${m.changelogTitle}\n${entry}`);
   } else {
     await fs.appendFile(changelogPath, entry);
   }
@@ -1587,68 +1581,52 @@ function buildRoleSystemPrompt(role, session) {
     routeTargets = allRoles.filter(r => r.name !== role.name);
   }
 
-  let prompt = `# 团队协作
-你正在一个 AI 团队中工作。${session.goal ? `项目目标是: ${session.goal}` : '等待用户提出任务或问题。'}
+  const m = getMessages(session.language || 'zh-CN');
+
+  let prompt = `${m.teamCollab}
+${m.teamCollabIntro(session.goal)}
 
-团队成员:
-${allRoles.map(r => `- ${roleLabel(r)}: ${r.description}${r.isDecisionMaker ? ' (决策者)' : ''}`).join('\n')}`;
+${m.teamMembers}
+${allRoles.map(r => `- ${roleLabel(r)}: ${r.description}${r.isDecisionMaker ? ` (${m.decisionMakerTag})` : ''}`).join('\n')}`;
 
   const hasMultiInstance = allRoles.some(r => r.groupIndex > 0);
 
   if (routeTargets.length > 0) {
-    prompt += `\n\n# 路由规则
-当你完成当前任务并需要将结果传递给其他角色时，在你的回复最末尾添加一个 ROUTE 块：
+    prompt += `\n\n${m.routingRules}
+${m.routingIntro}
 
 \`\`\`
 ---ROUTE---
-to: <角色name>
-summary: <简要说明要传递什么>
+to: <roleName>
+summary: <brief description>
 ---END_ROUTE---
 \`\`\`
 
-可用的路由目标:
+${m.routeTargets}
 ${routeTargets.map(r => `- ${r.name}: ${roleLabel(r)} — ${r.description}`).join('\n')}
-- human: 人工（只在决策者也无法决定时使用）
+- human: ${m.humanTarget}
 
-注意：
-- 如果你的工作还没完成，不需要添加 ROUTE 块
-- 如果你遇到不确定的问题，@ 决策者 "${session.decisionMaker}"，而不是直接 @ human
-- 如果你是决策者且遇到需要人类判断的问题，才 @ human
-- 可以一次发多个 ROUTE 块来并行分配任务给不同角色
-- ROUTE 块必须在回复的最末尾
-- 当你的任务已完成且不需要其他角色继续时，ROUTE 回决策者 "${session.decisionMaker}" 做总结
-- 在正文中可用 @角色name 提及某个角色（如 @developer），但这不会触发路由，仅供阅读`;
+${m.routeNotes(session.decisionMaker)}`;
   }
 
   // 决策者额外 prompt
   if (role.isDecisionMaker) {
     const isDevTeam = session.teamType === 'dev';
 
-    prompt += `\n\n# 工具使用
-PM 可以使用所有工具，包括 Read、Grep、Glob、Bash、Edit、Write。${isDevTeam ? '代码文件的改动仍建议 ROUTE 给 developer 执行，但不做硬性限制。' : ''}`;
+    prompt += `\n\n${m.toolUsage}
+${m.toolUsageContent(isDevTeam)}`;
 
-    prompt += `\n\n# 决策者职责
-你是团队的决策者。其他角色遇到不确定的情况会请求你的决策。
-- 如果你有足够的信息做出决策，直接决定并 @相关角色执行
-- 如果你需要更多信息，@具体角色请求补充
-- 如果问题超出你的能力范围或需要业务判断，@human 请人类决定
-- 你可以随时审查其他角色的工作并给出反馈`;
+    prompt += `\n\n${m.dmRole}
+${m.dmRoleContent}`;
 
     if (isDevTeam) {
-      prompt += `
-- PM 不做代码分析。收到需求后直接将原始需求 ROUTE 给空闲 dev 做技术分析，dev 分析完返回 PM，PM 再拆分任务并直接分配执行。
-- PM 拥有 commit + push + tag 的自主权。只要修改没有大的 regression 影响（测试全通过），PM 可以自行决定 commit、push 和 tag，无需等待人工确认。只有当改动会直接影响对话交互逻辑时，才需要人工介入审核。`;
+      prompt += m.dmDevExtra;
     }
 
     // 非开发团队：注入讨论模式 prompt
     if (!isDevTeam) {
-      prompt += `\n\n# 协作模式
-这是一个协作讨论团队，不走严格的 PM→执行→审查→测试 工作流。
-- 角色之间可以自由讨论、相互请教、提出不同意见
-- 不需要严格的"分配→执行→审查"流程，鼓励角色之间直接对话
-- 当一个角色需要另一个角色的输入时，直接 ROUTE 给对方并说明需要什么
-- 决策者负责把控整体方向和最终决策，但日常讨论不需要经过决策者中转
-- 每次 ROUTE 仍建议包含 task 和 taskTitle 字段，用于消息按 feature 分组显示`;
+      prompt += `\n\n${m.collabMode}
+${m.collabModeContent}`;
     }
 
     // 多实例模式（仅开发团队使用）：注入开发组状态和调度规则
@@ -1662,80 +1640,55 @@ PM 可以使用所有工具，包括 Read、Grep、Glob、Bash、Edit、Write。
           const state = session.roleStates.get(r.name);
           const busy = state?.turnActive;
           const task = state?.currentTask;
-          if (busy && task) return `${r.name}(忙:${task.taskId} ${task.taskTitle})`;
-          if (busy) return `${r.name}(忙)`;
-          return `${r.name}(空闲)`;
+          if (busy && task) return `${r.name}(${m.groupBusy(task.taskId + ' ' + task.taskTitle)})`;
+          if (busy) return `${r.name}(${m.groupBusyShort})`;
+          return `${r.name}(${m.groupIdle})`;
         });
-        groupLines.push(`组${g}: ${memberStrs.join(' ')}`);
+        groupLines.push(`${m.groupLabel(g)}: ${memberStrs.join(' ')}`);
       }
 
-      prompt += `\n\n# 执行组状态
+      prompt += `\n\n${m.execGroupStatus}
 ${groupLines.join(' / ')}
 
-# 并行任务调度规则
-你有 ${maxGroup} 个开发组可以并行工作。拆分任务时：
-1. 每个子任务分配 task-id（如 task-1）和 taskTitle（如 "实现登录页面"）
-2. 优先分配给**空闲**的开发组，避免给忙碌的 dev 发新任务
-3. 一次可以发**多个 ROUTE 块**来并行分配任务：
+${m.parallelRules}
+${m.parallelRulesContent(maxGroup)}
 
 \`\`\`
 ---ROUTE---
 to: dev-1
 task: task-1
-taskTitle: 实现登录页面
-summary: 请实现登录页面，包括表单验证和API调用
+taskTitle: ${m.implLoginPage}
+summary: ${m.implLoginSummary}
 ---END_ROUTE---
 
 ---ROUTE---
 to: dev-2
 task: task-2
-taskTitle: 实现注册页面
-summary: 请实现注册页面，包括邮箱验证
+taskTitle: ${m.implRegisterPage}
+summary: ${m.implRegisterSummary}
 ---END_ROUTE---
 \`\`\`
 
-4. 每个 dev 完成后会独立经过 reviewer 和 tester 审核，最后 ROUTE 回你
-5. 等待**所有子任务完成**后再做汇总报告
-6. **每次 ROUTE 都必须包含 task 和 taskTitle 字段，不能省略。没有 task 字段的 ROUTE 会导致消息无法按 feature 分组显示**`;
+${m.parallelExample}`;
     }
 
     prompt += `\n
-# 工作流终结点
-团队的工作流有明确的结束条件。当以下任一条件满足时，你应该给出总结并结束当前工作流：
-${isDevTeam ? '1. **代码已提交** - 所有代码修改已经 commit（如需要，可让 developer 执行 git commit）\n' : ''}${isDevTeam ? '2' : '1'}. **需要用户输入** - 遇到需要用户决定的问题时，@human 提出具体问题，等待用户回复
-${isDevTeam ? '3' : '2'}. **任务完成** - 所有任务已完成，给出完成总结（列出完成了什么${isDevTeam ? '、变更了哪些文件' : ''}、还有什么后续建议）
+${m.workflowEnd}
+${m.workflowEndContent(isDevTeam)}
 
-重要：不要无限循环地在角色之间传递。当工作实质性完成时，主动给出总结并结束。
-
-# 任务清单
-你可以在回复中添加 TASKS 块来发布/更新任务清单，团队界面会自动展示：
+${m.taskList}
+${m.taskListContent}
 
 \`\`\`
----TASKS---
-- [ ] 任务描述 #task-1 @角色name
-- [x] 已完成的任务 #task-2 @角色name
----END_TASKS---
+${m.taskExample}
 \`\`\`
 
-注意：
-- 每行一个任务，[ ] 表示待办，[x] 表示已完成
-- #taskId 标注对应的 feature ID（如 #task-1），用于精确关联任务完成状态
-- @角色name 标注负责人（可选）
-- 后续回复中可更新 TASKS 块（标记完成的任务）
-- TASKS 块不需要在回复最末尾，可以放在任意位置`;
+${m.taskListNotes}`;
   }
 
   // Feature 进度文件说明（系统自动管理，告知角色即可）
-  prompt += `\n\n# Feature 工作记录
-系统会自动管理 \`context/features/{task-id}.md\` 工作记录文件：
-- PM 分配任务时自动创建文件（包含 task-id、标题、需求描述）
-- 每次 ROUTE 传递时自动追加工作记录（角色名、时间、summary）
-- 你收到的消息中会包含 <task-context> 标签，里面是该任务的完整工作记录
-
-系统还维护以下文件（自动更新，无需手动管理）：
-- \`context/features/index.md\`：所有 feature 的索引（进行中/已完成分类），快速查看项目状态
-- \`context/changelog.md\`：已完成任务的变更记录，每个任务完成时自动追加摘要
-你不需要手动创建或更新这些文件，专注于你的本职工作即可。`;
+  prompt += `\n\n${m.featureRecordTitle}
+${m.featureRecordContent}`;
 
   // 执行者角色的组绑定 prompt（count > 1 时）
   if (role.groupIndex > 0 && role.roleType === 'developer') {
@@ -1743,44 +1696,45 @@ ${isDevTeam ? '3' : '2'}. **任务完成** - 所有任务已完成，给出完
     const rev = allRoles.find(r => r.roleType === 'reviewer' && r.groupIndex === gi);
     const test = allRoles.find(r => r.roleType === 'tester' && r.groupIndex === gi);
     if (rev && test) {
-      prompt += `\n\n# 开发组绑定
-你属于开发组 ${gi}。你的搭档：
-- 审查者: ${roleLabel(rev)} (${rev.name})
-- 测试: ${roleLabel(test)} (${test.name})
-
-开发完成后，请同时发两个 ROUTE 块分别给 ${rev.name} 和 ${test.name}：
+      prompt += `\n\n${m.devGroupBinding}
+${m.devGroupBindingContent(gi, roleLabel(rev), rev.name, roleLabel(test), test.name)}
 
 \`\`\`
 ---ROUTE---
 to: ${rev.name}
-summary: 请审查代码变更
+summary: ${m.reviewCode}
 ---END_ROUTE---
 
 ---ROUTE---
 to: ${test.name}
-summary: 请测试功能
+summary: ${m.testFeature}
 ---END_ROUTE---
 \`\`\`
 
-两者会并行工作，各自完成后独立 ROUTE 回 PM。`;
+${m.devGroupBindingNote}`;
     }
   }
 
+  // Language instruction
+  if (session.language === 'en') {
+    prompt += `\n\n# Language
+Always respond in English. Use English for all explanations, comments, and communications with the user. Technical terms and code identifiers should remain in their original form.`;
+  } else {
+    prompt += `\n\n# Language
+Always respond in 中文. Use 中文 for all explanations, comments, and communications with the user. Technical terms and code identifiers should remain in their original form.`;
+  }
+
   return prompt;
 }
+function buildInitialTask(goal, firstRole, allRoles, language = 'zh-CN') {
+  const m = getMessages(language);
+  return `${m.projectStart}
 
-/**
- * 构建初始任务 prompt
- */
-function buildInitialTask(goal, firstRole, allRoles) {
-  return `项目启动！
-
-目标: ${goal}
+${m.goalLabel}: ${goal}
 
-你是第一个开始工作的角色。请分析目标，开始你的工作。
-完成后，通过 ROUTE 块将结果传递给下一个合适的角色。
+${m.firstRoleInstruction}
 
-团队中可用的角色:
+${m.availableRoles}
 ${allRoles.map(r => `- ${r.name}: ${roleLabel(r)} - ${r.description}`).join('\n')}`;
 }
 

package/package.json

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