openteam 0.3.1 → 0.4.0

package/bin/openteam.js

@@ -8,7 +8,7 @@ import { createRequire } from 'module';
 import { program } from 'commander';
 import {
   cmdStart, cmdAttach, cmdList, cmdStop,
-  cmdStatus, cmdMonitor, cmdDashboard,
+  cmdStatus, cmdMonitor, cmdDashboard, cmdAgentAttach,
 } from '../src/interfaces/cli.js';
 
 const require = createRequire(import.meta.url);
@@ -64,7 +64,13 @@ program
   .option('--dir <directory>', '项目目录')
   .action(cmdDashboard);
 
-// 内部命令（不在帮助中显示）
+// 内部命令（不在帮助中显示，由 layout / daemon 自动调用）
+program
+  .command('agent-attach <team> <agent>', { hidden: true })
+  .description('等待 agent 会话就绪后 attach')
+  .option('--dir <directory>', '项目目录')
+  .action(cmdAgentAttach);
+
 program
   .command('daemon <team>', { hidden: true })
   .option('--port <port>', 'serve 端口', parseInt)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openteam",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Agent-centric team collaboration for OpenCode",
   "type": "module",
   "main": "./src/index.js",

package/src/foundation/state.js

@@ -130,7 +130,7 @@ export function saveRuntime(teamName, projectDir, runtimeData) {
 }
 
 /**
- * Clear runtime configuration（保留 projectDir/team/sessions）
+ * Clear runtime configuration（保留 projectDir/team/sessions/started）
  */
 export function clearRuntime(teamName, projectDir) {
   const state = loadState(teamName, projectDir);
@@ -138,6 +138,7 @@ export function clearRuntime(teamName, projectDir) {
   saveState(teamName, projectDir, {
     projectDir: state.projectDir,
     team: state.team,
+    started: state.started,
     sessions: state.sessions || {},
   });
 }
@@ -292,7 +293,7 @@ export function removeInstance(teamName, projectDir, agentName, { cwd, alias })
 
 /**
  * 扫描团队的所有实例（含运行中和已停止的）
- * @returns {Array<{ projectDir: string, runtime: object|null, hash: string, alive: boolean }>}
+ * @returns {Array<{ projectDir: string, runtime: object|null, hash: string, alive: boolean, started: string|null }>}
  */
 export function listInstances(teamName) {
   const teamDir = getTeamDir(teamName);
@@ -326,6 +327,7 @@ export function listInstances(teamName) {
         runtime: alive ? runtime : null,
         hash: entry.name,
         alive,
+        started: state.started ?? null,
       });
     } catch {}
   }

package/src/foundation/terminal.js

