@iamsamyiok/agents-chat 3.33.0 → 3.35.0

package/.env.example

@@ -24,3 +24,8 @@
 # AGENTS_CHAT_OPENCODE_CMD=
 # 单任务超时毫秒（默认 10 分钟）
 # AGENTS_CHAT_TIMEOUT_MS=600000
+# AI 组队生成超时（毫秒，默认 120000；真实内核生成整队提示词耗时较长）
+# AGENTS_CHAT_SUGGEST_TIMEOUT_MS=120000
+# AI 编排（卡牌控制台聊天编排）超时：对话（默认 120000）与生成清单（默认 180000，输出量大）
+# AGENTS_CHAT_PLANNER_CHAT_TIMEOUT_MS=120000
+# AGENTS_CHAT_PLANNER_PLAN_TIMEOUT_MS=180000

package/README.md

@@ -26,6 +26,8 @@ npm install -g opencode-ai
 | 能力 | 说明 |
 |---|---|
 | 群聊编排 | 直接输入需求，管家智能体拆解成阶段计划，调度子智能体并行执行，自动验收不合格返工 |
+| AI 组队 | 一句话描述需求，执行内核自动生成整套智能体团队（名称/图标/技能/提示词），预览后合并或替换应用 |
+| AI 编排 | 多任务编排页「🪄 AI 编排」聊天式编排：描述目标，AI 反问澄清后一键生成带依赖与并行的任务清单，编辑预览后导入看板 |
 | 批量任务 | 粘贴一段文本一次导入多条任务（`1. xxx` 每行一条），可拖拽排序、批量执行 |
 | 定时任务 | 行首写时间即定时（`2026-08-18 13:07 生成日报`），到点自动执行，停机错过的启动时补跑，可开机自启 |
 | Git 隔离 | 导入时勾选「Git 隔离执行」：每任务独立 worktree 分支互不污染，完成后逐文件看 diff、一键合并或丢弃 |
@@ -33,6 +35,7 @@ npm install -g opencode-ai
 | 完成通知 | 页面在后台弹系统通知；webhook 转发钉钉/飞书/自建中转 |
 | 单聊工作台 | 与 OpenCode 单体多轮续聊；任务链支持 `-` 接续上一会话、`//` 并行执行 |
 | 卡牌协作 | 每个智能体一张卡牌实时直播工作过程，可中途插话纠偏或委派转交 |
+| 三模式标签 | 左上角「👤 单聊 / 👥 群聊 / 🎛 编排」一键切换（编排控制台内嵌主界面），每个标签实时显示完成进度与未读绿点提醒 |
 
 ## 安装方式
 
@@ -84,7 +87,7 @@ OpenCode（推荐）/ Claude Code / Codex CLI / pi，页面右上角可切换。
 git clone https://github.com/iamsamyiok/agents-chat
 cd agents-chat && npm install
 AGENTS_CHAT_MOCK=1 npm start   # 演示模式开发，无需内核
