metame-cli 1.5.3 → 1.5.5

package/scripts/daemon-agent-commands.js

@@ -13,6 +13,7 @@ function createAgentCommandHandler(deps) {
     sendBrowse,
     sendDirPicker,
     getSession,
+    getSessionForEngine,
     listRecentSessions,
     buildSessionCardElements,
     sessionLabel,
@@ -21,7 +22,11 @@ function createAgentCommandHandler(deps) {
     getSessionRecentContext,
     pendingBinds,
     pendingAgentFlows,
+    pendingTeamFlows,
     pendingActivations,
+    writeConfigSafe,
+    backupConfig,
+    execSync,
     doBindAgent,
     mergeAgentRole,
     agentTools,
@@ -36,6 +41,103 @@ function createAgentCommandHandler(deps) {
     return n === 'codex' ? 'codex' : getDefaultEngine();
   }
 
+  function inferStoredEngine(rawSession) {
+    if (!rawSession || typeof rawSession !== 'object') return getDefaultEngine();
+    if (rawSession.engine) return normalizeEngineName(rawSession.engine);
+    const slots = rawSession.engines && typeof rawSession.engines === 'object' ? rawSession.engines : null;
+    if (!slots) return getDefaultEngine();
+    const started = Object.entries(slots).find(([, slot]) => slot && slot.started);
+    if (started) return normalizeEngineName(started[0]);
+    const available = Object.keys(slots);
+    return available.length === 1 ? normalizeEngineName(available[0]) : getDefaultEngine();
+  }
+
+  function buildBoundSessionChatId(projectKey) {
+    const key = String(projectKey || '').trim();
+    return key ? `_bound_${key}` : '';
+  }
+
+  function getSessionRoute(chatId) {
+    const cfg = loadConfig();
+    const state = loadState();
+    const chatKey = String(chatId);
+    const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
+    const boundKey = agentMap[chatKey] || null;
+    const boundProj = boundKey && cfg.projects ? cfg.projects[boundKey] : null;
+    const stickyKey = state && state.team_sticky ? state.team_sticky[chatKey] : null;
+    const stickyMember = stickyKey && boundProj && Array.isArray(boundProj.team)
+      ? boundProj.team.find((m) => m && m.key === stickyKey)
+      : null;
+
+    if (stickyMember) {
+      return {
+        sessionChatId: `_agent_${stickyMember.key}`,
+        cwd: stickyMember.cwd ? normalizeCwd(stickyMember.cwd) : (boundProj && boundProj.cwd ? normalizeCwd(boundProj.cwd) : null),
+        engine: normalizeEngineName(stickyMember.engine || (boundProj && boundProj.engine)),
+      };
+    }
+
+    if (boundProj) {
+      return {
+        sessionChatId: buildBoundSessionChatId(boundKey),
+        cwd: boundProj.cwd ? normalizeCwd(boundProj.cwd) : null,
+        engine: normalizeEngineName(boundProj.engine),
+      };
+    }
+
+    const rawSession = getSession(chatId);
+    return {
+      sessionChatId: String(chatId),
+      cwd: rawSession && rawSession.cwd ? normalizeCwd(rawSession.cwd) : null,
+      engine: inferStoredEngine(rawSession),
+    };
+  }
+
+  function getCurrentEngine(chatId) {
+    return getSessionRoute(chatId).engine;
+  }
+
+  function getLogicalSessionForRoute(route) {
+    if (!route || !route.sessionChatId) return null;
+    if (typeof getSessionForEngine === 'function') {
+      const engineSession = getSessionForEngine(route.sessionChatId, route.engine);
+      if (engineSession && engineSession.id) return engineSession;
+    }
+    const raw = getSession(route.sessionChatId);
+    if (!raw) return null;
+    const slot = raw.engines && raw.engines[route.engine];
+    if (slot && slot.id) return { cwd: raw.cwd, engine: route.engine, ...slot };
+    if (raw.id) return { cwd: raw.cwd, engine: route.engine, id: raw.id, started: !!raw.started };
+    return null;
+  }
+
+  function buildResumeChoices({ recentSessions, currentLogical, curCwd, currentEngine, isLogicalRoute }) {
+    const items = [];
+    const seen = new Set();
+    if (
+      isLogicalRoute
+      && currentLogical
+      && currentLogical.id
+      && currentLogical.started
+    ) {
+      items.push({
+        sessionId: currentLogical.id,
+        projectPath: currentLogical.cwd || curCwd || HOME,
+        engine: currentEngine,
+        customTitle: '当前会话',
+        summary: '优先续接当前智能体会话',
+      });
+      seen.add(String(currentLogical.id));
+    }
+    for (const session of recentSessions || []) {
+      const key = String(session && session.sessionId || '');
+      if (!key || seen.has(key)) continue;
+      items.push(session);
+      seen.add(key);
+    }
+    return items;
+  }
+
   function inferEngineByCwd(cfg, cwd) {
     if (!cfg || !cfg.projects || !cwd) return null;
     const targetCwd = normalizeCwd(cwd);
@@ -48,18 +150,20 @@ function createAgentCommandHandler(deps) {
     return null;
   }
 
+  async function autoCreateSessionOnEmptyResume(bot, chatId, cwd, engine) {
+    const resolvedCwd = cwd ? normalizeCwd(cwd) : null;
+    if (!resolvedCwd || !fs.existsSync(resolvedCwd) || typeof attachOrCreateSession !== 'function') {
+      await bot.sendMessage(chatId, `No sessions found${resolvedCwd ? ' in ' + path.basename(resolvedCwd) : ''}. Try /new first.`);
+      return true;
+    }
+    attachOrCreateSession(getSessionRoute(chatId).sessionChatId, resolvedCwd, '', engine || getDefaultEngine());
+    await bot.sendMessage(chatId, `📁 ${path.basename(resolvedCwd)}\n✅ 已自动创建新会话`);
+    return true;
+  }
+
   // Pending activations have no TTL — they persist until consumed.
   // The creating chatId is stored to prevent self-activation.
 
-  function storePendingActivation(agentKey, agentName, cwd, createdByChatId) {
-    if (!pendingActivations) return;
-    pendingActivations.set(agentKey, {
-      agentKey, agentName, cwd,
-      createdByChatId: String(createdByChatId),
-      createdAt: Date.now(),
-    });
-  }
-
   // Returns the latest pending activation, excluding the creating chat
   function getLatestActivationForChat(chatId) {
     if (!pendingActivations || pendingActivations.size === 0) return null;
@@ -184,25 +288,6 @@ function createAgentCommandHandler(deps) {
     return { ok: true, data: legacy };
   }
 
-  async function createAgentViaUnifiedApi(chatId, name, dir, roleDesc, opts = {}) {
-    // Default: skip binding the creating chat — let the target group activate via /activate
-    const { skipChatBinding = true, engine = null } = opts;
-    if (agentTools && typeof agentTools.createNewWorkspaceAgent === 'function') {
-      const res = await agentTools.createNewWorkspaceAgent(name, dir, roleDesc, chatId, { skipChatBinding, engine });
-      if (res.ok && skipChatBinding && res.data && res.data.projectKey) {
-        storePendingActivation(res.data.projectKey, name, res.data.cwd, chatId);
-      }
-      return res;
-    }
-    const bound = await doBindAgent({ sendMessage: async () => {} }, chatId, name, dir);
-    if (!bound || bound.ok === false) {
-      return { ok: false, error: (bound && bound.error) || 'bind failed' };
-    }
-    const merged = await mergeAgentRole(dir, roleDesc);
-    if (merged.error) return { ok: false, error: merged.error };
-    return { ok: true, data: { cwd: dir, project: { name }, role: merged } };
-  }
-
   async function listAgentsViaUnifiedApi(chatId) {
     if (agentTools && typeof agentTools.listAllAgents === 'function') {
       return agentTools.listAllAgents(chatId);
@@ -244,47 +329,89 @@ function createAgentCommandHandler(deps) {
     const config = ctx.config || {};
     const text = ctx.text || '';
 
+    // /cancel — 取消任何挂起的向导流
+    if (text === '/cancel') {
+      let cancelled = false;
+      if (pendingTeamFlows && pendingTeamFlows.has(String(chatId))) {
+        pendingTeamFlows.delete(String(chatId));
+        cancelled = true;
+      }
+      if (pendingAgentFlows && pendingAgentFlows.has(String(chatId))) {
+        pendingAgentFlows.delete(String(chatId));
+        cancelled = true;
+      }
+      if (pendingBinds && pendingBinds.has(String(chatId))) {
+        pendingBinds.delete(String(chatId));
+        cancelled = true;
+      }
+      await bot.sendMessage(chatId, cancelled ? '✅ 已取消当前操作' : '没有进行中的操作');
+      return true;
+    }
+
     if (text === '/resume' || text.startsWith('/resume ')) {
       const arg = text.slice(7).trim();
 
       // Get current workdir to scope session list — prefer bound project cwd over session cwd
-      const cfgForResume = loadConfig();
-      const chatAgentMapForResume = { ...(cfgForResume.telegram ? cfgForResume.telegram.chat_agent_map : {}), ...(cfgForResume.feishu ? cfgForResume.feishu.chat_agent_map : {}) };
-      const boundKeyForResume = chatAgentMapForResume[String(chatId)];
-      const boundProjForResume = boundKeyForResume && cfgForResume.projects ? cfgForResume.projects[boundKeyForResume] : null;
-      const boundCwdForResume = (boundProjForResume && boundProjForResume.cwd) ? normalizeCwd(boundProjForResume.cwd) : null;
-      const curSession = getSession(chatId);
-      const curCwd = boundCwdForResume || (curSession ? curSession.cwd : null);
-      const recentSessions = listRecentSessions(5, curCwd);
+      const route = getSessionRoute(chatId);
+      const isLogicalRoute = route.sessionChatId !== String(chatId);
+      const currentLogical = getLogicalSessionForRoute(route);
+      const curSession = getSession(route.sessionChatId) || getSession(chatId);
+      const curCwd = route.cwd || (curSession ? curSession.cwd : null);
+      const currentEngine = getCurrentEngine(chatId);
+      const recentSessions = listRecentSessions(5, curCwd, currentEngine);
+      const resumeChoices = buildResumeChoices({
+        recentSessions,
+        currentLogical,
+        curCwd,
+        currentEngine,
+        isLogicalRoute,
+      });
 
       if (!arg) {
-        if (recentSessions.length === 0) {
-          await bot.sendMessage(chatId, `No sessions found${curCwd ? ' in ' + path.basename(curCwd) : ''}. Try /new first.`);
-          return true;
+        if (resumeChoices.length === 0) {
+          return autoCreateSessionOnEmptyResume(bot, chatId, curCwd, currentEngine);
         }
         const headerTitle = curCwd ? `📋 Sessions in ${path.basename(curCwd)}` : '📋 Recent Sessions';
-        if (bot.sendRawCard) {
-          await bot.sendRawCard(chatId, headerTitle, buildSessionCardElements(recentSessions));
-        } else if (bot.sendButtons) {
-          const buttons = recentSessions.map(s => {
-            return [{ text: sessionLabel(s), callback_data: `/resume ${s.sessionId}` }];
-          });
-          await bot.sendButtons(chatId, headerTitle, buttons);
-        } else {
-          const _tags2 = loadSessionTags();
-          let msg = `${headerTitle}\n\n`;
-          recentSessions.forEach((s, i) => {
-            msg += sessionRichLabel(s, i + 1, _tags2) + '\n';
-          });
-          await bot.sendMessage(chatId, msg);
+        try {
+          if (bot.sendRawCard) {
+            await bot.sendRawCard(chatId, headerTitle, buildSessionCardElements(resumeChoices));
+          } else {
+            throw new Error('raw-card-unavailable');
+          }
+        } catch {
+          try {
+            if (bot.sendButtons) {
+              const buttons = resumeChoices.map(s => {
+                return [{ text: sessionLabel(s), callback_data: `/resume ${s.sessionId}` }];
+              });
+              await bot.sendButtons(chatId, headerTitle, buttons);
+            } else {
+              throw new Error('buttons-unavailable');
+            }
+          } catch {
+            const _tags2 = loadSessionTags();
+            let msg = `${headerTitle}\n`;
+            msg += '\n';
+            resumeChoices.forEach((s, i) => {
+              msg += sessionRichLabel(s, i + 1, _tags2) + '\n';
+            });
+            await bot.sendMessage(chatId, msg);
+          }
         }
         return true;
       }
 
-      // Argument given -> match by name, then by session ID prefix
-      const allSessions = listRecentSessions(50);
+      // Argument given -> match current resume choices first (includes synthetic
+      // "当前会话" entry for logical routes), then fall back to global history.
+      const allSessions = listRecentSessions(50, null, currentEngine);
       const argLower = arg.toLowerCase();
-      let fullMatch = allSessions.find(s => s.customTitle && s.customTitle.toLowerCase() === argLower);
+      let fullMatch = resumeChoices.find(s => s.customTitle && s.customTitle.toLowerCase() === argLower);
+      if (!fullMatch) {
+        fullMatch = allSessions.find(s => s.customTitle && s.customTitle.toLowerCase() === argLower);
+      }
+      if (!fullMatch) {
+        fullMatch = resumeChoices.find(s => s.customTitle && s.customTitle.toLowerCase().includes(argLower));
+      }
       if (!fullMatch) {
         fullMatch = allSessions.find(s => s.customTitle && s.customTitle.toLowerCase().includes(argLower));
       }
@@ -292,35 +419,53 @@ function createAgentCommandHandler(deps) {
         fullMatch = recentSessions.find(s => s.sessionId.startsWith(arg))
           || allSessions.find(s => s.sessionId.startsWith(arg));
       }
+      if (!fullMatch) {
+        fullMatch = resumeChoices.find(s => s.sessionId.startsWith(arg));
+      }
       if (!fullMatch) {
         // keep historical behavior:
         // "/resume 看到的session信息太少了" should be treated as normal text
         return null;
       }
       const sessionId = fullMatch.sessionId;
-      const cwd = fullMatch.projectPath || (getSession(chatId) && getSession(chatId).cwd) || HOME;
+      const cwd = fullMatch.projectPath || (curSession && curSession.cwd) || HOME;
 
       const state2 = loadState();
       const cfgForEngine = loadConfig();
-      const engineByTargetCwd = inferEngineByCwd(cfgForEngine, cwd) || getDefaultEngine();
-      // For bound chats, write session to virtual chatId (_agent_{key}) so askClaude picks it up
-      const resumeChatAgentMap = { ...(cfgForEngine.telegram ? cfgForEngine.telegram.chat_agent_map : {}), ...(cfgForEngine.feishu ? cfgForEngine.feishu.chat_agent_map : {}) };
-      const resumeBoundKey = resumeChatAgentMap[String(chatId)];
-      const sessionKey = resumeBoundKey ? `_agent_${resumeBoundKey}` : String(chatId);
+      const sessionKey = route.sessionChatId;
       const existing = state2.sessions[sessionKey] || {};
+      const existingEngine = normalizeEngineName(
+        existing.engine
+        || (existing.engines && Object.entries(existing.engines).find(([, slot]) => slot && slot.started)?.[0])
+      );
+      const engineByTargetCwd = normalizeEngineName(fullMatch.engine)
+        || inferEngineByCwd(cfgForEngine, cwd)
+        || existingEngine;
+      const selectedLogicalCurrent = isLogicalRoute
+        && currentLogical
+        && currentLogical.id
+        && sessionId === currentLogical.id;
+      const targetSessionId = sessionId;
+      const targetCwd = cwd;
       const existingEngines = existing.engines || {};
       state2.sessions[sessionKey] = {
         ...existing,
-        cwd,
-        engines: { ...existingEngines, [engineByTargetCwd]: { id: sessionId, started: true } },
+        cwd: targetCwd,
+        id: targetSessionId,
+        started: true,
+        engine: engineByTargetCwd,
+        engines: { ...existingEngines, [engineByTargetCwd]: { id: targetSessionId, started: true } },
       };
       saveState(state2);
       const name = fullMatch.customTitle;
-      const label = name || (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) || sessionId.slice(0, 8);
+      const label = name || (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) || targetSessionId.slice(0, 8);
 
       // 读取最近对话片段，帮助确认是否切换到正确的 session
-      const recentCtx = getSessionRecentContext ? getSessionRecentContext(sessionId) : null;
+      const recentCtx = getSessionRecentContext ? getSessionRecentContext(targetSessionId) : null;
       let msg = `✅ 已切换: **${label}**\n📁 ${path.basename(cwd)}`;
+      if (selectedLogicalCurrent) {
+        msg += '\n\n已恢复当前智能体会话。';
+      }
       if (recentCtx) {
         if (recentCtx.lastUser) {
           const snippet = recentCtx.lastUser.replace(/\n/g, ' ').slice(0, 80);
@@ -341,6 +486,93 @@ function createAgentCommandHandler(deps) {
 
     // wizard state machine removed — use natural language to create agents
 
+    // /agent new 多步向导状态机（name/desc 步骤）
+    if (pendingAgentFlows) {
+      const flow = pendingAgentFlows.get(String(chatId));
+      if (flow && text && !text.startsWith('/')) {
+        if (flow.step === 'name') {
+          flow.name = text.trim();
+          flow.step = 'desc';
+          pendingAgentFlows.set(String(chatId), flow);
+          await bot.sendMessage(chatId, `好的，Agent 名称是「${flow.name}」\n\n步骤3/3：请描述这个 Agent 的角色和职责（用自然语言）：`);
+          return true;
+        }
+        if (flow.step === 'desc') {
+          pendingAgentFlows.delete(String(chatId));
+          const { dir, name, isClone, parentCwd } = flow;
+          const description = text.trim();
+          await bot.sendMessage(chatId, `⏳ 正在配置 Agent「${name}」，稍等...`);
+          try {
+            await doBindAgent(bot, chatId, name, dir);
+            const mergeResult = await mergeAgentRole(dir, description, isClone, parentCwd);
+            if (mergeResult && mergeResult.error) {
+              await bot.sendMessage(chatId, `⚠️ CLAUDE.md 合并失败: ${mergeResult.error}，其他配置已保存`);
+            } else if (mergeResult && mergeResult.symlinked) {
+              await bot.sendMessage(chatId, `🔗 CLAUDE.md 已链接到父 Agent（分身模式）\n✅ Agent「${name}」创建完成`);
+            } else if (mergeResult && mergeResult.created) {
+              await bot.sendMessage(chatId, `📝 已创建 CLAUDE.md\n✅ Agent「${name}」创建完成`);
+            } else {
+              await bot.sendMessage(chatId, `📝 已更新 CLAUDE.md\n✅ Agent「${name}」创建完成`);
+            }
+          } catch (e) {
+            await bot.sendMessage(chatId, `❌ 创建 Agent 失败: ${e.message}`);
+          }
+          return true;
+        }
+      }
+    }
+
+    // /agent new team 多步向导状态机
+    if (pendingTeamFlows) {
+      const teamFlow = pendingTeamFlows.get(String(chatId));
+      if (teamFlow && text && !text.startsWith('/')) {
+        if (teamFlow.step === 'name') {
+          teamFlow.name = text.trim();
+          teamFlow.step = 'members';
+          pendingTeamFlows.set(String(chatId), teamFlow);
+          await bot.sendMessage(chatId, `团队名称：「${teamFlow.name}」
+
+请输入成员列表，格式：
+名称:icon:颜色
+
+可用颜色：green, yellow, red, blue, purple, orange, pink, indigo
+
+示例：
+编剧:✍️:green, 审核:🔍:yellow, 推广:📢:red
+
+一行一个成员，或用逗号分隔多个`);
+          return true;
+        }
+
+        if (teamFlow.step === 'members') {
+          const validColors = ['green', 'yellow', 'red', 'blue', 'purple', 'orange', 'pink', 'indigo'];
+          const memberLines = text.split(/[,，\n]/).filter(l => l.trim());
+          const members = [];
+          for (const line of memberLines) {
+            const parts = line.trim().split(':');
+            const name = parts[0] && parts[0].trim();
+            const icon = (parts[1] && parts[1].trim()) || '🤖';
+            const rawColor = parts[2] && parts[2].trim().toLowerCase();
+            const color = validColors.includes(rawColor) ? rawColor : validColors[members.length % validColors.length];
+            if (name) {
+              members.push({ key: name, name: `${teamFlow.name} · ${name}`, icon, color, nicknames: [name] });
+            }
+          }
+          if (members.length === 0) {
+            await bot.sendMessage(chatId, '⚠️ 请至少添加一个成员，格式：名称:icon:颜色');
+            return true;
+          }
+          teamFlow.members = members;
+          teamFlow.step = 'cwd';
+          pendingTeamFlows.set(String(chatId), teamFlow);
+          const memberList = members.map(m => `${m.icon} ${m.name} (${m.color})`).join('\n');
+          await bot.sendMessage(chatId, `✅ 成员配置：\n\n${memberList}\n\n正在选择父目录...`);
+          await sendBrowse(bot, chatId, 'team-new', HOME, `为「${teamFlow.name}」选择父工作目录`);
+          return true;
+        }
+      }
+    }
+
     // /agent edit wait-input flow (kept for command compatibility)
     {
       const editFlow = getFreshFlow(String(chatId) + ':edit');
@@ -363,6 +595,41 @@ function createAgentCommandHandler(deps) {
       const agentParts = agentArg.split(/\s+/).filter(Boolean);
       const agentSub = agentParts[0] || ''; // bind / list / new / edit / reset / unbind / ''
 
+      // /agent new [team] — 创建新 Agent 或团队
+      if (agentSub === 'new') {
+        const secondArg = agentParts[1];
+        if (secondArg === 'team') {
+          if (!pendingTeamFlows) {
+            await bot.sendMessage(chatId, '❌ 团队向导暂不可用');
+            return true;
+          }
+          pendingTeamFlows.set(String(chatId), { step: 'name' });
+          await bot.sendMessage(chatId, `🏗️ **团队创建向导**
+
+请输入团队名称（如：短剧团队、销售团队）：
+
+输入 /cancel 可取消`);
+          return true;
+        }
+        // /agent new clone — 分身模式
+        const isClone = secondArg === 'clone';
+        let parentCwd = null;
+        if (isClone) {
+          const cfg = loadConfig();
+          const agentMap = {
+            ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}),
+            ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}),
+          };
+          const boundKey = agentMap[String(chatId)];
+          const boundProj = boundKey && cfg.projects && cfg.projects[boundKey];
+          if (boundProj && boundProj.cwd) parentCwd = normalizeCwd(boundProj.cwd);
+        }
+        pendingAgentFlows.set(String(chatId), { step: 'dir', isClone, parentCwd, __ts: Date.now() });
+        const hint = isClone ? `（${parentCwd ? '分身模式：将链接父 Agent 的 CLAUDE.md' : '⚠️ 当前群未绑定 Agent'})` : '';
+        await sendBrowse(bot, chatId, 'agent-new', HOME, `步骤1/3：选择 Agent 的工作目录${hint}`);
+        return true;
+      }
+
       // /agent bind <名称> [目录]
       if (agentSub === 'bind') {
         const bindName = agentParts[1];
@@ -644,6 +911,23 @@ function createAgentCommandHandler(deps) {
       return true;
     }
 
+    // /agent-dir <path>: /agent new 向导的目录选择回调（步骤1→步骤2）
+    if (text.startsWith('/agent-dir ')) {
+      const dirPath = expandPath(text.slice(11).trim());
+      const flow = pendingAgentFlows && pendingAgentFlows.get(String(chatId));
+      if (!flow || flow.step !== 'dir') {
+        await bot.sendMessage(chatId, '❌ 没有待完成的 /agent new，请重新发送 /agent new');
+        return true;
+      }
+      flow.dir = dirPath;
+      flow.step = 'name';
+      pendingAgentFlows.set(String(chatId), flow);
+      const displayPath = dirPath.replace(HOME, '~');
+      const cloneHint = flow.isClone ? '（分身模式）' : '';
+      await bot.sendMessage(chatId, `✓ 已选择目录：${displayPath}${cloneHint}\n\n步骤2/3：给这个 Agent 起个名字？`);
+      return true;
+    }
+
     // /agent-bind-dir <path>: internal callback for bind picker
     if (text.startsWith('/agent-bind-dir ')) {
       const dirPath = expandPath(text.slice(16).trim());
@@ -657,6 +941,90 @@ function createAgentCommandHandler(deps) {
       return true;
     }
 
+    // /agent-team-dir <path>: directory picker callback for team creation
+    if (text.startsWith('/agent-team-dir ')) {
+      const dirPath = expandPath(text.slice(16).trim());
+      const teamFlow = pendingTeamFlows && pendingTeamFlows.get(String(chatId));
+      if (!teamFlow || teamFlow.step !== 'cwd') {
+        await bot.sendMessage(chatId, '❌ 没有待完成的团队创建，请重新发送 /agent new team');
+        return true;
+      }
+      teamFlow.step = 'creating';
+      pendingTeamFlows.set(String(chatId), teamFlow);
+      await bot.sendMessage(chatId, `⏳ 正在创建团队「${teamFlow.name}」...`);
+
+      try {
+        const teamDir = path.join(dirPath, 'team');
+        if (!fs.existsSync(teamDir)) fs.mkdirSync(teamDir, { recursive: true });
+
+        const members = Array.isArray(teamFlow.members) ? teamFlow.members : [];
+        const results = [];
+        for (const member of members) {
+          const memberDir = path.join(teamDir, member.key);
+          if (!fs.existsSync(memberDir)) fs.mkdirSync(memberDir, { recursive: true });
+          const claudeMdPath = path.join(memberDir, 'CLAUDE.md');
+          if (!fs.existsSync(claudeMdPath)) {
+            fs.writeFileSync(claudeMdPath, `# ${member.name}\n\n（团队成员：${teamFlow.name}）\n`, 'utf8');
+          }
+          // Init git repo for checkpoint support
+          try {
+            if (execSync) execSync('git init -q', { cwd: memberDir, stdio: 'ignore' });
+          } catch { /* non-critical */ }
+          results.push(`✅ ${member.icon} ${member.key}: ${memberDir.replace(HOME, '~')}`);
+        }
+
+        // Register in daemon.yaml under parent project's team array
+        const cfg = loadConfig();
+        let parentProjectKey = null;
+        if (cfg.projects) {
+          for (const [projKey, proj] of Object.entries(cfg.projects)) {
+            if (normalizeCwd(proj.cwd || '') === normalizeCwd(dirPath)) {
+              parentProjectKey = projKey;
+              break;
+            }
+          }
+        }
+
+        if (parentProjectKey && cfg.projects[parentProjectKey]) {
+          const proj = cfg.projects[parentProjectKey];
+          if (!proj.team) proj.team = [];
+          for (const member of members) {
+            if (!proj.team.some(m => m.key === member.key)) {
+              proj.team.push({
+                key: member.key,
+                name: member.name,
+                icon: member.icon,
+                color: member.color,
+                cwd: path.join(teamDir, member.key),
+                nicknames: member.nicknames,
+              });
+            }
+          }
+          if (writeConfigSafe) writeConfigSafe(cfg);
+          if (backupConfig) backupConfig();
+        }
+
+        const memberList = members.map(m => `${m.icon} ${m.key}`).join('  |  ');
+        const yamlNote = parentProjectKey
+          ? `📝 已更新 daemon.yaml：${parentProjectKey}.team`
+          : '⚠️ 未找到父项目，请手动在 daemon.yaml 中注册 team 段';
+        await bot.sendMessage(chatId, `🎉 **团队创建完成！**
+
+**${teamFlow.name}**
+${memberList}
+
+📁 目录：${teamDir.replace(HOME, '~')}/
+${yamlNote}
+
+💡 发 \`/agent\` 可切换到成员对话`);
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ 创建失败: ${e.message}`);
+      }
+
+      pendingTeamFlows.delete(String(chatId));
+      return true;
+    }
+
     return false;
   }