@@ -245,36 +245,149 @@ function writeZellijTabLayout(sessionName, tabName, cmd) {
 }
 
 /**
- * 创建 zellij session，并在默认 tab 中启动 daemon
+ * 生成 zellij stacked tab layout，所有 panes 折叠在一个 tab 中
+ *
+ * stacked pane：只有一个 pane 展开全屏，其余折叠为标题栏。
+ * expanded=true 的 pane 启动时默认展开（通常是 leader）。
+ *
+ * @param {string} sessionName - session 名
+ * @param {string} tabName - tab 名
+ * @param {Array<{name: string, cmd: string, expanded?: boolean}>} panes - pane 定义
+ * @returns {string} layout 文件路径
+ */
+function writeZellijStackedTabLayout(sessionName, tabName, panes) {
+  const escapedTabName = tabName.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const paneEntries = panes.map(p => {
+    const eName = p.name.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const eCmd = p.cmd.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const attrs = p.expanded ? ' expanded=true' : '';
+    return `      pane command="bash" name="${eName}"${attrs} {\n        args "-lc" "exec ${eCmd}"\n      }`;
+  }).join('\n');
+
+  const layout = `layout {
+  tab name="${escapedTabName}" {
+    pane size=1 borderless=true {
+      plugin location="zellij:tab-bar"
+    }
+    pane stacked=true {
+${paneEntries}
+    }
+    pane size=1 borderless=true {
+      plugin location="zellij:status-bar"
+    }
+  }
+}`;
+  const layoutPath = path.join('/tmp', `openteam-zellij-${sessionName}-stacked.kdl`);
+  fs.writeFileSync(layoutPath, layout);
+  return layoutPath;
+}
+
+/**
+ * 生成 zellij session layout（daemon only，含 default_tab_template）
+ */
+function writeZellijSessionLayout(sessionName, daemonTabName, cmd) {
+  const escapedTabName = daemonTabName.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const escapedCmd = cmd.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const layout = `layout {
+  default_tab_template {
+    pane size=1 borderless=true {
+      plugin location="zellij:tab-bar"
+    }
+    children
+    pane size=1 borderless=true {
+      plugin location="zellij:status-bar"
+    }
+  }
+
+  tab name="${escapedTabName}" focus=true {
+    pane command="bash" name="${escapedTabName}" {
+      args "-lc" "exec ${escapedCmd}"
+    }
+  }
+}`;
+  const layoutPath = path.join('/tmp', `openteam-zellij-${sessionName}-session.kdl`);
+  fs.writeFileSync(layoutPath, layout);
+  return layoutPath;
+}
+
+/**
+ * 生成 zellij team layout — 同屏显示 dashboard + stacked agents
+ *
+ * 左侧 30%: daemon（嵌入式 dashboard）
+ * 右侧 70%: stacked agents（leader 默认展开，其余折叠为标题栏）
+ *
+ * @param {string} sessionName
+ * @param {string} daemonCmd - daemon 启动命令
+ * @param {Array<{name: string, cmd: string, expanded?: boolean}>} agents
+ */
+function writeZellijTeamLayout(sessionName, daemonCmd, agents) {
+  const eDaemonCmd = daemonCmd.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const paneEntries = agents.map(a => {
+    const eName = a.name.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const eCmd = a.cmd.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const attrs = a.expanded ? ' expanded=true' : '';
+    return `        pane command="bash" name="${eName}"${attrs} {\n          args "-lc" "exec ${eCmd}"\n        }`;
+  }).join('\n');
+
+  const layout = `layout {
+  default_tab_template {
+    pane size=1 borderless=true {
+      plugin location="zellij:tab-bar"
+    }
+    children
+    pane size=1 borderless=true {
+      plugin location="zellij:status-bar"
+    }
+  }
+
+  tab name="team" focus=true {
+    pane split_direction="vertical" {
+      pane command="bash" name="daemon" size="30%" {
+        args "-lc" "exec ${eDaemonCmd}"
+      }
+      pane stacked=true {
+${paneEntries}
+      }
+    }
+  }
+}`;
+  const layoutPath = path.join('/tmp', `openteam-zellij-${sessionName}-team.kdl`);
+  fs.writeFileSync(layoutPath, layout);
+  return layoutPath;
+}
+
+/**
+ * 创建 zellij session，daemon 作为 command pane 运行
+ *
+ * 用 -l layout 一步创建 session + daemon tab。
+ * background session 没有 focus 状态，rename-tab/close-pane 等依赖 focus 的 action 全部不可靠，
+ * 只有 layout 方式能可靠地定义 tab 名称和 command pane。
  */
 function bootstrapZellijSession(sessionName, cmd) {
   const env = cleanMuxEnv();
-  execSync(`zellij attach "${sessionName}" --create-background`, { stdio: 'ignore', env });
+  const layoutPath = writeZellijSessionLayout(sessionName, 'daemon', cmd);
+  execSync(`zellij -l "${layoutPath}" attach "${sessionName}" --create-background`, { stdio: 'ignore', env });
   if (!waitForZellijSession(sessionName)) {
     throw new Error(`zellij session not ready: ${sessionName}`);
   }
-
-  const sessionEnv = { ...env, ZELLIJ_SESSION_NAME: sessionName };
-  execSync('zellij action rename-tab daemon', { stdio: 'ignore', env: sessionEnv });
-  execSync(`zellij run --in-place -- bash -c 'exec ${cmd.replace(/'/g, "'\\''")}'`, {
-    stdio: 'ignore',
-    env: sessionEnv,
-  });
 }
 
 /**
  * 统一启动 mux session — 正确处理 tmux/zellij 的根本差异
  *
- * tmux: 先 new-session -d（detached），foreground 时再 attach
- * zellij: 先起默认 session，再把 daemon 注入首个 tab，避免覆盖用户自定义 UI
+ * tmux: 先 new-session -d（detached），foreground 时再 attach；agent panes 由 daemon 动态创建
+ * zellij: 用 layout 一步创建 session（background session 无 focus，不能用 action 操作 pane）
+ *   - 有 agents: team layout — daemon 左侧 30% + stacked agents 右侧 70%，agent 自行 attach
+ *   - 无 agents: daemon-only layout（兼容非团队模式）
  *
  * @param {'tmux'|'zellij'} mux
  * @param {string} sessionName
- * @param {string} cmd - 首个 pane 运行的命令
+ * @param {string} cmd - daemon 命令
  * @param {object} options
  * @param {boolean} options.foreground - true = 阻塞直到用户退出
+ * @param {Array<{name: string, cmd: string, expanded?: boolean}>} options.agents - agent pane 定义（仅 zellij）
  */