-npm test                       # 66 个测试用例
+npm test                       # 92 个测试用例
 ```
 
 零运行时依赖，Node 原生模块实现（HTTP/SSE/存储均为自研轻量层）。

package/app/lib/planner.js

@@ -0,0 +1,248 @@
+// AI 智能编排：卡牌控制台的聊天式任务编排（多轮对话澄清 + 生成结构化清单）
+// 会话持久化于 <DATA>/planner/<sid>.json；内核调用复用 agent.runAgent（runAgentFn 可注入便于测试）
+const fs = require('fs');
+const path = require('path');
+const agentMod = require('./agent');
+const { extractJSONArray } = require('./teamgen');
+
+const ROOT = path.join(__dirname, '..');
+const DATA_DIR = process.env.AGENTS_CHAT_DATA || path.join(ROOT, '.data');
+const PLANNER_DIR = path.join(DATA_DIR, 'planner');
+
+const MSG_MAX = 4000;      // 单条消息长度上限
+const ROUNDS_MAX = 80;     // messages 条数上限（约 40 轮），超出裁最旧
+const PLAN_MIN = 2;
+const PLAN_MAX = 12;
+const CHAT_TIMEOUT_MS = Number(process.env.AGENTS_CHAT_PLANNER_CHAT_TIMEOUT_MS) > 0
+  ? Number(process.env.AGENTS_CHAT_PLANNER_CHAT_TIMEOUT_MS) : 120000;
+const PLAN_TIMEOUT_MS = Number(process.env.AGENTS_CHAT_PLANNER_PLAN_TIMEOUT_MS) > 0
+  ? Number(process.env.AGENTS_CHAT_PLANNER_PLAN_TIMEOUT_MS) : 180000;
+
+// 编排设计师人设：先澄清再拆解；任务模型对齐卡牌控制台（mode/deps/priority）
+const PLANNER_SYSTEM = [
+  '你是一位资深项目经理与任务编排设计师，帮助用户把目标拆解为可执行的多任务编排。',
+  '',
+  '【对话方式】',
+  '1. 用户描述目标后，若关键信息缺失（做什么、技术栈/工具、范围边界、期望产出），先提出 1-3 个具体的澄清问题，不要凭空编造',
+  '2. 信息足够时，简要确认你的理解（一两句话），并提示用户可以点「生成编排」按钮产出任务清单',
+  '3. 回复简洁务实，不输出与编排无关的长篇内容；语言跟随用户语言',
+  '',
+  '【任务模型（生成清单时遵守，对话中不必展开）】',
+  '- 每个任务：title（一句话标题）、content（完整可独立执行的任务描述，包含必要上下文，不写「继续上面」这类脱离清单后无法理解的话）',
+  '- mode：new=新进程独立执行 / continue=同会话续聊（同一件事分步骤、需要记住前一步成果时用，并依赖前一步）/ parallel=并行独立进程（互不依赖可同时跑）',
+  '- deps：依赖任务的序号数组（1 起始），任务只能等依赖完成后执行',
+  '- 拆解原则：先准备后执行再检查验收；有依赖关系的按顺序；独立可并行的标记 parallel；任务粒度适中，总数 2-12 个'
+].join('\n');
+
+// ---------- 会话存取 ----------
+
+function ensureDir() {
+  try { fs.mkdirSync(PLANNER_DIR, { recursive: true }); } catch { /* ignore */ }
+}
+
+function sidValid(sid) {
+  return /^pl-[a-z0-9-]+$/i.test(String(sid || ''));
+}
+
+function sessionPath(sid) {
+  return path.join(PLANNER_DIR, `${sid}.json`);
+}
+
+function readSession(sid) {
+  if (!sidValid(sid)) return null;
+  try {
+    const s = JSON.parse(fs.readFileSync(sessionPath(sid), 'utf8'));
+    if (!s || !Array.isArray(s.messages)) return null;
+    return s;
+  } catch { return null; }
+}
+
+function writeSession(s) {
+  ensureDir();
+  // 轮次上限：超出裁最旧（保留最近 ROUNDS_MAX 条）
+  if (s.messages.length > ROUNDS_MAX) s.messages = s.messages.slice(-ROUNDS_MAX);
+  s.updatedAt = new Date().toISOString();
+  fs.writeFileSync(sessionPath(s.sid), JSON.stringify(s, null, 1));
+}
+
+function createSession() {
+  const sid = `pl-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const s = { sid, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), messages: [] };
+  writeSession(s);
+  return s;
+}
+
+function latestSession() {
+  ensureDir();
+  let best = null;
+  for (const f of fs.readdirSync(PLANNER_DIR)) {
+    if (!f.endsWith('.json')) continue;
+    const s = readSession(f.slice(0, -5));
+    if (s && (!best || s.updatedAt > best.updatedAt)) best = s;
+  }
+  return best;
+}
+
+function deleteSession(sid) {
+  if (!sidValid(sid)) return false;
+  try { fs.unlinkSync(sessionPath(sid)); return true; } catch { return false; }
+}
+
+// 过期清理（随每日 prune 调用）：删除 updatedAt 早于 days 天前的会话
+function pruneStale(days) {
+  const keep = (Number(days) || 15) * 86400000;
+  const cut = Date.now() - keep;
+  let n = 0;
+  try {
+    ensureDir();
+    for (const f of fs.readdirSync(PLANNER_DIR)) {
+      if (!f.endsWith('.json')) continue;
+      const p = path.join(PLANNER_DIR, f);
+      try {
+        const st = fs.statSync(p);
+        if (st.mtimeMs < cut) { fs.unlinkSync(p); n++; }
+      } catch { /* ignore */ }
+    }
+  } catch { /* ignore */ }
+  return n;
+}
+
+// ---------- 内核调用（与 teamgen.suggestTeam 同模式：超时 stopScope + done 回调聚合） ----------
+
+function runOnce(prompt, timeout, scope) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let content = '';
+    let runError = '';
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      runError = `生成超时（${Math.round(timeout / 1000)} 秒），请稍后重试`;
+      try { agentMod.stopScope(scope); } catch { /* ignore */ }
+      resolve({ content, error: runError });
+    }, timeout);
+    try {
+      agentMod.runAgent(
+        { id: scope, name: scope, model: '', behavior: 'echo', systemPrompt: '' },
+        prompt,
+        (chunk) => {
+          if (chunk && chunk.content) content += chunk.content;
+          if (chunk && chunk.error) runError = runError || String(chunk.error);
+          if (chunk && chunk.done && !settled) { settled = true; clearTimeout(timer); resolve({ content, error: runError }); }
+        },
+        scope
+      );
+    } catch (e) {
+      if (!settled) { settled = true; clearTimeout(timer); resolve({ content: '', error: `调用内核失败：${e.message}` }); }
+    }
+  });
+}
+
+function historyText(messages) {
+  return messages.map(m => `${m.role === 'user' ? '用户' : '助手'}：${m.content}`).join('\n\n');
+}
+
+// 多轮对话：追加用户消息 → 内核回复（携带 system + 全部历史）→ 落盘
+async function chat({ sid, message, runAgentFn, timeoutMs }) {
+  const s = sid ? readSession(sid) : null;
+  const sess = s || createSession();
+  if (runAgentFn) {
+    // 测试注入：替换 agentMod.runAgent
+    const orig = agentMod.runAgent;
+    agentMod.runAgent = runAgentFn;
+    try { return await doChat(sess, message, timeoutMs); }
+    finally { agentMod.runAgent = orig; }
+  }
+  return doChat(sess, message, timeoutMs);
+}
+
+async function doChat(sess, message, timeoutMs) {
+  const text = String(message || '').trim().slice(0, MSG_MAX);
+  const timeout = Number(timeoutMs) > 0 ? Number(timeoutMs) : CHAT_TIMEOUT_MS;
+  sess.messages.push({ role: 'user', content: text });
+  const prompt = `${PLANNER_SYSTEM}\n\n【对话记录】\n${historyText(sess.messages)}\n\n请以助手身份回复最后一条用户消息。`;
+  const r = await runOnce(prompt, timeout, 'planner-chat');
+  if (r.error) {
+    sess.messages.pop(); // 失败不污染历史（用户可重发）
+    return { sid: sess.sid, reply: '', error: r.error };
+  }
+  const reply = String(r.content || '').trim().slice(0, MSG_MAX * 2);
+  sess.messages.push({ role: 'assistant', content: reply });
+  writeSession(sess);
+  return { sid: sess.sid, reply };
+}
+
+// 生成编排清单：以历史为上下文追加生成指令 → 容错解析 → cleanPlan 清洗
+async function plan({ sid, runAgentFn, timeoutMs }) {
+  const sess = readSession(sid);
+  if (!sess) return { error: '编排会话不存在，请先发送一条消息' };
+  if (!sess.messages.some(m => m.role === 'user')) return { error: '会话为空，请先描述你的目标' };
+  if (runAgentFn) {
+    const orig = agentMod.runAgent;
+    agentMod.runAgent = runAgentFn;
+    try { return await doPlan(sess, timeoutMs); }
+    finally { agentMod.runAgent = orig; }
+  }
+  return doPlan(sess, timeoutMs);
+}
+
+async function doPlan(sess, timeoutMs) {
+  const timeout = Number(timeoutMs) > 0 ? Number(timeoutMs) : PLAN_TIMEOUT_MS;
+  const instruct = [
+    '基于以上对话内容，生成最终任务编排清单。',
+    '只输出一个 JSON 数组（2-12 项），不要输出其他文字或代码块标记。每项字段：',
+    '- title：一句话标题（30 字内）',
+    '- content：完整可独立执行的任务描述（包含必要上下文与期望产出）',
+    '- mode："new" | "continue" | "parallel"',
+    '- deps：依赖任务序号数组（1 起始，引用清单内其他任务，不含自身）；mode 为 continue 时依赖其续聊的前一步',
+    '同会话续聊（continue）用于同一件事分步推进；互不依赖的可并行任务用 parallel 且 deps 为空。'
+  ].join('\n');
+  const prompt = `${PLANNER_SYSTEM}\n\n【对话记录】\n${historyText(sess.messages)}\n\n【当前指令】\n${instruct}`;
+  const r = await runOnce(prompt, timeout, 'planner-plan');
+  if (r.error) return { error: r.error };
+  const parsed = extractJSONArray(r.content);
+  if (!parsed) return { error: '生成结果无法解析为任务清单，请补充信息后重试' };
+  const items = cleanPlan(parsed);
+  if (items.length < PLAN_MIN) {
+    return { error: `生成结果只有 ${items.length} 个任务，至少需要 ${PLAN_MIN} 个，请补充更多细节后重试` };
+  }
+  // 生成记录落盘（便于继续对话时 LLM 知道已产出过清单；只存摘要防膨胀）
+  sess.messages.push({ role: 'user', content: '【生成编排清单】' });
+  sess.messages.push({ role: 'assistant', content: `已生成 ${items.length} 个任务的编排清单：\n${items.map((t, i) => `${i + 1}. ${t.title}（${t.mode}${t.deps.length ? '，依赖 ' + t.deps.join('/') : ''}）`).join('\n')}\n如需调整请直接说明。` });
+  writeSession(sess);
+  return { plan: items };
+}
+
+// 清洗：字段归一 + deps 校验（1 起始序号、去自引用/悬空/重复）+ 数量截断
+function cleanPlan(arr) {
+  if (!Array.isArray(arr)) return [];
+  const raw = arr.filter(x => x && typeof x === 'object');
+  const len = Math.min(raw.length, PLAN_MAX);
+  const items = [];
+  for (let i = 0; i < len; i++) {
+    const a = raw[i];
+    let content = String(a.content || '').trim().slice(0, 8000);
+    let title = String(a.title || '').trim().slice(0, 100);
+    if (!title) title = content.slice(0, 40) || `任务${i + 1}`;
+    let mode = String(a.mode || 'new').toLowerCase();
+    if (!['new', 'continue', 'parallel'].includes(mode)) mode = 'new';
+    let deps = Array.isArray(a.deps) ? a.deps : [];
+    deps = [...new Set(deps.map(d => parseInt(d, 10)).filter(Number.isInteger))]
+      .map(d => d - 1)                       // 转 0 起始
+      .filter(d => d >= 0 && d < len && d !== i) // 去悬空与自引用
+      .sort((x, y) => x - y)
+      .map(d => d + 1);                      // 回 1 起始
+    // continue 无有效链首（依赖为空）时退化为 new：续聊必须有前序会话
+    if (mode === 'continue' && deps.length === 0) mode = 'new';
+    if (!content) content = title;
+    items.push({ title, content, mode, deps });
+  }
+  return items;
+}
+
+module.exports = {
+  PLANNER_DIR, MSG_MAX, ROUNDS_MAX, PLAN_MIN, PLAN_MAX,
+  PLANNER_SYSTEM,
+  readSession, createSession, latestSession, deleteSession, pruneStale,
+  chat, plan, cleanPlan
+};

package/app/lib/teamgen.js

@@ -0,0 +1,143 @@
+// AI 智能组队：由执行内核根据用户需求生成子智能体团队配置
+// 纯函数模块（buildPrompt/extractTeamJSON/cleanSuggestedTeam）可独立单测；
+// suggestTeam 注入 runAgentFn 便于测试内核交互链路
+const agentMod = require('./agent');
+
+const LIMITS = { name: 20, icon: 8, desc: 100, systemPrompt: 8000 };
+const TEAM_MIN = 2;
+const TEAM_MAX = 6;
+const REQ_MAX = 2000;
+const SUGGEST_TIMEOUT_MS = Number(process.env.AGENTS_CHAT_SUGGEST_TIMEOUT_MS) > 0
+  ? Number(process.env.AGENTS_CHAT_SUGGEST_TIMEOUT_MS)
+  : 120000; // 真实内核生成整队提示词输出量大，60s 偏紧；.env 可覆盖
+
+// 结构化生成提示词：要求内核输出纯 JSON 数组（容错解析见 extractTeamJSON）
+function buildPrompt(requirements, existingNames) {
+  const avoid = (Array.isArray(existingNames) ? existingNames : [])
+    .map(n => String(n || '').trim()).filter(Boolean);
+  return [
+    '你是一位资深多智能体系统团队设计师。请根据用户需求，设计一支协作完成该需求的智能体团队。',
+    '',
+    '【用户需求】',
+    String(requirements || '').trim(),
+    '',
+    '【输出要求】只输出一个 JSON 数组，不要输出任何其他文字、解释或 markdown 代码块标记。数组包含 2 到 6 个对象，每个对象字段：',
+    '- name：智能体名称，简短（不超过 8 个字），团队内不得重名',
+    '- icon：单个 emoji 图标',
+    '- desc：一句话技能说明（不超过 50 字），明确该智能体的能力边界，供调度者据此分派任务',
+    '- systemPrompt：自定义提示词，包含角色定位、专业技能与输出要求，100 到 300 字，具体可执行',
+    '',
+    avoid.length ? `【命名避让】以下名称已被现有智能体占用，生成的 name 不得与之重复：${avoid.join('、')}` : '',
+    '',
+    '【设计原则】',
+    '1. 按需求拆解出真正需要的分工，每个智能体职责单一且清晰，避免出现职责重叠的成员',
+    '2. 语言与用户需求语言一致（用户用中文则全部用中文）',
+    '3. systemPrompt 要具体可执行，写清楚该角色拿到任务后应该怎么做、输出什么格式的成果',
+    '4. 若需求较简单，团队从简（2 到 3 个）；需求复杂才增加分工'
+  ].filter(line => line !== '').join('\n');
+}
+
+// 通用容错提取 JSON 数组（planner 等模块共享）：裸数组 → ```json 代码块 → 首个 [ 到最后一个 ] 的子串
+function extractJSONArray(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return null;
+  // 1. 整体就是合法 JSON
+  try { const v = JSON.parse(raw); if (Array.isArray(v)) return v; } catch { /* 继续尝试 */ }
+  // 2. markdown 代码块（```json ... ``` 或 ``` ... ```）
+  const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence) {
+    try { const v = JSON.parse(fence[1].trim()); if (Array.isArray(v)) return v; } catch { /* 继续尝试 */ }
+  }
+  // 3. 首个 [ 到最后一个 ] 之间（容忍前后杂文；字符串中含 ] 不影响，因为取最后一个 ]）
+  const start = raw.indexOf('[');
+  const end = raw.lastIndexOf(']');
+  if (start >= 0 && end > start) {
+    try { const v = JSON.parse(raw.slice(start, end + 1)); if (Array.isArray(v)) return v; } catch { /* 放弃 */ }
+  }
+  return null;
+}
+
+// 兼容保留：团队配置提取（实现转用通用函数）
+function extractTeamJSON(text) {
+  return extractJSONArray(text);
+}
+
+// 清洗生成结果：字段类型归一 + 长度截断 + 空名补名 + 重名后缀 + 数量上限
+// existingNames：现有智能体名（含管家），重名自动加序号，保证 @ 点名无歧义
+function cleanSuggestedTeam(arr, existingNames) {
+  if (!Array.isArray(arr)) return [];
+  const names = new Set(['管家', 'butler']);
+  for (const n of existingNames || []) {
+    const s = String(n || '').trim();
+    if (s) names.add(s);
+  }
+  const clean = [];
+  for (const a of arr) {
+    if (!a || typeof a !== 'object') continue;
+    let name = String(a.name || '').replace(/\s+/g, '').slice(0, LIMITS.name);
+    if (!name) name = `智能体${clean.length + 1}`;
+    let final = name;
+    let i = 2;
+    while (names.has(final)) final = `${name}${i++}`;
+    names.add(final);
+    clean.push({
+      name: final,
+      icon: String(a.icon || '').trim().slice(0, LIMITS.icon),
+      desc: String(a.desc || '').slice(0, LIMITS.desc),
+      systemPrompt: String(a.systemPrompt || '').slice(0, LIMITS.systemPrompt)
+    });
+    if (clean.length >= TEAM_MAX) break;
+  }
+  return clean;
+}
+
+// 完整生成链路：调内核一次 → 容错解析 → 清洗 → 数量校验
+// 返回 { success, agents, error }；任何失败都不影响现有配置（调用方不落盘）
+async function suggestTeam({ requirements, existingNames, runAgentFn, timeoutMs }) {
+  const run = runAgentFn || agentMod.runAgent;
+  const timeout = Number(timeoutMs) > 0 ? Number(timeoutMs) : SUGGEST_TIMEOUT_MS;
+  const scope = 'teamgen';
+  const prompt = buildPrompt(requirements, existingNames);
+
+  let settled = false;
+  let content = '';
+  let runError = '';
+  const done = new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      runError = `生成超时（${Math.round(timeout / 1000)} 秒），请稍后重试或简化需求描述`;
+      try { agentMod.stopScope(scope); } catch { /* ignore */ }
+      resolve();
+    }, timeout);
+    try {
+      run(
+        { id: scope, name: scope, model: '', behavior: 'echo', systemPrompt: '' },
+        prompt,
+        (chunk) => {
+          if (chunk && chunk.content) content += chunk.content;
+          if (chunk && chunk.error) runError = runError || String(chunk.error);
+          if (chunk && chunk.done && !settled) { settled = true; clearTimeout(timer); resolve(); }
+        },
+        scope
+      );
+    } catch (e) {
+      if (!settled) { settled = true; clearTimeout(timer); runError = `调用内核失败：${e.message}`; resolve(); }
+    }
+  });
+  await done;
+
+  if (runError) return { success: false, agents: [], error: runError };
+
+  const parsed = extractTeamJSON(content);
+  if (!parsed) {
+    return { success: false, agents: [], error: '生成结果无法解析为团队配置，请换个说法重试（例如补充更多分工细节）' };
+  }
+  const agents = cleanSuggestedTeam(parsed, existingNames);
+  if (agents.length < TEAM_MIN) {
+    return { success: false, agents: [], error: `生成结果只有 ${agents.length} 个智能体，至少需要 ${TEAM_MIN} 个，请补充更多分工细节后重试` };
+  }
+  return { success: true, agents };
+}
+
+module.exports = { buildPrompt, extractTeamJSON, extractJSONArray, cleanSuggestedTeam, suggestTeam, LIMITS, TEAM_MIN, TEAM_MAX, REQ_MAX };

package/app/public/cards.html

@@ -100,6 +100,30 @@
   .empty{color:var(--dim);font-size:12px;text-align:center;padding:18px 0}
   .mask{position:fixed;inset:0;background:rgba(0,0,0,.45);display:none;align-items:center;justify-content:center;z-index:50;backdrop-filter:blur(3px);-webkit-backdrop-filter:blur(3px)}
   .mask.show{display:flex;animation:fade-in .18s ease}