-export function startSession(mux, sessionName, cmd, { foreground = false } = {}) {
+export function startSession(mux, sessionName, cmd, { foreground = false, agents = [] } = {}) {
   if (mux === 'tmux') {
     const env = cleanMuxEnv();
     execSync(`tmux new-session -d -s "${sessionName}" "${cmd}"`, { stdio: 'ignore', env });
@@ -282,7 +395,17 @@ export function startSession(mux, sessionName, cmd, { foreground = false } = {})
       execSync(`tmux attach -t "${sessionName}"`, { stdio: 'inherit', env });
     }
   } else if (mux === 'zellij') {
-    bootstrapZellijSession(sessionName, cmd);
+    if (agents.length > 0) {
+      // team layout: daemon + stacked agents 同屏
+      const env = cleanMuxEnv();
+      const layoutPath = writeZellijTeamLayout(sessionName, cmd, agents);
+      execSync(`zellij -l "${layoutPath}" attach "${sessionName}" --create-background`, { stdio: 'ignore', env });
+      if (!waitForZellijSession(sessionName)) {
+        throw new Error(`zellij session not ready: ${sessionName}`);
+      }
+    } else {
+      bootstrapZellijSession(sessionName, cmd);
+    }
     if (foreground) {
       attachSession(mux, sessionName);
     }
@@ -306,9 +429,9 @@ export function addAgentPane(mux, sessionName, cmd, paneName) {
       }
       return paneName;
     } else if (mux === 'zellij') {
-      const env = { ...cleanMuxEnv(), ZELLIJ_SESSION_NAME: sessionName };
+      const env = cleanMuxEnv();
       const layoutPath = writeZellijTabLayout(sessionName, paneName, cmd);
-      execSync(`zellij action new-tab --name "${paneName}" --layout "${layoutPath}"`, { stdio: 'ignore', env });
+      execSync(`zellij --session "${sessionName}" action new-tab --name "${paneName}" --layout "${layoutPath}"`, { stdio: 'ignore', env });
       return paneName;
     }
   } catch (err) {
@@ -317,6 +440,26 @@ export function addAgentPane(mux, sessionName, cmd, paneName) {
   }
 }
 
+/**
+ * 创建 zellij stacked tab（所有 agent panes 折叠在一个 tab 中）
+ *
+ * @param {string} sessionName - session 名
+ * @param {string} tabName - tab 名
+ * @param {Array<{name: string, cmd: string, expanded?: boolean}>} panes
+ * @returns {boolean}
+ */
+export function addStackedTab(sessionName, tabName, panes) {
+  try {
+    const env = cleanMuxEnv();
+    const layoutPath = writeZellijStackedTabLayout(sessionName, tabName, panes);
+    execSync(`zellij --session "${sessionName}" action new-tab --layout "${layoutPath}"`, { stdio: 'ignore', env });
+    return true;
+  } catch (err) {
+    log.warn('addStackedTab failed', { sessionName, tabName, error: err.message });
+    return false;
+  }
+}
+
 /**
  * 列出 session 中所有 pane 的状态
  * @returns {Array<{id: string, name: string, alive: boolean, cmd: string}>}
@@ -335,8 +478,8 @@ export function listPanes(mux, sessionName) {
         return { id, name: name || '', alive: dead !== '1', cmd: cmd || '' };
       });
     } else if (mux === 'zellij') {
-      const env = { ...cleanMuxEnv(), ZELLIJ_SESSION_NAME: sessionName };
-      const layout = execSync('zellij action dump-layout', { encoding: 'utf8', env });
+      const env = cleanMuxEnv();
+      const layout = execSync(`zellij --session "${sessionName}" action dump-layout`, { encoding: 'utf8', env });
       const panes = [];
       const matches = layout.matchAll(/pane.*?name="([^"]+)"/g);
       for (const m of matches) {
@@ -360,9 +503,9 @@ export function respawnPane(mux, sessionName, paneId, cmd) {
       execSync(`tmux respawn-pane -t "${paneId}" -k "${cmd}"`, { stdio: 'ignore', env });
       return true;
     } else if (mux === 'zellij') {
-      const env = { ...cleanMuxEnv(), ZELLIJ_SESSION_NAME: sessionName };
+      const env = cleanMuxEnv();
       const layoutPath = writeZellijTabLayout(sessionName, paneId, cmd);
-      execSync(`zellij action new-tab --name "${paneId}" --layout "${layoutPath}"`, { stdio: 'ignore', env });
+      execSync(`zellij --session "${sessionName}" action new-tab --name "${paneId}" --layout "${layoutPath}"`, { stdio: 'ignore', env });
       return true;
     }
   } catch (err) {

package/src/interfaces/cli.js

@@ -11,6 +11,7 @@ import {
   getServeUrl,
   findAvailablePort,
   loadActiveSessions,
+  getAgentInstances,
   listRunningInstances,
   listAllRunningInstances,
   listAllInstances,
@@ -43,6 +44,23 @@ function padV(str, width) {
   return str + ' '.repeat(Math.max(0, width - visibleLength(str)));
 }
 
+/**
+ * ISO 时间戳 → 相对时间（"3m ago", "2h ago", "5d ago"）
+ */
+function relativeTime(isoString) {
+  if (!isoString) return '—';
+  const diff = Date.now() - new Date(isoString).getTime();
+  if (diff < 0) return '—';
+  const sec = Math.floor(diff / 1000);
+  if (sec < 60) return `${sec}s ago`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hrs = Math.floor(min / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  const days = Math.floor(hrs / 24);
+  return `${days}d ago`;
+}
+
 function error(msg) {
   console.error(`${RED}错误:${NC} ${msg}`);
   process.exit(1);
@@ -138,6 +156,13 @@ export async function cmdStart(teamName, options) {
 
   const daemonCmd = `openteam daemon ${teamName} --port ${port} --dir "${projectDir}" --mux ${mux}`;
 
+  // zellij: 构建 agent-attach 命令，由 team layout 的 stacked panes 自动调用
+  const agentCmds = mux === 'zellij' ? teamConfig.agents.map(agent => ({
+    name: agent,
+    cmd: `openteam agent-attach ${teamName} ${agent} --dir "${projectDir}"`,
+    expanded: agent === teamConfig.leader,
+  })) : [];
+
   info(`启动 ${teamName} 团队...`);
   console.log(`  复用器: ${mux}`);
   console.log(`  端口:   ${port}`);
@@ -145,9 +170,10 @@ export async function cmdStart(teamName, options) {
   console.log(`  Leader: ${teamConfig.leader}`);
   console.log('');
 
-  // 创建 mux session，pane 0 运行 daemon
-  // foreground: 前台模式阻塞直到用户退出；detach: 后台创建后立即返回
-  startSession(mux, sessionName, daemonCmd, { foreground: !options.detach });
+  // 创建 mux session
+  // zellij: team layout（daemon + stacked agents 同屏）
+  // tmux:   daemon only，agent panes 由 daemon 动态创建
+  startSession(mux, sessionName, daemonCmd, { foreground: !options.detach, agents: agentCmds });
 
   if (options.detach) {
     success('团队已在后台启动');
@@ -214,10 +240,12 @@ export function cmdList(options = {}) {
     rows.push({
       id: inst.hash,
       team: inst.teamName,
+      status: `${GREEN}Running${NC}`,
       project: inst.projectDir,
       leader,
       members: others,
       port: String(inst.runtime.servePort || '—'),
+      created: relativeTime(inst.started),
     });
   }
 
@@ -228,8 +256,11 @@ export function cmdList(options = {}) {
       const { leader, others } = getTeamMembers(inst.teamName);
       rows.push({
         id: inst.hash, team: inst.teamName,
+        status: 'Stopped',
         project: inst.projectDir || '—',
-        leader, members: others, port: '—', stopped: true,
+        leader, members: others, port: '—',
+        created: relativeTime(inst.started),
+        stopped: true,
       });
     }
 
@@ -239,8 +270,12 @@ export function cmdList(options = {}) {
     for (const teamName of neverRunTeams) {
       const { leader, others } = getTeamMembers(teamName);
       rows.push({
-        id: '—', team: teamName, project: '—',
-        leader, members: others, port: '—', stopped: true,
+        id: '—', team: teamName,
+        status: 'Created',
+        project: '—',
+        leader, members: others, port: '—',
+        created: '—',
+        stopped: true,
       });
     }
   }
@@ -251,8 +286,8 @@ export function cmdList(options = {}) {
   }
 
   // 动态计算列宽（基于可见长度）
-  const cols = ['id', 'team', 'project', 'leader', 'members', 'port'];
-  const headers = { id: 'ID', team: 'TEAM', project: 'PROJECT', leader: 'LEADER', members: 'MEMBERS', port: 'PORT' };
+  const cols = ['id', 'team', 'status', 'project', 'leader', 'members', 'port', 'created'];
+  const headers = { id: 'ID', team: 'TEAM', status: 'STATUS', project: 'PROJECT', leader: 'LEADER', members: 'MEMBERS', port: 'PORT', created: 'CREATED' };
   const widths = {};
   for (const col of cols) {
     widths[col] = Math.max(
@@ -402,3 +437,33 @@ export async function cmdDashboard(teamName, options = {}) {
   const { dashboard } = await import('./dashboard/index.js');
   await dashboard(teamName, projectDir);
 }
+
+/**
+ * 等待 agent 会话就绪后 attach（由 zellij team layout 自动调用）
+ *
+ * 轮询 state 文件，直到 serve URL + session ID 可用，然后 exec 到 opencode attach。
+ * 超时 120s — 考虑 serve 启动 + session 创建耗时。
+ */
+export async function cmdAgentAttach(teamName, agentName, options = {}) {
+  const projectDir = options.dir || process.cwd();
+  const timeout = 120000;
+  const start = Date.now();
+
+  console.log(`等待 ${agentName} 会话就绪...`);
+
+  while (Date.now() - start < timeout) {
+    const serveUrl = getServeUrl(teamName, projectDir);
+    if (serveUrl) {
+      const instances = getAgentInstances(teamName, projectDir, agentName);
+      if (instances.length > 0) {
+        console.log(`连接到 ${agentName}...`);
+        execSync(`opencode attach "${serveUrl}" -s "${instances[0].sessionId}"`, { stdio: 'inherit' });
+        return;
+      }
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  console.error(`${RED}超时:${NC} ${agentName} 会话未在 ${timeout / 1000}s 内就绪`);
+  process.exit(1);
+}

package/src/interfaces/daemon/index.js

@@ -7,10 +7,12 @@
  * - 嵌入式 dashboard
  */
 
+import { execSync } from 'child_process';
 import { loadTeamConfig, validateTeamConfig } from '../../foundation/config.js';
 import { saveRuntime, clearRuntime, findAvailablePort } from '../../foundation/state.js';
 import { DEFAULTS, getSessionName } from '../../foundation/constants.js';
 import { createLogger } from '../../foundation/logger.js';
+import { cleanMuxEnv } from '../../foundation/terminal.js';
 import { ensureAgent, recoverSessions } from '../../capabilities/lifecycle.js';
 import { startServe, stopServe, onServeCrash } from './serve.js';
 import { createAllAgentPanes, checkAndRespawn } from './panes.js';
@@ -86,8 +88,19 @@ export async function runDaemon(teamName, projectDir, options = {}) {
   }
 
   // ── 3. 创建 agent panes ──
-  console.log('创建 agent panes...');
-  createAllAgentPanes(muxType, sessionName, agents, serve.url, sessionMap);
+  // zellij: layout 已在 startSession 时创建好 stacked agents，agent-attach 自动连接
+  // tmux:   需要动态创建 agent window
+  if (muxType !== 'zellij') {
+    console.log('创建 agent panes...');
+    const leader = teamConfig.leader;
+    createAllAgentPanes(muxType, sessionName, agents, serve.url, sessionMap, { leaderName: leader });
+    try {
+      const env = cleanMuxEnv();
+      execSync(`tmux select-window -t "${sessionName}:0"`, { stdio: 'ignore', env });
+    } catch {
+      // ignore
+    }
+  }
 
   // ── 4. serve 崩溃重启 ──
   let restarting = false;

package/src/interfaces/daemon/panes.js

@@ -6,6 +6,7 @@
 import { execSync } from 'child_process';
 import {
   addAgentPane,
+  addStackedTab,
   cleanMuxEnv,
   listPanes,
   respawnPane,
@@ -17,13 +18,48 @@ const log = createLogger('daemon:panes');
 
 /**
  * 为所有 agent 创建 pane
+ *
+ * zellij: 一个 stacked tab，所有 agent 折叠在一起，leader 默认展开
+ * tmux:   每个 agent 一个 window（无 stacked 概念）
+ *
  * @param {string} mux - 复用器类型
  * @param {string} sessionName - mux session 名
  * @param {string[]} agents - agent 列表
  * @param {string} serveUrl - serve URL
  * @param {Map<string, string>} sessionMap - agentName → sessionId
+ * @param {object} [options]
+ * @param {string} [options.leaderName] - leader 名称（zellij stacked 模式下默认展开）
  */
-export function createAllAgentPanes(mux, sessionName, agents, serveUrl, sessionMap) {
+export function createAllAgentPanes(mux, sessionName, agents, serveUrl, sessionMap, options = {}) {
+  const { leaderName } = options;
+
+  if (mux === 'zellij') {
+    // zellij: 所有 agent 放入一个 stacked tab，leader 默认展开
+    const panes = [];
+    for (const agent of agents) {
+      const sessionId = sessionMap.get(agent);
+      if (!sessionId) {
+        log.warn(`skip pane for ${agent}: no session`);
+        continue;
+      }
+      panes.push({
+        name: agent,
+        cmd: buildAttachCmd(serveUrl, sessionId),
+        expanded: agent === leaderName,
+      });
+    }
+    if (panes.length > 0) {
+      const ok = addStackedTab(sessionName, 'team', panes);
+      if (ok) {
+        log.info(`stacked tab created with ${panes.length} agents`);
+      } else {
+        log.error('failed to create stacked tab');
+      }
+    }
+    return;
+  }
+
+  // tmux: 保持现有逻辑 — 每个 agent 一个 window
   let first = true;
   for (const agent of agents) {
     const sessionId = sessionMap.get(agent);
@@ -34,7 +70,7 @@ export function createAllAgentPanes(mux, sessionName, agents, serveUrl, sessionM
     const cmd = buildAttachCmd(serveUrl, sessionId);
 
     // 第一个 agent 开新 window，与 daemon pane 0 隔离
-    if (first && mux === 'tmux') {
+    if (first) {
       try {
         const env = cleanMuxEnv();
         execSync(`tmux new-window -t "${sessionName}" -n "${agent}" "${cmd}"`, { stdio: 'ignore', env });

package/src/interfaces/dashboard/data.js

@@ -44,6 +44,7 @@ export async function fetchAgentStatus(teamName, projectDir, serveUrl) {
       try {
         const exists = await sessionExists(serveUrl, inst.sessionId);
         const session = exists ? await fetchSession(serveUrl, inst.sessionId) : null;
+        const activity = exists ? await detectAgentActivity(serveUrl, inst.sessionId) : 'idle';
 
         agentStatuses.push({
           name: agent,
@@ -51,6 +52,7 @@ export async function fetchAgentStatus(teamName, projectDir, serveUrl) {
           cwd: inst.cwd || 'N/A',
           online: exists,
           title: session?.title || 'Unknown',
+          activity,
         });
       } catch (err) {
         agentStatuses.push({
@@ -59,6 +61,7 @@ export async function fetchAgentStatus(teamName, projectDir, serveUrl) {
           cwd: inst.cwd || 'N/A',
           online: false,
           title: 'Error',
+          activity: 'idle',
           error: err.message,
         });
       }
@@ -155,6 +158,33 @@ export async function fetchMessageStream(teamName, projectDir, serveUrl, limit =
   }
 }
 
+/**
+ * 检测 agent 活动状态
+ *
+ * 规则（基于最后一条消息）：
+ * - 无消息 → idle（刚创建）
+ * - assistant + finish → idle（待机，已完成回复）
+ * - assistant 无 finish → outputting（输出中，正在生成）
+ * - user → thinking（思考中，等待模型响应）
+ */
+async function detectAgentActivity(serveUrl, sessionId) {
+  try {
+    const messages = await fetchMessages(serveUrl, sessionId);
+    if (!messages || messages.length === 0) return 'idle';
+
+    const last = messages[messages.length - 1];
+    const role = last.info?.role;
+
+    if (role === 'user') return 'thinking';
+    if (role === 'assistant') {
+      return last.info?.finish ? 'idle' : 'outputting';
+    }
+    return 'idle';
+  } catch {
+    return 'idle';
+  }
+}
+
 /**
  * 从消息对象中提取第一段文本
  */

package/src/interfaces/dashboard/ui.js

@@ -208,6 +208,12 @@ export function updateTeamStatus(box, teamStatus) {
 
 /**
  * 更新 Agent 状态
+ *
+ * 活动指示器：
+ *   ● 待机   (green)  — idle，已完成回复或刚创建
+ *   ● 思考中 (yellow) — thinking，收到消息等待模型响应
+ *   ● 输出中 (cyan)   — outputting，模型正在生成回复
+ *   ○ 离线   (red)    — offline，会话不存在
  */
 export function updateAgentStatus(box, agentStatuses) {
   if (agentStatuses.length === 0) {
@@ -216,16 +222,33 @@ export function updateAgentStatus(box, agentStatuses) {
   }
 
   const lines = agentStatuses.map((agent) => {
-    const status = agent.online ? '{green-fg}●{/green-fg}' : '{red-fg}○{/red-fg}';
-    const name = agent.name.padEnd(15);
-    const sessionId = agent.sessionId.slice(0, 12).padEnd(12);
+    const indicator = formatActivity(agent);
+    const name = agent.name.padEnd(12);
+    const sessionId = agent.sessionId.slice(0, 8);
     const cwd = agent.cwd.length > 40 ? '...' + agent.cwd.slice(-37) : agent.cwd;
 
-    return `${status} ${name} ${sessionId} ${cwd}`;
+    return `${indicator} ${name} ${sessionId}  ${cwd}`;
   });
 
-  const header = '{bold}状态  Agent          会话ID       工作目录{/bold}';
-  box.setContent([header, ...lines].join('\n'));
+  box.setContent(lines.join('\n'));
+}
+
+/**
+ * 格式化 agent 活动状态指示器
+ *
+ * 所有变体对齐到 8 个可见列宽（CJK 字符占 2 列）：
+ *   "● 待机"   = 6 列 + 2 空格 = 8
+ *   "● 思考中" = 8 列 = 8
+ *   "● 输出中" = 8 列 = 8
+ *   "○ 离线"   = 6 列 + 2 空格 = 8
+ */
+function formatActivity(agent) {
+  if (!agent.online) return '{red-fg}○ 离线{/red-fg}  ';
+  switch (agent.activity) {
+    case 'thinking':   return '{yellow-fg}● 思考中{/yellow-fg}';
+    case 'outputting': return '{cyan-fg}● 输出中{/cyan-fg}';
+    default:           return '{green-fg}● 待机{/green-fg}  ';
+  }
 }
 
 /**