+  /* ---------- AI 编排聊天抽屉 ---------- */
+  #plDrawer{position:fixed;top:0;right:0;bottom:0;width:min(430px,100vw);background:var(--panel);border-left:1px solid var(--line);box-shadow:var(--shadow);z-index:55;display:none;flex-direction:column;transform:translateX(100%);transition:transform .22s cubic-bezier(.2,.7,.3,1)}
+  #plDrawer.open{display:flex;transform:translateX(0)}
+  .pl-head{display:flex;align-items:center;gap:8px;padding:12px 14px;border-bottom:1px solid var(--line);font-size:14px}
+  .pl-head .btn{padding:4px 10px;font-size:12px}
+  .pl-banner{margin:10px 14px 0;padding:9px 12px;border-radius:9px;font-size:12.5px;line-height:1.7;background:#fff7e6;border:1px solid #ffe58f;color:#614700;white-space:pre-wrap}
+  .pl-msgs{flex:1;overflow-y:auto;padding:12px 14px;display:flex;flex-direction:column;gap:10px}
+  .pl-bubble{max-width:88%;padding:9px 12px;border-radius:12px;font-size:13px;line-height:1.7;white-space:pre-wrap;word-break:break-word}
+  .pl-user{align-self:flex-end;background:var(--acc,#10aefa);color:#fff;border-bottom-right-radius:4px}
+  .pl-ai{align-self:flex-start;background:#f1f3f7;border:1px solid var(--line);border-bottom-left-radius:4px}
+  .pl-ai.err{background:#fff1f0;border-color:#ffccc7;color:#c0392b}
+  .pl-thinking{align-self:flex-start;color:var(--dim);font-size:12px;padding:4px 2px}
+  .pl-plan{border-top:1px dashed var(--line);padding:10px 14px;max-height:44vh;overflow-y:auto;background:#fafbfc}
+  .pl-plan h4{margin:0 0 8px;font-size:12.5px;color:var(--acc,#10aefa)}
+  .pl-task{display:flex;gap:6px;align-items:center;margin-bottom:6px}
+  .pl-task .no{font-size:11px;color:var(--dim);width:20px;flex:none;text-align:right}
+  .pl-task input{padding:5px 8px;font-size:12.5px}
+  .pl-task .t-title{flex:2.2}
+  .pl-task select,.pl-task .t-deps{width:86px;flex:none;padding:5px 6px;font-size:12px}
+  .pl-plan .foot{display:flex;gap:8px;margin-top:10px;flex-wrap:wrap}
+  .pl-input{display:flex;gap:8px;padding:10px 14px 4px;border-top:1px solid var(--line)}
+  .pl-input textarea{min-height:64px;flex:1}
+  .pl-tools{display:flex;gap:8px;padding:8px 14px 12px}
+  .pl-tools .btn{padding:5px 12px;font-size:12.5px}
   @keyframes fade-in{from{opacity:0}to{opacity:1}}
   @keyframes modal-in{from{opacity:0;transform:translateY(14px) scale(.985)}to{opacity:1;transform:none}}
   .modal{background:var(--panel);border:1px solid var(--line);border-radius:14px;width:min(680px,94vw);max-height:90vh;overflow:auto;padding:20px;box-shadow:var(--shadow);animation:modal-in .24s cubic-bezier(.2,.7,.3,1)}
@@ -236,8 +260,9 @@
       <option>1</option><option>2</option><option>3</option><option>4</option><option>5</option><option>6</option><option>7</option><option>8</option>
     </select>
   </div>
-  <button class="btn" id="btnNew">＋ 新建任务</button>
-  <button class="btn primary" id="btnRun" title="按依赖与优先级调度全部待执行任务">▶ 开始编排</button>
+   <button class="btn" id="btnNew">＋ 新建任务</button>
+   <button class="btn" id="btnPlanner" title="与 AI 聊天式编排：描述目标，AI 澄清后一键生成任务编排">🪄 AI 编排</button>
+   <button class="btn primary" id="btnRun" title="按依赖与优先级调度全部待执行任务">▶ 开始编排</button>
   <button class="btn danger" id="btnStop" disabled title="停止编排：进行中的任务复位为待执行（不影响追加聊天），未开始的任务保留">⏹ 停止</button>
   <button class="btn" id="btnClear">清空</button>
   <button class="btn" id="btnHelp" title="多任务编排使用帮助">❓ 帮助</button>
@@ -341,6 +366,28 @@
   </div>
 </div>
 
+<!-- AI 编排聊天抽屉 -->
+<div id="plDrawer">
+  <div class="pl-head">
+    <b>🪄 AI 编排</b>
+    <span style="flex:1"></span>
+    <button class="btn" id="plNew" title="开启全新编排会话（当前会话保留在历史中可随时删）">🆕 新会话</button>
+    <button class="btn" id="plClose" title="收起抽屉">✕</button>
+  </div>
+  <div class="pl-banner" id="plBanner" style="display:none"></div>
+  <div class="pl-msgs" id="plMsgs"></div>
+  <div class="pl-plan" id="plPlanBox" style="display:none"></div>
+  <div class="pl-input">
+    <textarea id="plInput" placeholder="描述你的目标，如：给项目做一轮完整的发布前检查，生成清单后我来看"></textarea>
+    <button class="btn primary" id="plSend">发送</button>
+  </div>
+  <div class="pl-tools">
+    <button class="btn" id="plPlanBtn" title="基于当前对话生成任务编排清单（可编辑后导入看板）">📝 生成编排</button>
+    <span style="flex:1"></span>
+    <button class="btn danger" id="plDel" title="删除当前编排会话">🗑 删会话</button>
+  </div>
+</div>
+
 <!-- 垃圾桶 -->
 <!-- 使用帮助 -->
 <div class="mask" id="helpMask">
@@ -661,6 +708,140 @@ function depCycle(id, deps){
   return false;
 }
 $('#btnNew').onclick=()=>openEdit(null);
+
+// ---------- AI 智能编排：聊天抽屉（描述目标 → 澄清 → 生成清单 → 导入看板） ----------
+let plSid = '';        // 当前编排会话 id
+let plBusy = false;    // 内核调用进行中（发送/生成互斥）
+let plDraft = [];      // 生成的编排清单预览（可编辑）
+
+$('#btnPlanner').onclick = () => { const d=$('#plDrawer'); const opening=!d.classList.contains('open'); d.classList.toggle('open', opening); if (opening) plInit(); };
+$('#plClose').onclick = () => $('#plDrawer').classList.remove('open');
+
+function plScrollBottom(){ const m=$('#plMsgs'); m.scrollTop=m.scrollHeight; }
+
+// 打开抽屉：恢复最近会话 + 内核状态检查
+async function plInit(){
+  const k = RUNNER_INFO && RUNNER_INFO.kind;
+  const banner=$('#plBanner');
+  if (k === 'demo' || k === 'missing'){
+    banner.style.display='block';
+    banner.textContent='⚠ AI 编排需要真实执行内核' + (k==='demo' ? '：当前为演示模式（AGENTS_CHAT_MOCK=1），删除 .env 中该配置并重启后即可使用' : '：请先安装 opencode（npm install -g opencode-ai）并登录，再刷新本页');
+    $('#plInput').disabled=true; $('#plSend').disabled=true; $('#plPlanBtn').disabled=true;
+  } else {
+    banner.style.display='none';
+    $('#plInput').disabled=false; $('#plSend').disabled=false; $('#plPlanBtn').disabled=false;
+  }
+  if (!plSid){
+    try{
+      const r=await api('/api/planner/session');
+      if (r.found && r.sid){ plSid=r.sid; plRender(r.messages||[]); }
+      else plRender([]);
+    }catch{ plRender([]); }
+  }
+}
+
+function plRender(msgs){
+  const m=$('#plMsgs');
+  if (!msgs.length){
+    m.innerHTML='<div class="pl-thinking">和我聊聊你想完成什么：例如「给项目做一轮发布前检查，覆盖依赖、测试、文档」。<br>信息不足时我会先问你几个问题，聊清楚后点下方「📝 生成编排」产出任务清单。</div>';
+    return;
+  }
+  m.innerHTML=msgs.map(x=>x.role==='user'
+    ? `<div class="pl-bubble pl-user">${esc(x.content)}</div>`
+    : `<div class="pl-bubble pl-ai">${esc(x.content)}</div>`).join('');
+  plScrollBottom();
+}
+
+function plAppend(role, text){ $('#plMsgs').insertAdjacentHTML('beforeend', `<div class="pl-bubble pl-${role}">${esc(text)}</div>`); plScrollBottom(); }
+
+async function plSendMsg(){
+  if (plBusy) return;
+  const ta=$('#plInput');
+  const message=ta.value.trim();
+  if (!message){ toast('先输入你的目标或回复'); return; }
+  ta.value='';
+  plAppend('user', message);
+  plBusy=true; $('#plSend').disabled=true; $('#plPlanBtn').disabled=true;
+  const think=document.createElement('div'); think.className='pl-thinking'; think.textContent='思考中…（最长约 2 分钟）';
+  $('#plMsgs').appendChild(think); plScrollBottom();
+  try{
+    const r=await post('/api/planner/chat', { sid: plSid, message });
+    think.remove();
+    if (r.success){ plSid=r.sid; plAppend('ai', r.reply||'（空回复）'); }
+    else { plAppend('ai', r.error||'发送失败'); $('#plMsgs').lastChild.classList.add('err'); }
+  }catch(e){ think.remove(); plAppend('ai', '发送失败：'+e.message); $('#plMsgs').lastChild.classList.add('err'); }
+  finally{ plBusy=false; $('#plSend').disabled=false; $('#plPlanBtn').disabled=false; }
+}
+$('#plSend').onclick=plSendMsg;
+$('#plInput').addEventListener('keydown', e=>{ if (e.key==='Enter' && !e.shiftKey){ e.preventDefault(); plSendMsg(); } });
+
+// 生成编排清单（可编辑预览）
+$('#plPlanBtn').onclick=async()=>{
+  if (plBusy) return;
+  if (!plSid){ toast('先发送一条消息描述目标'); return; }
+  plBusy=true; $('#plPlanBtn').disabled=true; $('#plSend').disabled=true;
+  $('#plPlanBox').style.display='block';
+  $('#plPlanBox').innerHTML='<h4>🤖 正在生成任务编排清单…（最长约 3 分钟）</h4>';
+  try{
+    const r=await post('/api/planner/plan', { sid: plSid });
+    if (r.success){ plDraft=r.plan||[]; plRenderPlan(); }
+    else { $('#plPlanBox').innerHTML=`<h4 style="color:#c0392b">生成失败：${esc(r.error||'')}</h4>`; }
+  }catch(e){ $('#plPlanBox').innerHTML=`<h4 style="color:#c0392b">生成失败：${esc(e.message)}</h4>`; }
+  finally{ plBusy=false; $('#plPlanBtn').disabled=false; $('#plSend').disabled=false; }
+};
+
+// 预览编辑：每任务标题/模式/依赖可改可删
+function plRenderPlan(){
+  const box=$('#plPlanBox');
+  box.style.display='block';
+  if (!plDraft.length){ box.innerHTML='<h4>暂无清单，点「📝 生成编排」</h4>'; return; }
+  box.innerHTML='<h4>📋 编排清单（可直接修改，依赖填清单序号如 1,2）</h4>' +
+    plDraft.map((t,i)=>`
+      <div class="pl-task">
+        <span class="no">${i+1}</span>
+        <input class="t-title" value="${esc(t.title)}" oninput="plDraft[${i}].title=this.value">
+        <select onchange="plDraft[${i}].mode=this.value">
+          <option value="new" ${t.mode==='new'?'selected':''}>新进程</option>
+          <option value="continue" ${t.mode==='continue'?'selected':''}>续聊</option>
+          <option value="parallel" ${t.mode==='parallel'?'selected':''}>并行</option>
+        </select>
+        <input class="t-deps" value="${esc((t.deps||[]).join(','))}" placeholder="依赖" oninput="plDraft[${i}].deps=this.value.split(',').map(s=>parseInt(s.trim())).filter(Number.isInteger)">
+        <button class="icon-btn" title="删除该任务" onclick="plDraft.splice(${i},1);plRenderPlan()">✕</button>
+      </div>`).join('') +
+    `<div class="foot">
+      <button class="btn" onclick="plDraft=[];plRenderPlan()">清空</button>
+      <button class="btn primary" style="flex:1" onclick="plImport('append')">＋ 导入看板（追加 ${plDraft.length} 项）</button>
+      <button class="btn danger" onclick="plImport('replace')">替换全部</button>
+    </div>`;
+}
+
+// 导入看板：append 追加 | replace 清空后导入（二次确认）
+async function plImport(mode){
+  const tasks=plDraft.filter(t=>String(t.title||'').trim()||String(t.content||'').trim())
+    .map((t,i)=>({ title:String(t.title||'').trim(), content:String(t.content||'').trim(), mode:t.mode||'new', deps:Array.isArray(t.deps)?t.deps:[] }));
+  if (!tasks.length){ toast('清单为空'); return; }
+  if (mode==='replace'){
+    const cur=(CARDS||[]).length;
+    if (!confirm(`将清空现有 ${cur} 个看板任务（移入垃圾桶，30 天内可还原），再导入 ${tasks.length} 个新任务。确定替换？`)) return;
+  }
+  try{
+    const r=await post('/api/cards/batch', { tasks, importMode: mode });
+    if (!r.success){ toast(r.error||'导入失败'); return; }
+    (r.warnings||[]).forEach(w=>toast(w));
+    toast(`已导入 ${tasks.length} 个任务${mode==='replace'?'（已清空原看板）':''}，点「▶ 开始编排」执行`);
+    plDraft=[]; $('#plPlanBox').style.display='none';
+    $('#plDrawer').classList.remove('open');
+    await loadCards();
+  }catch(e){ toast('导入失败：'+e.message); }
+}
+
+$('#plNew').onclick=()=>{ plSid=''; plDraft=[]; $('#plPlanBox').style.display='none'; plRender([]); toast('已开启新编排会话'); };
+$('#plDel').onclick=async()=>{
+  if (!plSid || !confirm('删除当前编排会话（聊天记录将不可恢复）？')) return;
+  await post('/api/planner/session/delete', { sid: plSid });
+  plSid=''; plDraft=[]; $('#plPlanBox').style.display='none'; plRender([]); toast('会话已删除');
+};
+
 $('#btnEditCancel').onclick=()=>$('#maskEdit').classList.remove('show');
 $('#btnEditSave').onclick=async()=>{
   const mode=$('#fMode').value, chainId=$('#fChain').value;

package/app/public/index.html

@@ -215,14 +215,14 @@
   .at-tx i { font-style: normal; color: #999; font-size: 11px; display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 380px; }
 
   /* ---------- 弹窗 ---------- */
-  #modalMask, #batchMask, #agentsMask, #historyMask, #helpMask, #flowMask, #cardMask, #teamsMask, #memMask, #diffMask, #welcomeMask { position: fixed; inset: 0; background: rgba(0,0,0,.4); display: none; align-items: center; justify-content: center; z-index: 51; }
+  #modalMask, #batchMask, #agentsMask, #historyMask, #helpMask, #flowMask, #cardMask, #teamsMask, #memMask, #diffMask, #welcomeMask, #suggestMask { position: fixed; inset: 0; background: rgba(0,0,0,.4); display: none; align-items: center; justify-content: center; z-index: 51; }
   /* 弹窗出现动画：遮罩淡入（含毛玻璃）+ 内容上浮，全站弹窗统一节奏 */
   div[id$="Mask"] { backdrop-filter: blur(3px); -webkit-backdrop-filter: blur(3px); }
   div[id$="Mask"].show { animation: fade-in .18s ease; }
   .modal, .preview-card { animation: modal-in .24s cubic-bezier(.2,.7,.3,1); }
   @keyframes fade-in { from { opacity: 0; } to { opacity: 1; } }
   @keyframes modal-in { from { opacity: 0; transform: translateY(14px) scale(.985); } to { opacity: 1; transform: none; } }
-  #modalMask.show, #batchMask.show, #agentsMask.show, #historyMask.show, #helpMask.show, #flowMask.show, #cardMask.show, #teamsMask.show, #memMask.show, #diffMask.show, #welcomeMask.show { display: flex; }
+  #modalMask.show, #batchMask.show, #agentsMask.show, #historyMask.show, #helpMask.show, #flowMask.show, #cardMask.show, #teamsMask.show, #memMask.show, #diffMask.show, #welcomeMask.show, #suggestMask.show { display: flex; }
   /* 团队仓库卡片 */
   .team-card { border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 16px; margin-bottom: 12px; }
   .team-card .tc-head { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; }
@@ -349,7 +349,7 @@
   /* ---------- 侧栏顶部：单聊/群聊开关 + 任务操作按钮 ---------- */
   .side-header { padding: 12px 12px 10px; display: flex; flex-direction: column; gap: 8px; border-bottom: 1px solid #f0f0f0; }
   .mode-switch { display: inline-flex; border: 1px solid #ddd; border-radius: 8px; overflow: hidden; }
-  .mode-switch button { border: none; background: #fff; font-size: 13px; padding: 5px 22px; min-width: 104px; cursor: pointer; color: #666; flex: 1; white-space: nowrap; }
+  .mode-switch button { border: none; background: #fff; font-size: 13px; padding: 5px 22px; min-width: 104px; cursor: pointer; color: #666; flex: 1; white-space: nowrap; position: relative; }
 
   /* ---------- 侧栏中部：会话区（上，约5条）+ 任务区（下）各占一半，总高固定 ---------- */
   .side-mid { flex: 1; min-height: 0; display: flex; flex-direction: column; overflow: hidden; }
@@ -358,6 +358,12 @@
   #taskList { flex: 1; min-height: 0; overflow-y: auto; }
   .mode-switch button + button { border-left: 1px solid #ddd; }
   .mode-switch button.active { background: #07c160; color: #fff; font-weight: 600; }
+  /* 三模式标签角标：完成进度（✓d/t）+ 未读绿点红数字 */
+  .mode-switch .tab-prog { font-size: 10.5px; color: #999; margin-left: 3px; }
+  .mode-switch button.active .tab-prog { color: rgba(255,255,255,.85); }
+  .mode-switch .tab-dot { display: none; position: absolute; top: -5px; right: 4px; min-width: 15px; height: 15px; padding: 0 4px; border-radius: 8px; background: #fa5151; color: #fff; font-size: 10px; line-height: 15px; text-align: center; font-weight: 600; }
+  .mode-switch .tab-dot.show { display: block; }
+  .mode-switch .tab-dot::before { content: ''; display: inline-block; width: 6px; height: 6px; border-radius: 50%; background: #07c160; margin-right: 2px; vertical-align: 1px; }
   .side-header .side-actions { display: flex; gap: 6px; width: 100%; }
   .side-header .side-actions .mini-btn { flex: 1; padding: 4px 0; text-align: center; }
   .ttab .badge { margin-left: 4px; vertical-align: 1px; }
@@ -433,8 +439,9 @@
   <aside id="sidebar">
     <div class="side-header">
       <div class="mode-switch" id="modeSwitch">
-        <button id="modeSoloBtn" onclick="setChatMode('solo')">👤 单聊</button>
-        <button id="modeGroupBtn" class="active" onclick="setChatMode('group')">👥 群聊</button>
+        <button id="modeSoloBtn" onclick="setChatMode('solo')">👤 单聊<span class="tab-prog" id="soloProg"></span><span class="tab-dot" id="soloDot"></span></button>
+        <button id="modeGroupBtn" class="active" onclick="setChatMode('group')">👥 群聊<span class="tab-prog" id="groupProg"></span><span class="tab-dot" id="groupDot"></span></button>
+        <button id="modeCardsBtn" onclick="setChatMode('cards')">🎛 编排<span class="tab-prog" id="cardsProg"></span><span class="tab-dot" id="cardsDot"></span></button>
       </div>
       <div class="side-actions">
         <button class="mini-btn" onclick="openImport()">导入任务</button>
@@ -506,6 +513,12 @@
         </footer>
       </div>
     </div>
+    <div id="cardsView" style="flex:1;min-height:0;display:none;flex-direction:column;position:relative">
+      <iframe id="cardsFrame" title="多任务编排控制台" style="flex:1;width:100%;border:0;display:block"></iframe>
+      <div id="cardsFallback" style="display:none;padding:40px;text-align:center;color:#888">
+        控制台加载失败。<button class="mini-btn" onclick="window.open('/cards','_blank')">在新标签打开</button>
+      </div>
+    </div>
   </main>
 </div>
 
@@ -588,6 +601,7 @@
     <div class="tip">每个智能体都是一个独立的 AI Agent：执行内核由顶部下拉框统一选择（OpenCode / Claude Code / Codex / pi），<b>图标</b>用于辨认，<b>名称</b>用于 @ 点名，<b>技能说明</b>供管家调度参考，<b>自定义提示词</b>会在任务下发时附加在用户提示词前面。所有智能体使用所选内核的默认模型。「管家」为内置调度智能体，不可修改。</div>
     <div class="butler-ro" id="butlerRo"></div>
     <div class="ag-row" style="margin:8px 0 2px">
+      <button class="add-agent" style="flex:1" onclick="openSuggest()">🪄 AI 组队 · 一句话生成团队</button>
       <button class="add-agent" style="flex:1" onclick="openTeams()">📦 团队仓库 · 一键换经典团队</button>
     </div>
     <div class="global-cwd-box">
@@ -658,6 +672,25 @@
     </div>
   </div>
 </div>
+<!-- AI 智能组队弹窗 -->
+<div id="suggestMask">
+  <div class="modal wide">
+    <h3>🪄 AI 组队</h3>
+    <div class="tip">用一句话描述你的需求，AI 扮演团队设计师，生成一套分工明确的智能体团队（名称/图标/技能说明/提示词）。先预览再应用，应用后仍可自由增删改，点配置页「保存」才生效。</div>
+    <div class="ta-wrap"><textarea id="sgReqInput" style="min-height:88px" placeholder="例如：我要从零做一个跨境电商独立站，需要市场调研、选品分析、网站前后端开发、内容文案和上线测试，帮我组建一支能覆盖全流程的团队"></textarea></div>
+    <div class="ag-row" style="margin:8px 0">
+      <button id="sgRunBtn" class="primary" style="flex:1" onclick="runSuggest()">✨ 生成团队</button>
+    </div>
+    <div id="sgResult"></div>
+    <div class="modal-actions">
+      <button class="mini-btn" onclick="runSuggest()">🔄 重新生成</button>
+      <span style="flex:1"></span>
+      <button onclick="closeSuggest()">放弃</button>
+      <button class="mini-btn" style="background:#07c160;color:#fff" onclick="applySuggest('append')">＋ 应用（合并到现有团队）</button>
+      <button class="primary" onclick="applySuggest('replace')">应用（替换全部子智能体）</button>
+    </div>
+  </div>
+</div>
 <!-- 聊天历史弹窗 -->
 <div id="historyMask">
   <div class="modal wide">
@@ -749,7 +782,7 @@
 </div>
 
 <script>
-const PAGE_VERSION = '3.33.0'; // 与服务端 /api/health.version 互检，不一致说明页面缓存过期
+const PAGE_VERSION = '3.35.0'; // 与服务端 /api/health.version 互检，不一致说明页面缓存过期
 const AV_COLORS = ['#5b8def','#07c160','#fa9d3b','#10aeff','#8a6fe8','#fa5151','#e8a33d','#3aa7a3'];
 const PHASE_LABEL = { plan: '调度规划', work: '执行', review: '验收', report: '汇总', talk: '圆桌发言', task: '任务执行' };
 // 职业图标库（智能体配置可选）
@@ -766,7 +799,8 @@ let globalCwd = '';            // 全局统一工作目录
 let configKernel = 'auto';     // 配置的执行内核
 let configApproval = 'off';    // 人工审批关卡：off/plan/verify/all
 let teamPresets = [];          // 团队仓库预设（配置页「📦 团队仓库」）
-let chatMode = 'group';        // 当前模式：group=群聊（多智能体）| solo=单聊（OpenCode 工作台）
+let chatMode = 'group';        // 当前模式：group=群聊（多智能体）| solo=单聊（OpenCode 工作台）| cards=多任务编排（内嵌控制台）
+let lastMainMsgCount = -1;     // 主会话消息数快照（-1=首次加载不计数；用于非群聊模式的未读提醒）
 const sessions = new Map();    // key: 'main' | taskId | oc会话id → 消息数组
 
 // ---------- 单聊工作台状态 ----------
@@ -861,6 +895,13 @@ async function init() {
   restoreApprovals(); // 恢复仍在等待的人工审批卡片（刷新/断线场景）
   updateFooterBtns();
 
+  // 恢复上次所在模式标签（单聊/群聊/编排），并拉一次编排统计驱动角标
+  try {
+    const saved = localStorage.getItem(MODE_STORE_KEY);
+    if (saved === 'solo' || saved === 'cards') setChatMode(saved);
+  } catch { /* localStorage 不可用时保持群聊 */ }
+  refreshCardsStats();
+
   // 版本互检：页面与服务端不一致 → 页面是旧缓存，必须强刷
   if (health.version && health.version !== PAGE_VERSION) {
     addSys(`⚠ 页面版本（${PAGE_VERSION}）与服务端（${health.version}）不一致：浏览器缓存了旧页面，请按 Ctrl+F5 强制刷新`);
@@ -929,19 +970,39 @@ async function init() {
   setInterval(() => {
     if (taskBusy || document.hidden) return;
     loadTasks(true);
+    refreshCardsStats(); // 编排标签角标同步（stats 接口轻量 <1KB）
   }, 8000);
 }
 
-// ---------- 单聊/群聊模式切换（左上角开关） ----------
+// ---------- 单聊/群聊/编排三模式切换（左上角标签） ----------
+const MODE_STORE_KEY = 'acChatMode'; // 模式持久化：刷新后恢复上次所在标签
+let cardsStatsCache = null;          // /api/cards/stats 最近一次结果（角标计算）
+let groupMsgUnread = 0;              // 非群聊模式下主会话收到的未读消息数（切回群聊清零）
+
 function setChatMode(mode) {
-  chatMode = mode === 'solo' ? 'solo' : 'group';
+  chatMode = ['solo', 'cards'].includes(mode) ? mode : 'group';
+  try { localStorage.setItem(MODE_STORE_KEY, chatMode); } catch { /* ignore */ }
+  if (chatMode === 'group') groupMsgUnread = 0; // 回到群聊即视为已读主会话
   document.getElementById('modeSoloBtn').classList.toggle('active', chatMode === 'solo');
   document.getElementById('modeGroupBtn').classList.toggle('active', chatMode === 'group');
+  document.getElementById('modeCardsBtn').classList.toggle('active', chatMode === 'cards');
   document.getElementById('groupView').style.display = chatMode === 'group' ? 'flex' : 'none';
   document.getElementById('soloView').style.display = chatMode === 'solo' ? 'flex' : 'none';
+  const cv = document.getElementById('cardsView');
+  cv.style.display = chatMode === 'cards' ? 'flex' : 'none';
+  if (chatMode === 'cards') {
+    // 内嵌控制台懒加载：首次才注入 src，切回不重载（保留看板状态）
+    const fr = document.getElementById('cardsFrame');
+    if (!fr.getAttribute('src')) {
+      fr.src = '/cards';
+      fr.onerror = () => { fr.style.display = 'none'; document.getElementById('cardsFallback').style.display = 'block'; };
+    }
+    markCardsSeen(); // 控制台可见即视为已查看：清未读、记当前完成数
+  }
   renderSidebar();
   renderHeader();
   updateFooterBtns();
+  updateModeBadges();
   if (chatMode === 'solo') {
     loadOcSessions();
     loadOcModels();
@@ -949,6 +1010,58 @@ function setChatMode(mode) {
   }
 }
 
+// ---------- 三标签角标：完成进度（✓d/t）+ 未读绿点数字 ----------
+async function refreshCardsStats() {
+  try {
+    const r = await api('/api/cards/stats');
+    cardsStatsCache = r.success ? r.stats : null;
+  } catch { cardsStatsCache = null; }
+  if (chatMode === 'cards') markCardsSeen();
+}
+
+// 编排已查看：更新 localStorage 基准（未读=当前完成数−基准，恒 ≥0）
+function markCardsSeen() {
+  if (cardsStatsCache) {
+    try { localStorage.setItem('acCardsLastSeenDone', String(cardsStatsCache.done)); } catch { /* ignore */ }
+  }
+}
+
+function updateModeBadges() {
+  try {
+    // 单聊/群聊：任务维度统计（按 runner 过滤）+ 各自未读会话数
+    const soloTasks = tasks.filter(t => t.runner === 'solo');
+    const groupTasks = tasks.filter(t => t.runner !== 'solo');
+    const doneOf = (arr) => arr.filter(t => t.status === 'done').length;
+    const unreadOf = (arr) => arr.filter(t => unreadSess.has(t.id)).length;
+    const prog = (el, d, t) => {
+      const n = document.getElementById(el);
+      if (n) n.textContent = t > 0 ? `✓${d}/${t}` : '';
+    };
+    const dot = (el, n) => {
+      const d = document.getElementById(el);
+      if (!d) return;
+      d.textContent = n > 99 ? '99+' : String(n);
+      d.classList.toggle('show', n > 0);
+    };
+    prog('soloProg', doneOf(soloTasks), soloTasks.length);
+    prog('groupProg', doneOf(groupTasks), groupTasks.length);
+    let groupUnread = unreadOf(groupTasks);
+    if (chatMode !== 'group') groupUnread += groupMsgUnread; // 非群聊时主会话新消息也提醒
+    dot('soloDot', chatMode === 'solo' ? 0 : unreadOf(soloTasks));
+    dot('groupDot', groupUnread);
+    // 编排：stats 接口 + localStorage 差值
+    const st = cardsStatsCache;
+    prog('cardsProg', st ? st.done : 0, st ? st.total : 0);
+    let cardsUnread = 0;
+    if (st && chatMode !== 'cards') {
+      let seen = 0;
+      try { seen = parseInt(localStorage.getItem('acCardsLastSeenDone'), 10) || 0; } catch { /* ignore */ }
+      cardsUnread = Math.max(0, st.done - seen);
+    }
+    dot('cardsDot', cardsUnread);
+  } catch { /* 数据未就绪时静默跳过（init 早期） */ }
+}
+
 // ==================== 单聊工作台（OpenCode） ====================
 
 // ---------- 模型列表 ----------
@@ -1376,6 +1489,7 @@ async function loadTasks(silent) {
   tasks = data.tasks || [];
   detectBackgroundDone();
   renderSidebar();
+  updateModeBadges(); // 三标签角标随任务状态同步
 }
 
 // ---------- 后台完成检测：定时任务由服务端调度执行，前端轮询感知状态变化 ----------
@@ -1647,6 +1761,7 @@ function switchSession(taskId) {
   unreadSess.delete(curKey()); // 切到该会话 = 已读，清除绿点
   renderSidebar();
   renderHeader();
+  updateModeBadges(); // 已读清除后角标即时更新
   // 有未读（后台完成过）或本地空但任务已结束（定时调度后台跑完）：从服务端拉最新消息
   const t = curTaskId ? tasks.find(x => x.id === curTaskId) : null;
   if (wasUnread || (t && (t.status === 'done' || t.status === 'failed') && getSess(curKey()).length === 0)) {
@@ -1665,6 +1780,7 @@ function markUnread(key) {
   if (key === curKey()) return;
   unreadSess.add(key);
   renderSidebar();
+  updateModeBadges(); // 未读绿点变化同步标签角标
 }
 
 // 取某会话最后一条汇总消息文本（群聊取 report 阶段；单聊任务取最后一条 assistant），作为弹窗预览内容
@@ -3184,12 +3300,20 @@ async function rerunFrom(run, stage) {
 async function loadMessages() {
   const data = await api('/api/messages');
   sessions.clear();
+  let mainCount = 0;
   for (const m of data.messages || []) {
     getSess(sessKey(m.taskId)).push({
       role: m.role, content: m.content, agentId: m.agentId, agentName: m.agentName,
       phase: m.phase, plan: m.plan, taskId: m.taskId, outputPath: m.outputPath, ts: m.timestamp
     });
+    if (!m.taskId) mainCount++;
   }
+  // 非群聊模式下主会话出现新消息：群聊标签计入未读提醒（回群聊即清零）
+  if (chatMode !== 'group' && mainCount > lastMainMsgCount && lastMainMsgCount >= 0) {
+    groupMsgUnread += mainCount - lastMainMsgCount;
+    updateModeBadges();
+  }
+  lastMainMsgCount = mainCount;
   renderMessages();
 }
 
@@ -3354,6 +3478,94 @@ function applyTeamPreset(i, mode) {
   toast(`已应用「${t.name}」（${mode === 'replace' ? '替换' : '追加'} ${incoming.length} 个智能体），点「保存」后生效`);
 }
 
+// ---------- AI 智能组队：一句话需求 → 内核生成团队 → 预览应用 ----------
+let sgDraft = []; // 预览态候选（仅前端内存，应用才进 editing）
+
+function openSuggest() {
+  document.getElementById('sgResult').innerHTML = '';
+  sgDraft = [];
+  document.getElementById('suggestMask').classList.add('show');
+  setTimeout(() => document.getElementById('sgReqInput').focus(), 50);
+}
+function closeSuggest() { document.getElementById('suggestMask').classList.remove('show'); }
+
+async function runSuggest() {
+  const reqEl = document.getElementById('sgReqInput');
+  const requirements = String(reqEl.value || '').trim();
+  if (!requirements) { toast('先描述一下你的需求，AI 才知道要组什么团队'); reqEl.focus(); return; }
+  const btn = document.getElementById('sgRunBtn');
+  const out = document.getElementById('sgResult');
+  btn.disabled = true;
+  btn.textContent = '⏳ 生成中…（AI 正在设计团队分工，最长约 2 分钟）';
+  out.innerHTML = '<div class="task-empty" style="padding:16px">AI 正在根据你的需求设计团队分工，请稍候…</div>';
+  sgDraft = [];
+  try {
+    const r = await api('/api/agents/suggest', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ requirements }) });
+    if (r.success) {
+      sgDraft = r.agents || [];
+      renderSuggestCards();
+      toast(`已生成 ${sgDraft.length} 个智能体，确认后点下方「应用」`);
+    } else {
+      out.innerHTML = `<div class="task-empty" style="padding:16px;color:#c0392b">❌ ${esc(r.error || '生成失败，请稍后重试')}</div>`;
+    }
+  } catch (e) {
+    out.innerHTML = `<div class="task-empty" style="padding:16px;color:#c0392b">❌ 生成失败：${esc(e.message)}</div>`;
+  } finally {
+    btn.disabled = false;
+    btn.textContent = '✨ 生成团队';
+  }
+}
+
+function renderSuggestCards() {
+  const el = document.getElementById('sgResult');
+  if (!sgDraft.length) {
+    el.innerHTML = '<div class="task-empty" style="padding:16px">暂无生成结果，输入需求后点「生成团队」</div>';
+    return;
+  }
+  el.innerHTML = sgDraft.map((a, i) => `
+    <div class="ag-card">
+      <div class="ag-row">
+        <span style="font-size:20px;align-self:center">${esc(a.icon || '🤖')}</span>
+        <b style="align-self:center;flex:1">${esc(a.name)}</b>
+        <button class="mini-btn gray" onclick="sgDraft.splice(${i},1);renderSuggestCards()">删除</button>
+      </div>
+      <input value="${escAttr(a.desc || '')}" placeholder="技能说明" oninput="sgDraft[${i}].desc=this.value">
+      <details>
+        <summary style="font-size:12px;color:#666;cursor:pointer;margin:4px 0">自定义提示词（点击展开查看，可直接修改）</summary>
+        <textarea oninput="sgDraft[${i}].systemPrompt=this.value">${esc(a.systemPrompt || '')}</textarea>
+      </details>
+    </div>`).join('');
+}
+
+// 应用候选：append=合并到现有名单（重名自动加序号）；replace=替换全部子智能体
+function applySuggest(mode) {
+  if (!sgDraft.length) { toast('还没有可应用的生成结果'); return; }
+  const incoming = sgDraft.map(a => ({
+    id: '', behavior: 'echo',
+    name: String(a.name || '').trim(),
+    icon: String(a.icon || ''),
+    desc: String(a.desc || ''),
+    systemPrompt: String(a.systemPrompt || '')
+  })).filter(a => a.name);
+  if (!incoming.length) { toast('候选智能体缺少名称，无法应用'); return; }
+  if (mode === 'replace') {
+    editing = incoming;
+  } else {
+    const names = new Set(['管家', 'butler', ...editing.map(a => String(a.name || '').trim())]);
+    for (const a of incoming) {
+      let final = a.name, n = 2;
+      while (names.has(final)) final = `${a.name}${n++}`;
+      a.name = final;
+      names.add(final);
+      editing.push(a);
+    }
+  }
+  sgDraft = [];
+  renderAgentCards();
+  closeSuggest();
+  toast(`已应用 AI 生成的团队（${mode === 'replace' ? '替换' : '合并'} ${incoming.length} 个智能体），点配置页「保存」后生效`);
+}
+
 function iconPicker(i) {
   const cur = editing[i].icon || '';
   return '<div class="icon-row">' + ICON_PRESETS.map(ic =>
@@ -3605,6 +3817,7 @@ function openHelp() {
       <li>本机安装任一执行内核并登录模型（模型与密钥由内核自己管理，本程序不做任何 API 配置）：<br>
         <code>${KERNEL_INSTALL.opencode}</code><br><code>${KERNEL_INSTALL.claude}</code><br><code>${KERNEL_INSTALL.codex}</code><br><code>${KERNEL_INSTALL.pi}</code></li>
       <li>启动本程序后浏览器打开 <code>http://localhost:3456</code>，会自动识别已安装的内核</li>
+      <li>不知道配什么团队？「⚙ 智能体配置」里点「🪄 AI 组队」，一句话描述需求，AI 自动生成整套智能体团队（先预览再应用）；也可从「📦 团队仓库」一键换经典团队</li>
       <li>直接在输入框说话即可开始；粘贴任务清单可批量执行</li>
     </ol>
   </div>

package/app/server.js

@@ -69,7 +69,11 @@ process.on('unhandledRejection', (err) => {
 const PORT = Number(process.argv.includes('--port') ? process.argv[process.argv.indexOf('--port') + 1] : (process.env.PORT || 3456));
 const PUBLIC_DIR = path.join(__dirname, 'public');
 const store = require('./lib/store');
-const { runAgent, stopScope, stopAllChildren } = require('./lib/agent');
+const { runAgent, resolveRunner, missingHint, stopScope, stopAllChildren } = require('./lib/agent');
+const teamgen = require('./lib/teamgen');
+const planner = require('./lib/planner');
+let suggestInFlight = false; // AI 组队生成互斥：同刻仅一个（内核单次调用，防并发浪费）
+const plannerLocks = new Set(); // AI 编排按会话互斥（每会话同时一个内核调用）
 const { runButler, runMentioned, runRoundtable, runTasks, prepareRerun } = require('./lib/orchestrator');
 const oc = require('./lib/oc');
 const memoryMod = require('./lib/memory');
@@ -598,6 +602,104 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (p === '/api/agents/suggest' && req.method === 'POST') {
+    // AI 智能组队：需求文本 → 执行内核生成团队配置（预览态，不落盘；应用走 /api/agents 保存链路）
+    const body = await readBody(req);
+    const requirements = String(body.requirements || '').trim();
+    if (!requirements || requirements.length > teamgen.REQ_MAX) {
+      json(res, 400, { success: false, error: `需求描述不能为空且不超过 ${teamgen.REQ_MAX} 字` });
+      return;
+    }
+    if (suggestInFlight) {
+      json(res, 409, { success: false, error: '上一次生成还在进行中，请稍候' });
+      return;
+    }
+    const runner = resolveRunner();
+    if (runner.kind === 'demo' || runner.kind === 'missing') {
+      const why = runner.kind === 'demo'
+        ? '当前为演示模式（AGENTS_CHAT_MOCK=1），删除 .env 中该配置并重启本程序后即可使用真实生成'
+        : missingHint(runner);
+      json(res, 200, { success: false, error: `AI 组队需要真实执行内核：${why}` });
+      return;
+    }
+    suggestInFlight = true;
+    try {
+      const r = await teamgen.suggestTeam({
+        requirements,
+        existingNames: store.getAgents().map(a => a.name)
+      });
+      json(res, 200, r);
+    } finally {
+      suggestInFlight = false;
+    }
+    return;
+  }
+
+  // ---------- AI 智能编排（卡牌控制台聊天式编排） ----------
+  if (p === '/api/planner/chat' && req.method === 'POST') {
+    const body = await readBody(req);
+    const message = String(body.message || '').trim();
+    if (!message || message.length > planner.MSG_MAX) {
+      json(res, 400, { success: false, error: `消息不能为空且不超过 ${planner.MSG_MAX} 字` });
+      return;
+    }
+    const runner = resolveRunner();
+    if (runner.kind === 'demo' || runner.kind === 'missing') {
+      const why = runner.kind === 'demo'
+        ? '当前为演示模式（AGENTS_CHAT_MOCK=1），删除 .env 中该配置并重启本程序后即可使用'
+        : missingHint(runner);
+      json(res, 200, { success: false, error: `AI 编排需要真实执行内核：${why}` });
+      return;
+    }
+    const sid = body.sid ? String(body.sid) : '';
+    if (plannerLocks.has(sid)) { json(res, 409, { success: false, error: '上一条还在处理中，请稍候' }); return; }
+    plannerLocks.add(sid);
+    try {
+      const r = await planner.chat({ sid, message });
+      if (r.error) json(res, 200, { success: false, error: r.error });
+      else json(res, 200, { success: true, sid: r.sid, reply: r.reply });
+    } finally {
+      plannerLocks.delete(sid);
+    }
+    return;
+  }
+
+  if (p === '/api/planner/plan' && req.method === 'POST') {
+    const body = await readBody(req);
+    const sid = String(body.sid || '');
+    const runner = resolveRunner();
+    if (runner.kind === 'demo' || runner.kind === 'missing') {
+      const why = runner.kind === 'demo'
+        ? '当前为演示模式（AGENTS_CHAT_MOCK=1），删除 .env 中该配置并重启本程序后即可使用'
+        : missingHint(runner);
+      json(res, 200, { success: false, error: `AI 编排需要真实执行内核：${why}` });
+      return;
+    }
+    if (plannerLocks.has(sid)) { json(res, 409, { success: false, error: '上一条还在处理中，请稍候' }); return; }
+    plannerLocks.add(sid);
+    try {
+      const r = await planner.plan({ sid });
+      if (r.error) json(res, 200, { success: false, error: r.error });
+      else json(res, 200, { success: true, plan: r.plan });
+    } finally {
+      plannerLocks.delete(sid);
+    }
+    return;
+  }
+
+  if (p === '/api/planner/session' && req.method === 'GET') {
+    const sid = String(parsed.query.sid || '');
+    const s = sid ? planner.readSession(sid) : planner.latestSession();
+    json(res, 200, { success: true, found: !!s, sid: s ? s.sid : '', messages: s ? s.messages : [] });
+    return;
+  }
+  if (p === '/api/planner/session/delete' && req.method === 'POST') {
+    const body = await readBody(req);
+    const ok = planner.deleteSession(String(body.sid || ''));
+    json(res, 200, { success: ok });
+    return;
+  }
+
   if (p === '/api/tasks' && req.method === 'GET') {
     // 按 seq（拖拽可调）排序返回
     json(res, 200, { success: true, tasks: store.getTasks() });
@@ -1177,6 +1279,71 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (p === '/api/cards/stats' && req.method === 'GET') {
+    // 三模式标签角标：轻量统计（<1KB），避免主界面拉全量卡牌
+    const stat = { total: 0, pending: 0, running: 0, done: 0, failed: 0 };
+    for (const c of CardStore.list()) {
+      stat.total++;
+      if (stat[c.status] !== undefined) stat[c.status]++;
+    }
+    json(res, 200, { success: true, stats: stat });
+    return;
+  }
+
+  if (p === '/api/cards/batch' && req.method === 'POST') {
+    // AI 编排清单批量导入：importMode=append 追加 | replace 先清空全部再导入
+    const body = await readBody(req);
+    const tasksIn = Array.isArray(body.tasks) ? body.tasks : [];
+    if (!tasksIn.length || tasksIn.length > 50) {
+      json(res, 400, { success: false, error: 'tasks 必须是 1-50 个任务的数组' });
+      return;
+    }
+    const { wouldCycle } = require('./lib/cards');
+    let replaced = 0;
+    if (String(body.importMode) === 'replace') {
+      for (const c of CardStore.list()) { CardStore.remove(c.id); replaced++; }
+    }
+    // 第一步：先全部创建（暂不带依赖），拿到序号 → id 映射
+    const idMap = new Map();
+    const cards = [];
+    tasksIn.forEach((t, i) => {
+      const card = CardStore.add({
+        title: String(t.title || '').trim() || String(t.content || '').slice(0, 40) || `任务${i + 1}`,
+        content: String(t.content || ''),
+        priority: Number.isFinite(Number(t.priority)) ? Number(t.priority) : 100 + i,
+        mode: 'new'
+      });
+      idMap.set(i + 1, card.id);
+      cards.push(card);
+    });
+    // 第二步：按清单回填 mode / deps（映射为批内 id）与续聊链首；环依赖丢弃并计警告
+    const warnings = [];
+    tasksIn.forEach((t, i) => {
+      const id = idMap.get(i + 1);
+      let mode = String(t.mode || 'new');
+      if (!['new', 'continue', 'parallel'].includes(mode)) mode = 'new';
+      let deps = Array.isArray(t.deps) ? t.deps : [];
+      deps = [...new Set(deps.map(d => parseInt(d, 10)).filter(Number.isInteger))]
+        .map(d => idMap.get(d)).filter(x => x && x !== id);
+      let chainId = '';
+      if (mode === 'continue' && deps.length) {
+        chainId = deps[0]; // 续聊链首 = 第一个依赖（清单内前一步）
+      } else if (mode === 'continue') {
+        mode = 'new'; // 无链首的续聊退化为新进程
+      }
+      const safe = [];
+      for (const d of deps) {
+        if (wouldCycle(id, [...safe, d])) { warnings.push(`任务 ${i + 1} 的依赖（序号 ${d}）会形成循环，已跳过`); continue; }
+        safe.push(d);
+      }
+      CardStore.update(id, { mode, dependsOn: safe, chainId });
+      const c = cards.find(x => x.id === id);
+      if (c) { c.mode = mode; c.dependsOn = safe; c.chainId = chainId; }
+    });
+    json(res, 200, { success: true, cards, warnings, replaced });
+    return;
+  }
+
   if (p === '/api/cards/clear' && req.method === 'POST') {
     const all = CardStore.list();
     for (const c of all) CardStore.remove(c.id);
@@ -1574,6 +1741,9 @@ function pruneOldDataQuiet() {
     require('./lib/worktree').pruneStale(PRUNE_DAYS, store.getTasks())
       .then(ws => { if (ws.worktrees) { stat.worktrees = ws.worktrees; console.log('[maintenance] 清理过期 Git 隔离区:', ws.worktrees); } })
       .catch(() => {});
+    // AI 编排聊天会话同步滚动清理（与任务/会话同一保留窗口）
+    const pl = require('./lib/planner').pruneStale(PRUNE_DAYS);
+    if (pl) { stat.plannerSessions = pl; console.log('[maintenance] 清理过期编排会话:', pl); }
     const touched = Object.values(stat).reduce((a, b) => a + b, 0);
     if (touched) console.log(`[maintenance] 自动清理超 ${PRUNE_DAYS} 天的历史数据：`, JSON.stringify(stat));
   } catch (e) { console.error('[maintenance] 自动清理失败:', e && (e.message || e)); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamsamyiok/agents-chat",
-  "version": "3.33.0",
+  "version": "3.35.0",
   "description": "多智能体群聊工具 - 支持 OpenCode/Claude Code/Codex/pi 内核，微信风格聊天界面",
   "main": "lib/start.js",
   "bin": {