@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/main/server.ts

@@ -44,28 +44,53 @@ import staticPlugin from '@fastify/static';
 import { Cron } from 'croner';
 import Fastify from 'fastify';
 
-import {
-  CROSS_TEAM_SENT_SOURCE,
-  CROSS_TEAM_SOURCE,
-  formatCrossTeamText,
-} from '@shared/constants/crossTeam';
-import type { CcAgentType, CcProjectPlatform } from '../shared/types/ccConnect';
+import { CROSS_TEAM_SENT_SOURCE } from '@shared/constants/crossTeam';
+import type { CcAgentType, CcProjectPlatform, CcSessionListItem } from '../shared/types/ccConnect';
 import { CcConnectBridge } from './services/ccConnect/CcConnectBridge';
 import { CcConnectClient } from './services/ccConnect/CcConnectClient';
+import { isPlaceholderWorkDir, needsWorkDirReconcile } from './services/ccConnect/workDirReconcile';
+import {
+  DirectCliSessionManager,
+  buildDirectReplyMessageId,
+  type DirectCliEvent,
+} from './services/direct-cli';
 import { TeamProvisioningService } from './services/teams-mvp';
 import { TaskDispatchService } from './services/teams-mvp/TaskDispatchService';
 import { resolveCcProjectName } from './utils/teamProjectResolution';
 import { CollaborationBoardService } from './services/teams-mvp/CollaborationBoardService';
-import { SystemManagerConfigService } from './services/system-manager/SystemManagerConfigService';
-import { SystemManagerPtyService } from './services/system-manager/SystemManagerPtyService';
+import { createWorkerSociety } from '@features/worker-society/main/composition/societyComposition';
+import { registerSocietyRoutes } from '@features/worker-society/main/adapters/input/societyRoutes';
+import {
+  SOCIETY_MCP_TOOLS,
+  executeSocietyMcpTool,
+} from '@features/worker-society/main/adapters/input/societyMcp';
+import {
+  SystemManagerConfigService,
+  adminWorkDir,
+} from './services/system-manager/SystemManagerConfigService';
+import { ensureAdminLoopInitialized as runAdminLoopInit } from './services/system-manager/AdminLoopInitializer';
+import { httpsGetFollowRedirects } from './services/extensions/catalog/PluginCatalogService';
+import { HERMIT_OPS_GUIDE_URL } from './services/teams-mvp/OpsRunbookContext';
 import { WorkflowPromptService } from './services/system-manager/WorkflowPromptService';
-import { seedBuiltinWorkflows, ensureGlobalWorkflows } from './services/system-manager/BuiltinWorkflowSeeder';
+import {
+  ensureGlobalWorkflows,
+  seedBuiltinWorkflows,
+} from './services/system-manager/BuiltinWorkflowSeeder';
 import {
   SYSTEM_MANAGER_BIND_PROJECT,
   SYSTEM_MANAGER_DISPLAY_NAME,
   SYSTEM_MANAGER_TEAM_NAME,
 } from '@shared/types/team';
-import type { SystemManagerSummary, TaskBusConfig, TeamLaunchRequest } from '@shared/types/team';
+import type {
+  SystemManagerSummary,
+  TaskBusConfig,
+  TeamLaunchRequest,
+  ToolApprovalSettings,
+  ToolApprovalRequest,
+  ToolApprovalAutoResolved,
+} from '@shared/types/team';
+import { DEFAULT_TOOL_APPROVAL_SETTINGS } from '@shared/types/team';
+import { shouldAutoAllow } from '@main/utils/toolApprovalRules';
 import type { TeamManifest } from './services/teams-mvp/TeamWorkspaceService';
 import { UpdateService } from './services/UpdateService';
 import {
@@ -79,6 +104,18 @@ import {
   shouldIncludeContent,
 } from './services/session-intelligence/ConversationTelemetryService';
 import { LocalSessionScanner } from './services/session-intelligence/LocalSessionScanner';
+import { mergeLocalAndCcSessions } from './services/session-intelligence/teamSessionListMapper';
+import type { CcSession } from '@shared/types/api';
+import { discoverableTeamToWorker, type DiscoverableWorker } from '@shared/types/worker';
+import { LoopAssetsScannerService } from './services/loop-assets/LoopAssetsScannerService';
+import {
+  scanProjectStats,
+  type ProjectUsageStats,
+} from './services/session-intelligence/SessionUsageParser';
+import {
+  isExternalPlatformSessionKey,
+  resolveExternalPlatformSessionTeamSlug,
+} from './utils/externalPlatformSessionRouting';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
@@ -103,7 +140,7 @@ const CC_AGENT_TYPES: readonly CcAgentType[] = [
   'tmux',
 ];
 const SYSTEM_MANAGER_DESCRIPTION =
-  '项目级 Claude Code 控制台，负责插件、MCP、Env、数字员工和统计数据的托管管理。';
+  '项目级 Claude Code Helm Loop，负责插件、MCP、Env、数字员工和统计数据的托管管理。';
 
 function toCcAgentType(value: string | undefined): CcAgentType {
   return CC_AGENT_TYPES.includes(value as CcAgentType) ? (value as CcAgentType) : 'claudecode';
@@ -189,9 +226,10 @@ function loadConfig(): HermitConfig {
       merged = { ...defaults, ...raw };
     }
   } catch (err) {
-    const msg = err instanceof SyntaxError
-      ? `${HERMIT_CONFIG_FILE} 格式错误: ${err.message}。将使用默认配置并覆盖修复。`
-      : `读取 ${HERMIT_CONFIG_FILE} 失败: ${err instanceof Error ? err.message : String(err)}`;
+    const msg =
+      err instanceof SyntaxError
+        ? `${HERMIT_CONFIG_FILE} 格式错误: ${err.message}。将使用默认配置并覆盖修复。`
+        : `读取 ${HERMIT_CONFIG_FILE} 失败: ${err instanceof Error ? err.message : String(err)}`;
     console.warn(`[Hermit] ${msg}`);
     // Auto-heal: rewrite the config file with valid defaults + any readable env overrides
     mkdirSync(HERMIT_HOME, { recursive: true });
@@ -230,7 +268,9 @@ function writeHermitConfigRaw(content: string): HermitConfig {
     parsed = JSON.parse(content);
   } catch (err) {
     if (err instanceof SyntaxError) {
-      throw new Error(`配置文件 JSON 格式错误: ${err.message}。请检查是否有尾逗号、单引号或注释等非法 JSON 语法。`);
+      throw new Error(
+        `配置文件 JSON 格式错误: ${err.message}。请检查是否有尾逗号、单引号或注释等非法 JSON 语法。`
+      );
     }
     throw err;
   }
@@ -255,31 +295,21 @@ const bridge = new CcConnectBridge({
   bridgeUrl: runtimeConfig.ccBridgeUrl,
   bridgeToken: runtimeConfig.ccBridgeToken || runtimeConfig.ccToken,
 });
-const svc = new TeamProvisioningService(cc, bridge);
+const svc = new TeamProvisioningService(cc, bridge, undefined, {
+  restartCcConnect: restartCcConnectAndReconnectBridge,
+});
 const systemManagerConfig = new SystemManagerConfigService(REPO_ROOT);
-const systemManagerPty = new SystemManagerPtyService();
 const workflowPromptService = new WorkflowPromptService();
 
-systemManagerPty.on('data', (event) => broadcastSse('terminal:data', event));
-systemManagerPty.on('exit', (event) => broadcastSse('terminal:exit', event));
-
 async function getSystemManagerWorkDir(): Promise<string> {
-  try {
-    return (await systemManagerConfig.getConfig()).selectedWorkDir;
-  } catch {
-    return REPO_ROOT;
-  }
-}
-
-async function syncSystemManagerManifestWorkDir(workDir: string): Promise<void> {
-  try {
-    const manifest = await svc.readTeamManifest(SYSTEM_MANAGER_TEAM_NAME);
-    if (manifest.workDir !== workDir) {
-      await svc.updateTeam(SYSTEM_MANAGER_TEAM_NAME, { workDir });
-    }
-  } catch {
-    // The console team may not exist yet; ensureSystemManager() will create it later.
-  }
+  // Canonical, isolated Helm Loop runtime path. Dedicated (never shared with
+  // another team/project) so the admin agent can bootstrap its own CLAUDE.md
+  // here without colliding with project work. The manifest workDir is synced to
+  // this path by ensureSystemManagerUncached; selectedWorkDir only drives
+  // workflow-command discovery, not the runtime location.
+  const dir = adminWorkDir();
+  await fs.mkdir(dir, { recursive: true }).catch(() => undefined);
+  return dir;
 }
 
 let systemManagerEnsurePromise: Promise<SystemManagerSummary> | null = null;
@@ -349,52 +379,142 @@ async function ensureSystemManager(): Promise<SystemManagerSummary> {
   return systemManagerEnsurePromise;
 }
 
+/**
+ * Helm Loop bootstrap wrapper. On first open, fetch the ops guide and feed it to
+ * the admin lead session as the first turn so the agent seeds its own CLAUDE.md.
+ * Idempotent + failure-retrying (see AdminLoopInitializer). The bootstrap user
+ * message is also appended to the team inbox so it is visible in the console.
+ * Invoked fire-and-forget from the ensure endpoint — never blocks open.
+ */
+async function ensureAdminLoopInitialized(): Promise<void> {
+  const sessionKey = `${SYSTEM_MANAGER_TEAM_NAME}:lead`;
+  await runAdminLoopInit({
+    getConfig: () => systemManagerConfig.getConfig(),
+    updateConfig: (patch) => systemManagerConfig.updateConfig(patch),
+    fetchGuide: () => httpsGetFollowRedirects(HERMIT_OPS_GUIDE_URL),
+    log: (message) => app.log.warn({ sessionKey }, message),
+    dispatch: async ({ text, messageId }) => {
+      const workDir = await getSystemManagerWorkDir();
+      await svc
+        .appendMessage(SYSTEM_MANAGER_TEAM_NAME, {
+          from: 'user',
+          to: SYSTEM_MANAGER_TEAM_NAME,
+          role: 'user',
+          content: text,
+          meta: { sessionKey, source: 'admin-init' },
+        })
+        .catch((err) =>
+          app.log.warn({ err, sessionKey }, 'helm loop init: append user message failed')
+        );
+      await dispatchDirectCliMessage({
+        teamName: SYSTEM_MANAGER_TEAM_NAME,
+        sessionKey,
+        workDir,
+        from: SYSTEM_MANAGER_TEAM_NAME,
+        to: 'user',
+        text,
+        messageId,
+      });
+      broadcastSse('team-change', { type: 'inbox', teamName: SYSTEM_MANAGER_TEAM_NAME });
+    },
+  });
+}
+
 const conversationTelemetry = new ConversationTelemetryService({
   cc,
   listTeams: () => svc.listTeams(),
   readTeamManifest: (teamName) => svc.readTeamManifest(teamName),
 });
 const localSessionScanner = new LocalSessionScanner();
-
-async function computeTeamStats(
-  workDir: string
-): Promise<{ sessions: number; messages: number; tokens: number; durationMs: number } | undefined> {
-  if (!workDir) return undefined;
-  try {
-    const sessions = await localSessionScanner.scanSummaries(workDir, '');
-    if (sessions.length === 0) return undefined;
-    let tokens = 0;
-    let messages = 0;
-    let earliest: string | null = null;
-    let latest: string | null = null;
-    for (const s of sessions) {
-      tokens += s.inputTokens + s.outputTokens;
-      messages += s.messageCount;
-      if (s.startTime && (!earliest || s.startTime < earliest)) earliest = s.startTime;
-      if (s.endTime && (!latest || s.endTime > latest)) latest = s.endTime;
-    }
-    let durationMs = 0;
-    if (earliest && latest) {
-      durationMs = Date.parse(latest) - Date.parse(earliest);
-      if (durationMs < 0) durationMs = 0;
-    }
-    return { sessions: sessions.length, messages, tokens, durationMs };
-  } catch {
-    return undefined;
+const loopAssetsScanner = new LoopAssetsScannerService();
+const TEAM_STATS_CACHE_TTL_MS = 30_000;
+const teamStatsCache = new Map<
+  string,
+  {
+    expiresAt: number;
+    value: ProjectUsageStats | null;
+    promise?: Promise<ProjectUsageStats | null>;
   }
+>();
+
+function getProjectStatsSnapshot(workDir: string): ProjectUsageStats | null {
+  const normalizedWorkDir = workDir.trim();
+  if (!normalizedWorkDir) return null;
+
+  const now = Date.now();
+  const cached = teamStatsCache.get(normalizedWorkDir);
+  if (cached && cached.expiresAt > now) return cached.value;
+  if (cached?.promise) return cached.value;
+
+  const promise = scanProjectStats(normalizedWorkDir)
+    .catch((err) => {
+      app.log.warn({ err, workDir: normalizedWorkDir }, 'scan project stats failed');
+      return null;
+    })
+    .then((value) => {
+      teamStatsCache.set(normalizedWorkDir, {
+        expiresAt: Date.now() + TEAM_STATS_CACHE_TTL_MS,
+        value,
+      });
+      return value;
+    });
+
+  teamStatsCache.set(normalizedWorkDir, {
+    expiresAt: now + TEAM_STATS_CACHE_TTL_MS,
+    value: cached?.value ?? null,
+    promise,
+  });
+  void promise;
+  return cached?.value ?? null;
 }
 
 async function resolveRouteCcProjectName(teamName: string): Promise<string> {
-  return resolveCcProjectName(teamName, (name) => svc.readTeamManifest(name));
+  return resolveCcProjectName(teamName, (name) => svc.readTeamManifestByProject(name));
+}
+
+async function restartCcConnectAndReconnectBridge(): Promise<void> {
+  await cc.restart();
+
+  // Wait for cc-connect management API to come back (restart only signals, process respawns async).
+  let managementReady = false;
+  for (let i = 0; i < 30; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    try {
+      await cc.listProjects();
+      managementReady = true;
+      break;
+    } catch {
+      /* not back yet */
+    }
+  }
+  if (!managementReady) {
+    throw new Error('cc-connect did not come back within 30s');
+  }
+
+  // After cc-connect restarts, force Hermit's Bridge adapter to reconnect and re-register.
+  // Otherwise Feishu/Lark may show connected in cc-connect but Hermit is not listening yet.
+  bridge.reconnect();
+  await waitForHarnessBridgeConnected(15_000);
 }
 
 const collabBoard = new CollaborationBoardService();
 const taskDispatch = new TaskDispatchService(svc['workspace'], collabBoard);
 
+// Worker Society —— 去中心化 worker 自治社交平台（替代派单的主路径）。
+// 状态持久化到 ~/.hermit/society/（声誉/关系/需求/消息跨重启存活）；REST 路由见下方 registerSocietyRoutes。
+// 成员花名册以 hermit 真实数字员工为单一事实源：注入 listDiscoverableWorkers（GET /api/workers 同款），
+// 社会层身份即真实团队；能力/声誉/并发由 ~/.hermit/society/profiles.json overlay 叠加（MergingProfileStore）。
+const workerSociety = createWorkerSociety(undefined, {
+  realWorkersProvider: listDiscoverableWorkers,
+});
+
 // Broadcast collab board changes via SSE
 taskDispatch.onCollabChange = (dispatchId, status, fromTeam, toTeam) => {
   broadcastSse('collab-change', { dispatchId, status, fromTeam, toTeam });
 };
+taskDispatch.onRuntimeStart = async ({ teamName, text }) => {
+  await sendHarnessMessageViaBridge({ teamName, text });
+};
 
 async function readSavedTaskBusConfig(): Promise<TaskBusConfig | null> {
   try {
@@ -470,6 +590,94 @@ function normalizePlatformAllowFrom(value: unknown): Record<string, string> {
   return Object.fromEntries(entries);
 }
 
+function hasPlatformAllowDeleteMarker(value: unknown): boolean {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+  return Object.entries(value as Record<string, unknown>).some(
+    ([platform, allowFrom]) =>
+      platform.trim().length > 0 && (typeof allowFrom !== 'string' || allowFrom.trim().length === 0)
+  );
+}
+
+function normalizePlatformAllowUpdate(value: unknown): Record<string, string> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  const normalized = normalizePlatformAllowFrom(value);
+  if (Object.keys(normalized).length > 0) {
+    if (normalized.lark !== undefined) delete normalized.feishu;
+    return normalized;
+  }
+  return Object.keys(value).length === 0 || hasPlatformAllowDeleteMarker(value) ? {} : undefined;
+}
+
+function readStringOption(record: Record<string, unknown>, keys: readonly string[]): string {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === 'string' && value.trim().length > 0) return value.trim();
+  }
+  return '';
+}
+
+async function persistPlatformRoutingMetadataForProject(
+  projectName: string,
+  platformType: string,
+  options: Record<string, unknown>
+): Promise<void> {
+  const project = projectName.trim();
+  const platform = platformType.trim();
+  if (!project || !platform) return;
+
+  const allowFrom = readStringOption(options, [
+    'allow_from',
+    'owner_open_id',
+    'owner_user_id',
+    'owner_union_id',
+    'user_id',
+    'open_id',
+  ]);
+  const explicitAllowChat = readStringOption(options, ['allow_chat', 'chat_id', 'open_chat_id']);
+  const allowChat = explicitAllowChat || (allowFrom ? '*' : '');
+  if (!allowFrom && !allowChat) return;
+
+  let teamSlug: string;
+  try {
+    const manifest = await svc.readTeamManifestByProject(project);
+    teamSlug = manifest.slug || project;
+  } catch {
+    teamSlug = project === SYSTEM_MANAGER_BIND_PROJECT ? SYSTEM_MANAGER_TEAM_NAME : project;
+  }
+
+  let existingFrom: Record<string, string> = {};
+  let existingChat: Record<string, string> = {};
+  try {
+    const manifest = await svc.readTeamManifest(teamSlug);
+    existingFrom = normalizePlatformAllowFrom(manifest.platformAllowFrom);
+    existingChat = normalizePlatformAllowFrom(manifest.platformAllowChat);
+  } catch {
+    // Team metadata may not exist for a cc-connect-only project yet.
+  }
+
+  const patch: Record<string, unknown> = {};
+  if (allowFrom) patch.platformAllowFrom = { ...existingFrom, [platform]: allowFrom };
+  if (allowChat) patch.platformAllowChat = { ...existingChat, [platform]: allowChat };
+
+  try {
+    await svc.updateTeam(teamSlug, patch);
+  } catch (err) {
+    app.log.warn(
+      { err, project, teamSlug, platform },
+      'failed to persist platform routing metadata'
+    );
+  }
+}
+
+function isCcProjectNotFoundError(err: unknown): boolean {
+  const message = err instanceof Error ? err.message : String(err);
+  return /project not found:/i.test(message);
+}
+
 // ===========================================================================
 // SSE 客户端管理器 — 广播 bridge 事件到所有连接的前端客户端
 // ===========================================================================
@@ -491,11 +699,148 @@ function broadcastSse(eventName: string, data: unknown): void {
 // 启动 bridge 并把事件广播到 SSE 客户端
 bridge.start();
 
+// ---------------------------------------------------------------------------
+// Direct-CLI execution layer.
+// In-app Loop consoles (admin + team lead) and team-member DMs spawn the local
+// `claude` CLI directly as a long-lived stream-json subprocess, bypassing
+// cc-connect (which is now reserved for external IM). cc-connect's project/
+// work_dir/platform layer was the root cause of "❌ 错误: 启动 Agent 会话失败".
+// Manager events relay to SSE for token-level streaming; the `result` event
+// persists the final reply into the team inbox (same appendMessage path as the
+// bridge reply handler), so the existing renderer refresh Just Works.
+// ---------------------------------------------------------------------------
+const directCliManager = new DirectCliSessionManager();
+
+/** Routes a sessionKey → the team inbox + reply sender/recipient it belongs to. */
+interface DirectCliRoute {
+  teamName: string;
+  /** `from` value persisted on the assistant reply (team name for lead, member name for DM). */
+  from: string;
+  to: string;
+}
+
+const directCliRoutes = new Map<string, DirectCliRoute>();
+
+// Per-team tool-approval settings (auto-allow categories). Synced from the renderer on
+// startup via /api/teams/:name/tool-approval/settings. Defaults deny everything so the user
+// is prompted — matching Claude Code's native cmd permission flow.
+const toolApprovalSettingsByName = new Map<string, ToolApprovalSettings>();
+
+/**
+ * Maps a permission requestId → the DirectCli session it came from (lead or member DM), plus
+ * the toolName/toolInput needed to build the AskUserQuestion `updatedInput` at respond time.
+ */
+interface PendingPermissionApproval {
+  sessionKey: string;
+  toolName?: string;
+  toolInput?: Record<string, unknown>;
+}
+const permissionSessionByRequestId = new Map<string, PendingPermissionApproval>();
+
+function readToolApprovalSettings(teamName: string): ToolApprovalSettings {
+  return toolApprovalSettingsByName.get(teamName) ?? DEFAULT_TOOL_APPROVAL_SETTINGS;
+}
+
+// Auto-allow rules (autoAllowAll / file edits / safe-but-not-dangerous bash) live in the
+// shared, unit-tested `toolApprovalRules` util — copied verbatim from the multi-agent
+// reference impl so the rule set (incl. DANGEROUS_PATTERNS that override safe prefixes,
+// e.g. `git rm`) stays byte-identical. Only `can_use_tool` is a real gate; other control
+// subtypes must be auto-allowed or the stream deadlocks on stdin.
+
+directCliManager.on('event', (event: DirectCliEvent) => {
+  const route = directCliRoutes.get(event.sessionKey);
+  if (!route) return;
+  const { teamName } = route;
+
+  if (event.kind === 'complete') {
+    void (async () => {
+      if (event.text) {
+        await svc
+          .appendMessage(teamName, {
+            // Carry the streaming messageId as the canonical id so the renderer's
+            // optimistic in-progress reply (same messageId) is pruned, not duplicated.
+            id: event.messageId,
+            from: route.from,
+            to: route.to,
+            role: 'agent',
+            content: event.text,
+            meta: { sessionKey: event.sessionKey, source: 'direct-cli' },
+          })
+          .catch((err) =>
+            app.log.warn({ err, sessionKey: event.sessionKey }, 'direct-cli append failed')
+          );
+      }
+      broadcastSse('team-change', { type: 'inbox', teamName });
+    })();
+    return;
+  }
+
+  if (event.kind === 'error') {
+    app.log.warn({ error: event.error, sessionKey: event.sessionKey }, 'direct-cli session error');
+    broadcastSse('team-change', { type: 'inbox', teamName });
+    return;
+  }
+
+  if (event.kind === 'permission-request') {
+    void (async () => {
+      const settings = readToolApprovalSettings(teamName);
+      // Non-`can_use_tool` subtypes (hook_callback, etc.) auto-allow to prevent deadlock;
+      // `can_use_tool` goes through the shared shouldAutoAllow rules.
+      const autoAllow =
+        event.subtype !== 'can_use_tool' ||
+        shouldAutoAllow(settings, event.toolName ?? 'Unknown', event.toolInput ?? {}).autoAllow;
+      if (autoAllow) {
+        try {
+          directCliManager.respondPermission(event.sessionKey, event.requestId, true);
+        } catch (err) {
+          app.log.warn(
+            { err, sessionKey: event.sessionKey },
+            'direct-cli auto-allow respond failed'
+          );
+        }
+        return;
+      }
+      // Surface to the renderer's CC-style approval sheet (Allow / Deny / Allow all). The
+      // user's choice comes back via /api/teams/:name/tool-approval/respond, which writes
+      // the control_response to stdin and unblocks the turn.
+      permissionSessionByRequestId.set(event.requestId, {
+        sessionKey: event.sessionKey,
+        toolName: event.toolName,
+        toolInput: event.toolInput,
+      });
+      broadcastSse('tool-approval-event', {
+        requestId: event.requestId,
+        runId: event.runId,
+        teamName,
+        source: 'lead',
+        toolName: event.toolName ?? 'Unknown',
+        toolInput: event.toolInput ?? {},
+        receivedAt: new Date().toISOString(),
+      } satisfies ToolApprovalRequest);
+    })();
+    return;
+  }
+
+  // init / delta / thinking / tool → live streaming payload for the renderer.
+  broadcastSse('team-change', {
+    type: 'direct-cli-stream',
+    teamName,
+    sessionKey: event.sessionKey,
+    messageId: 'messageId' in event ? event.messageId : undefined,
+    kind: event.kind,
+    text: 'text' in event ? event.text : undefined,
+    toolName: 'toolName' in event ? event.toolName : undefined,
+    toolInput: 'toolInput' in event ? event.toolInput : undefined,
+    from: route.from,
+  });
+});
+
 bridge.on('reply', (msg) => {
   const sessionKey: string = (msg as { session_key?: string }).session_key ?? '';
-  const teamName = resolveTeamFromSessionKey(sessionKey) ?? sessionKey;
 
   void (async () => {
+    const teamName = await resolveTeamFromBridgeMessageWithRetry(msg);
+    if (!teamName) return;
     // 先落盘再广播，否则前端可能在 appendFile 完成前刷新到旧 feed。
     await svc.appendMessage(teamName, {
       from: teamName,
@@ -506,19 +851,20 @@ bridge.on('reply', (msg) => {
     });
     broadcastSse('team-change', { type: 'inbox', teamName });
   })().catch((err) => {
-    app.log.warn({ err, teamName, sessionKey }, 'bridge reply persistence failed');
+    app.log.warn({ err, sessionKey }, 'bridge reply persistence failed');
   });
 });
 
 bridge.on('reply_stream', (msg) => {
   const sessionKey: string = (msg as { session_key?: string }).session_key ?? '';
-  const teamName = resolveTeamFromSessionKey(sessionKey) ?? sessionKey;
   const done = (msg as { done?: boolean }).done ?? false;
 
-  if (done) {
-    // 流式结束，存储完整回复
-    const fullText = (msg as { full_text?: string }).full_text ?? '';
-    void (async () => {
+  void (async () => {
+    const teamName = await resolveTeamFromBridgeMessageWithRetry(msg);
+    if (!teamName) return;
+    if (done) {
+      // 流式结束，存储完整回复
+      const fullText = (msg as { full_text?: string }).full_text ?? '';
       if (fullText) {
         await svc.appendMessage(teamName, {
           from: teamName,
@@ -529,43 +875,148 @@ bridge.on('reply_stream', (msg) => {
         });
       }
       broadcastSse('team-change', { type: 'inbox', teamName });
-    })().catch((err) => {
-      app.log.warn({ err, teamName, sessionKey }, 'bridge stream reply persistence failed');
-    });
-  } else {
+      return;
+    }
     broadcastSse('team-change', { type: 'lead-message', teamName });
-  }
+  })().catch((err) => {
+    app.log.warn({ err, sessionKey }, 'bridge stream reply persistence failed');
+  });
 });
 
 bridge.on('message', (msg) => {
   const type = (msg as { type?: string }).type ?? '';
   const sessionKey: string = (msg as { session_key?: string }).session_key ?? '';
   if (!sessionKey) return; // 无 session_key 的控制帧（pong 等）不广播
-  const teamName = resolveTeamFromSessionKey(sessionKey);
-  if (!teamName) return;
-  // typing_start/stop → lead-message；其他 → inbox
-  const eventType = type === 'typing_start' || type === 'typing_stop' ? 'lead-message' : 'inbox';
-  broadcastSse('team-change', { type: eventType, teamName });
+
+  void (async () => {
+    const teamName = await resolveTeamFromBridgeMessageWithRetry(msg);
+    if (!teamName) return;
+    // typing_start/stop → lead-message；其他 → inbox
+    const eventType = type === 'typing_start' || type === 'typing_stop' ? 'lead-message' : 'inbox';
+    broadcastSse('team-change', { type: eventType, teamName });
+  })().catch((err) => {
+    app.log.warn({ err, sessionKey, type }, 'bridge message routing failed');
+  });
 });
 
+const BRIDGE_SESSION_TEAM_CACHE_TTL_MS = 60_000;
+const EXTERNAL_PLATFORM_ROUTE_RETRY_COUNT = 6;
+const EXTERNAL_PLATFORM_ROUTE_RETRY_DELAY_MS = 1_000;
+const bridgeSessionTeamCache = new Map<string, { teamName: string; expiresAt: number }>();
+
 /**
- * 从 session_key 解析 teamName。
+ * 从 bridge message/session_key 解析 Hermit team slug。
+ *
+ * cc-connect 的外部平台 session_key 通常是 `feishu:{chat}:{user}`，不能当作
+ * Hermit teamName 使用；否则消息会落到 `~/.hermit/teams/feishu:*` 这类错误目录。
+ */
+async function resolveTeamFromBridgeMessage(msg: unknown): Promise<string | null> {
+  const sessionKey = (msg as { session_key?: string }).session_key ?? '';
+  if (!sessionKey) return null;
+
+  const explicitProject = getBridgeMessageProject(msg);
+  if (explicitProject) {
+    const teamName = await resolveTeamSlugFromCcProject(explicitProject);
+    if (teamName) {
+      cacheBridgeSessionTeam(sessionKey, teamName);
+      return teamName;
+    }
+  }
+
+  const parsedTeamName = parseHermitTeamFromSessionKey(sessionKey);
+  if (parsedTeamName) return resolveTeamSlugFromTeamName(parsedTeamName);
+
+  const cached = bridgeSessionTeamCache.get(sessionKey);
+  if (cached && cached.expiresAt > Date.now()) return cached.teamName;
+
+  if (isExternalPlatformSessionKey(sessionKey)) {
+    const teamName = await resolveTeamSlugFromCcSessions(sessionKey);
+    if (teamName) {
+      cacheBridgeSessionTeam(sessionKey, teamName);
+      return teamName;
+    }
+    return null;
+  }
+
+  return resolveTeamSlugFromTeamName(sessionKey);
+}
+
+async function resolveTeamFromBridgeMessageWithRetry(msg: unknown): Promise<string | null> {
+  const sessionKey = (msg as { session_key?: string }).session_key ?? '';
+  if (!isExternalPlatformSessionKey(sessionKey)) return resolveTeamFromBridgeMessage(msg);
+
+  for (let attempt = 0; attempt <= EXTERNAL_PLATFORM_ROUTE_RETRY_COUNT; attempt++) {
+    const teamName = await resolveTeamFromBridgeMessage(msg);
+    if (teamName) return teamName;
+    if (attempt < EXTERNAL_PLATFORM_ROUTE_RETRY_COUNT) {
+      await new Promise((resolve) => setTimeout(resolve, EXTERNAL_PLATFORM_ROUTE_RETRY_DELAY_MS));
+    }
+  }
+
+  app.log.warn(
+    { sessionKey },
+    'external platform bridge message could not be mapped to a Hermit team slug'
+  );
+  return null;
+}
+
+function getBridgeMessageProject(msg: unknown): string {
+  const raw = msg as { project?: unknown; project_name?: unknown };
+  const value = typeof raw.project === 'string' ? raw.project : raw.project_name;
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function cacheBridgeSessionTeam(sessionKey: string, teamName: string): void {
+  bridgeSessionTeamCache.set(sessionKey, {
+    teamName,
+    expiresAt: Date.now() + BRIDGE_SESSION_TEAM_CACHE_TTL_MS,
+  });
+}
+
+async function resolveTeamSlugFromCcProject(projectName: string): Promise<string | null> {
+  try {
+    const manifest = await svc.readTeamManifestByProject(projectName);
+    return manifest.slug || projectName;
+  } catch {
+    return null;
+  }
+}
+
+async function resolveTeamSlugFromTeamName(teamName: string): Promise<string | null> {
+  try {
+    const manifest = await svc.readTeamManifest(teamName);
+    return manifest.slug || teamName;
+  } catch {
+    return teamName;
+  }
+}
+
+async function resolveTeamSlugFromCcSessions(sessionKey: string): Promise<string | null> {
+  const projects = await cc.listProjects().catch(() => []);
+  for (const project of projects) {
+    const sessions = await cc.listSessions(project.name).catch(() => []);
+    if (!sessions.some((session) => session.session_key === sessionKey)) continue;
+    return resolveTeamSlugFromCcProject(project.name);
+  }
+
+  const manifests = await svc.listTeams().catch(() => []);
+  return resolveExternalPlatformSessionTeamSlug(sessionKey, manifests);
+}
+
+/**
+ * 解析 Hermit 自己生成的 session_key。
  * 约定格式:
  *   hermit:{teamName}:session  (老格式)
  *   hermit:{teamName}:lead     (新格式)
  *   bridge:hermit-{team}:{member}
- *   {teamName}                 (直接就是 teamName)
  */
-function resolveTeamFromSessionKey(sessionKey: string): string | null {
+function parseHermitTeamFromSessionKey(sessionKey: string): string | null {
   if (!sessionKey) return null;
-  // hermit:{teamName}:xxx
   const hermitMatch = sessionKey.match(/^hermit:([^:]+):/);
   if (hermitMatch) return hermitMatch[1];
-  // bridge:hermit-{team}:{member}
   const bridgeMatch = sessionKey.match(/^bridge:hermit-([^:]+):/);
   if (bridgeMatch) return bridgeMatch[1];
-  // 否则当成 teamName 本身
-  return sessionKey;
+  return null;
 }
 
 const app = Fastify({
@@ -591,9 +1042,22 @@ const allowedCorsOrigins = configuredCorsOrigins?.length
     ];
 const allowedOriginSet = new Set(allowedCorsOrigins);
 
+function isLoopbackBrowserOrigin(origin: string): boolean {
+  try {
+    const parsed = new URL(origin);
+    return (
+      (parsed.protocol === 'http:' || parsed.protocol === 'https:') &&
+      ['127.0.0.1', 'localhost', '[::1]'].includes(parsed.hostname)
+    );
+  } catch {
+    return false;
+  }
+}
+
 function isTrustedBrowserOrigin(origin: string | undefined): boolean {
   if (!origin) return true;
-  return allowedOriginSet.has(origin);
+  if (allowedOriginSet.has(origin)) return true;
+  return isLoopbackBrowserOrigin(origin);
 }
 
 function assertTrustedBrowserOrigin(request: import('fastify').FastifyRequest): void {
@@ -661,17 +1125,15 @@ async function proxyToCcConnect(
     );
     return reply.code(upstream.status).send({
       ok: false,
-      error: `cc-connect 端点 ${subPath} 返回了非 JSON 响应 (HTTP ${upstream.status})。` +
+      error:
+        `cc-connect 端点 ${subPath} 返回了非 JSON 响应 (HTTP ${upstream.status})。` +
         '请检查 cc-connect 是否正在运行且支持该端点。',
     });
   }
 
   return reply
     .code(upstream.status)
-    .header(
-      'Content-Type',
-      contentType || 'application/json; charset=utf-8'
-    )
+    .header('Content-Type', contentType || 'application/json; charset=utf-8')
     .send(body);
 }
 
@@ -991,18 +1453,8 @@ app.patch<{ Body: Record<string, unknown> }>('/api/cc-settings', async (request)
 // restart / reload cc-connect
 app.post('/api/cc-restart', async () => {
   try {
-    await cc.restart();
-    // Wait for cc-connect to come back (restart only signals, process respawns async)
-    for (let i = 0; i < 30; i++) {
-      await new Promise((r) => setTimeout(r, 1000));
-      try {
-        await cc.listProjects();
-        return { ok: true };
-      } catch {
-        /* not back yet */
-      }
-    }
-    return reply500(new Error('cc-connect did not come back within 30s'));
+    await restartCcConnectAndReconnectBridge();
+    return { ok: true };
   } catch (err) {
     return reply500(err);
   }
@@ -1021,10 +1473,14 @@ app.post('/api/cc-reload', async () => {
 // Teams — cc-connect projects 即团队，本地 ~/.hermit/teams/ 仅存 tasks + 额外元数据
 // ===========================================================================
 
-// POST /api/system-manager/ensure → 确保项目级控制台存在
+// POST /api/system-manager/ensure → 确保项目级 Helm Loop存在
 app.post('/api/system-manager/ensure', async (_request, reply) => {
   try {
-    return await ensureSystemManager();
+    const summary = await ensureSystemManager();
+    // Fire-and-forget the one-shot ops-guide bootstrap. Idempotent (skips once the
+    // marker is set) and retries on fetch failure each time the console opens.
+    void ensureAdminLoopInitialized();
+    return summary;
   } catch (err) {
     return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
   }
@@ -1041,12 +1497,10 @@ app.get('/api/system-manager/status', async (_request, reply) => {
 app.get('/api/system-manager/config', async (_request, reply) => {
   try {
     const config = await systemManagerConfig.getConfig();
-    // Seed builtin workflows into workspace if missing
-    const workspaceWorkflows = config.selectedWorkDir
-      ? path.join(config.selectedWorkDir, 'workflows')
-      : undefined;
-    if (workspaceWorkflows) {
-      void seedBuiltinWorkflows(workspaceWorkflows);
+    // Seed builtin commands into workspace's .claude/commands/ if missing.
+    // Await so the control console can list quick workflow buttons immediately.
+    if (config.selectedWorkDir) {
+      await seedBuiltinWorkflows(config.selectedWorkDir);
     }
     return config;
   } catch (err) {
@@ -1059,7 +1513,7 @@ app.put<{ Body: { selectedWorkDir?: string; workflowFolder?: string | null } }>(
   async (request, reply) => {
     try {
       const config = await systemManagerConfig.updateConfig(request.body ?? {});
-      await syncSystemManagerManifestWorkDir(config.selectedWorkDir);
+      await seedBuiltinWorkflows(config.selectedWorkDir);
       return config;
     } catch (err) {
       return reply.code(400).send({ error: err instanceof Error ? err.message : String(err) });
@@ -1079,126 +1533,157 @@ app.post<{ Body: { folder?: string } }>(
       const result = await workflowPromptService.list(folder);
       await systemManagerConfig.updateConfig({ workflowFolder: result.folder });
       return result;
-    } catch {
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.startsWith('Forbidden origin:')) {
+        return reply.code(403).send({ error: message });
+      }
       return { folder: '', prompts: [], warnings: [] };
     }
   }
 );
 
-app.post<{ Body: { id?: string } }>(
+app.post<{ Body: { folder?: string; id?: string } }>(
   '/api/system-manager/workflows/read',
   async (request, reply) => {
     try {
       assertTrustedBrowserOrigin(request);
       const config = await systemManagerConfig.getConfig();
-      if (!config.workflowFolder)
-        return reply.code(400).send({ error: 'workflowFolder is not configured' });
+      const folder =
+        typeof request.body?.folder === 'string' && request.body.folder.trim().length > 0
+          ? request.body.folder
+          : config.workflowFolder;
+      if (!folder) return reply.code(400).send({ error: 'workflowFolder is not configured' });
       const id = typeof request.body?.id === 'string' ? request.body.id : '';
-      return await workflowPromptService.read(config.workflowFolder, id);
+      return await workflowPromptService.read(folder, id);
     } catch (err) {
       return reply.code(400).send({ error: err instanceof Error ? err.message : String(err) });
     }
   }
 );
 
-app.post<{ Body: { command?: string; args?: string[]; cwd?: string; cols?: number; rows?: number } }>(
-  '/api/terminal/spawn',
-  async (request, reply) => {
-    try {
-      assertTrustedBrowserOrigin(request);
-      const requestedCwd = typeof request.body?.cwd === 'string' ? request.body.cwd.trim() : '';
-      const command = typeof request.body?.command === 'string' ? request.body.command : 'claude';
-      const args = Array.isArray(request.body?.args) ? request.body.args : [];
-
-      // Use requested cwd if provided; otherwise fall back to system manager config
-      let cwd: string;
-      if (requestedCwd) {
-        cwd = requestedCwd;
-        // Update system manager config to track the work dir
-        await systemManagerConfig.updateConfig({ selectedWorkDir: cwd });
-        await syncSystemManagerManifestWorkDir(cwd);
-      } else {
-        const config = await systemManagerConfig.getConfig();
-        cwd = config.selectedWorkDir;
-      }
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
 
-      const ptyId = await systemManagerPty.spawn({
-        command,
-        args,
-        cwd,
-        cols: request.body?.cols,
-        rows: request.body?.rows,
-      });
-      return { ptyId };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return reply
-        .code(message.startsWith('Forbidden origin:') ? 403 : 500)
-        .send({ error: message });
-    }
+function escapeAppleScriptString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function appleScriptStringLiteral(value: string): string {
+  return value
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .split('\n')
+    .map((line) => `"${escapeAppleScriptString(line)}"`)
+    .join(' & linefeed & ');
+}
+
+function execFileAsync(file: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    void import('node:child_process')
+      .then(({ execFile }) => {
+        execFile(file, args, (error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      })
+      .catch(reject);
+  });
+}
+
+function spawnDetached(file: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    void import('node:child_process')
+      .then(({ spawn }) => {
+        const child = spawn(file, args, { detached: true, stdio: 'ignore' });
+        child.once('error', reject);
+        child.once('spawn', () => {
+          child.unref();
+          resolve();
+        });
+      })
+      .catch(reject);
+  });
+}
+
+function cmdQuote(value: string): string {
+  return `"${value.replace(/"/g, '\\"')}"`;
+}
+
+// Launches commands in an external/system terminal only; no embedded terminal mode.
+async function openCommandInSystemTerminal(
+  shellLine: string,
+  windowsShellLine: string
+): Promise<void> {
+  if (process.platform === 'darwin') {
+    const script = `tell application "Terminal"\ndo script ${appleScriptStringLiteral(shellLine)}\nactivate\nend tell`;
+    await execFileAsync('osascript', ['-e', script]);
+    return;
   }
-);
 
-app.post<{ Params: { ptyId: string }; Body: { data?: string } }>(
-  '/api/terminal/:ptyId/write',
-  async (request, reply) => {
-    try {
-      assertTrustedBrowserOrigin(request);
-      systemManagerPty.write(request.params.ptyId, request.body?.data ?? '');
-      return { ok: true };
-    } catch (err) {
-      return reply.code(404).send({ error: err instanceof Error ? err.message : String(err) });
-    }
+  if (process.platform === 'win32') {
+    await spawnDetached('cmd.exe', ['/c', 'start', '', 'cmd.exe', '/k', windowsShellLine]);
+    return;
   }
-);
 
-app.post<{ Params: { ptyId: string }; Body: { cols?: number; rows?: number } }>(
-  '/api/terminal/:ptyId/resize',
-  async (request, reply) => {
+  const candidates = [
+    ...(process.env.TERMINAL
+      ? [{ file: process.env.TERMINAL, args: ['-e', 'sh', '-lc', shellLine] }]
+      : []),
+    { file: 'x-terminal-emulator', args: ['-e', 'sh', '-lc', shellLine] },
+    { file: 'gnome-terminal', args: ['--', 'sh', '-lc', shellLine] },
+    { file: 'konsole', args: ['-e', 'sh', '-lc', shellLine] },
+    { file: 'xfce4-terminal', args: ['-e', 'sh', '-lc', shellLine] },
+    { file: 'alacritty', args: ['-e', 'sh', '-lc', shellLine] },
+    { file: 'kitty', args: ['sh', '-lc', shellLine] },
+    { file: 'wezterm', args: ['start', '--', 'sh', '-lc', shellLine] },
+  ];
+
+  const errors: string[] = [];
+  for (const candidate of candidates) {
     try {
-      assertTrustedBrowserOrigin(request);
-      systemManagerPty.resize(
-        request.params.ptyId,
-        request.body?.cols ?? 120,
-        request.body?.rows ?? 34
-      );
-      return { ok: true };
+      await spawnDetached(candidate.file, candidate.args);
+      return;
     } catch (err) {
-      return reply.code(403).send({ error: err instanceof Error ? err.message : String(err) });
+      errors.push(`${candidate.file}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-);
-
-app.delete<{ Params: { ptyId: string } }>('/api/terminal/:ptyId', async (request, reply) => {
-  try {
-    assertTrustedBrowserOrigin(request);
-    await systemManagerPty.kill(request.params.ptyId);
-    return { ok: true };
-  } catch (err) {
-    return reply.code(403).send({ error: err instanceof Error ? err.message : String(err) });
-  }
-});
+  throw new Error(`No system terminal launcher succeeded. ${errors.join('; ')}`);
+}
 
-// POST /api/terminal/open-external — open command in system Terminal.app
+// POST /api/terminal/open-external — open command in an external/system terminal
 app.post<{ Body: { command: string; args?: string[]; cwd?: string } }>(
   '/api/terminal/open-external',
   async (request, reply) => {
     try {
+      assertTrustedBrowserOrigin(request);
       const { command, args = [], cwd } = request.body ?? {};
       if (!command) return reply.code(400).send({ error: 'command is required' });
-      const cmd = [command, ...args].join(' ');
-      const script = cwd
-        ? `tell application "Terminal"\ndo script "cd ${cwd.replace(/"/g, '\\"')} && ${cmd.replace(/"/g, '\\"')}"\nactivate\nend tell`
-        : `tell application "Terminal"\ndo script "${cmd.replace(/"/g, '\\"')}"\nactivate\nend tell`;
-      const { execFile } = await import('node:child_process');
-      execFile('osascript', ['-e', script]);
+      const normalizedArgs = Array.isArray(args)
+        ? args.filter((arg) => typeof arg === 'string')
+        : [];
+      const cmd = [command, ...normalizedArgs].map(shellQuote).join(' ');
+      const shellLine = cwd ? `cd ${shellQuote(cwd)} && ${cmd}` : cmd;
+      const windowsCmd = [command, ...normalizedArgs].map(cmdQuote).join(' ');
+      const windowsShellLine = cwd ? `cd /d ${cmdQuote(cwd)} && ${windowsCmd}` : windowsCmd;
+      await openCommandInSystemTerminal(shellLine, windowsShellLine);
       return { ok: true };
     } catch (err) {
-      return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+      const message = err instanceof Error ? err.message : String(err);
+      return reply
+        .code(message.startsWith('Forbidden origin:') ? 403 : 500)
+        .send({ error: message });
     }
   }
 );
 
+// Worker Society REST 路由（/api/society/*）—— worker 自治社会的 HTTP 接口（workers/needs/social/feed）。
+registerSocietyRoutes(app, workerSociety);
+
 // GET /api/teams → Hermit 本地团队优先，裸 cc-connect project 作为历史兼容显示；过滤飞书/系统项目
 app.get('/api/teams', async () => {
   try {
@@ -1224,21 +1709,14 @@ app.get('/api/teams', async () => {
         .map(async (meta) => {
           const bindProject = meta.bindProject || meta.slug;
           const project = projectByName.get(bindProject);
-          const isOnline = Array.isArray(project?.platforms) && project.platforms.length > 0;
-          let workDir = (meta.workDir || '').trim();
-          if (!workDir && project) {
-            try {
-              const detail = await cc.getProject(bindProject);
-              if (typeof detail.work_dir === 'string' && detail.work_dir.trim()) {
-                workDir = detail.work_dir.trim();
-              }
-            } catch {
-              // ignore detail read failure, keep manifest/default path
-            }
-          }
+          // Keep the list endpoint fast: per-team cc.getProject calls are slow and
+          // block first paint. Runtime liveness is loaded separately via aliveList.
+          const workDir = (meta.workDir || '').trim();
+          const projectPath = (meta.workDir || '').trim();
           const harness = toCcAgentType(project?.agent_type || meta.harness);
           const color = meta.color || 'blue';
           const displayName = meta.displayName || meta.slug;
+          const usageStats = workDir ? getProjectStatsSnapshot(workDir) : null;
 
           return {
             teamName: meta.slug,
@@ -1249,16 +1727,27 @@ app.get('/api/teams', async () => {
             members: [{ name: displayName, role: 'agent', agentId: harness, color }],
             taskCount: 0,
             lastActivity: null,
-            isAlive: isOnline,
+            isAlive: false,
             harness,
             bindProject,
             workDir,
-            projectPath: workDir || undefined,
+            projectPath: projectPath || undefined,
             sessionsCount: project?.sessions_count ?? 0,
             heartbeatEnabled: project?.heartbeat_enabled ?? false,
             pendingDelete: meta.pendingDelete === true,
             restartRequired: meta.restartRequired === true,
-            stats: await computeTeamStats(workDir),
+            stats: usageStats
+              ? {
+                  sessions: usageStats.sessions,
+                  messages: usageStats.messages,
+                  tokens: usageStats.totalTokens,
+                  tokensIn: usageStats.tokensIn,
+                  tokensOut: usageStats.tokensOut,
+                  cacheRead: usageStats.cacheRead,
+                  cacheCreation: usageStats.cacheCreation,
+                  durationMs: usageStats.durationMs,
+                }
+              : undefined,
           };
         })
     );
@@ -1453,7 +1942,7 @@ app.get<{ Params: { name: string } }>('/api/teams/:name/data', async (request, r
         disabledCommands: resolvedDisabledCommands,
         platformAllowFrom: resolvedPlatformAllowFrom,
         platformAllowChat: resolvedPlatformAllowChat,
-        projectPath: p.work_dir ?? workDir,
+        projectPath: workDir || p.work_dir,
         members: [{ name: displayName, role: 'lead' }],
       },
       tasks: teamTasks,
@@ -1511,6 +2000,7 @@ app.get<{ Params: { name: string } }>('/api/teams/:name/data', async (request, r
         managedSources,
         disabledCommands,
         platformAllowFrom,
+        platformAllowChat,
         projectPath: workDir,
         members: [{ name: displayName, role: 'lead' }],
       },
@@ -1547,6 +2037,7 @@ app.get<{ Params: { name: string } }>('/api/teams/:name/data', async (request, r
         reply_footer: replyFooter,
         inject_sender: injectSender,
         platform_allow_from: platformAllowFrom,
+        platform_allow_chat: platformAllowChat,
       },
       activeSessions: [],
     };
@@ -1572,21 +2063,39 @@ app.delete<{ Params: { name: string }; Querystring: { deleteFiles?: string } }>(
   async (request, reply) => {
     const teamName = request.params.name;
     if (isReservedSystemTeamName(teamName)) {
-      return reply.code(403).send({ error: '控制台不可删除' });
+      return reply.code(403).send({ error: 'Helm Loop 不可删除' });
     }
     try {
       let restartRequired = false;
+      let ccProjectName = teamName;
+      let localTeamName = teamName;
       try {
-        const result = await cc.deleteProject(teamName);
+        const manifest = await svc.readTeamManifestByProject(teamName);
+        ccProjectName = manifest.bindProject || teamName;
+        localTeamName = manifest.slug || teamName;
+      } catch {
+        // Team may only exist in cc-connect or local metadata may already be gone.
+      }
+      if (isReservedSystemTeamName(ccProjectName) || isReservedSystemTeamName(localTeamName)) {
+        return reply.code(403).send({ error: 'Helm Loop 不可删除' });
+      }
+      try {
+        const result = await cc.deleteProject(ccProjectName);
         restartRequired = result.restart_required === true;
       } catch (err) {
-        request.log.warn({ err, teamName }, 'delete cc-connect project failed or project missing');
+        request.log.warn(
+          { err, teamName, ccProjectName },
+          'delete cc-connect project failed or project missing'
+        );
       }
 
       try {
-        await svc.deleteTeam(teamName, { deleteFiles: request.query.deleteFiles === 'true' });
+        await svc.deleteTeam(localTeamName, { deleteFiles: request.query.deleteFiles === 'true' });
       } catch (err) {
-        request.log.warn({ err, teamName }, 'delete local team metadata failed or already missing');
+        request.log.warn(
+          { err, teamName, localTeamName },
+          'delete local team metadata failed or already missing'
+        );
       }
 
       return { ok: true, restartRequired };
@@ -1599,7 +2108,7 @@ app.delete<{ Params: { name: string }; Querystring: { deleteFiles?: string } }>(
 // ===========================================================================
 // Tasks — 存储在 ~/.hermit/teams/:name/tasks/board.json
 // 双向映射：TeamTask(pending/in_progress/completed) ↔ Task(todo/doing/done)
-// assignee 变化时触发 Task Dispatcher（Bridge 推消息给目标团队 agent）
+// 任务创建/指派只更新看板；只有显式点击开始才投递给 runtime/目标团队。
 // ===========================================================================
 
 /** TeamTask status → internal Task status */
@@ -1609,6 +2118,13 @@ function toTaskStatus(s: string): 'todo' | 'doing' | 'done' {
   return 'todo';
 }
 
+function isManualInProgressExitBlocked(
+  currentStatus: string | undefined,
+  nextStatus: 'todo' | 'doing' | 'done' | undefined
+): boolean {
+  return currentStatus === 'doing' && nextStatus !== undefined && nextStatus !== 'doing';
+}
+
 /** internal Task → TeamTask shape (for UI consumption) */
 function toTeamTask(task: {
   id: string;
@@ -1651,36 +2167,6 @@ function activeTasks<T extends { result?: string | null }>(tasks: T[]): T[] {
   return tasks.filter((task) => !isSoftDeletedTask(task));
 }
 
-function mapCcSessionDetail(detail: {
-  id: string;
-  name: string;
-  session_key: string;
-  agent_session_id?: string;
-  agent_type: string;
-  active: boolean;
-  live: boolean;
-  history_count: number;
-  created_at: string;
-  updated_at: string;
-  platform: string;
-  history: { role: 'user' | 'assistant'; content: string; timestamp: string }[];
-}) {
-  return {
-    id: detail.id,
-    name: detail.name,
-    sessionKey: detail.session_key,
-    agentSessionId: detail.agent_session_id,
-    agentType: detail.agent_type,
-    active: detail.active,
-    live: detail.live,
-    historyCount: detail.history_count,
-    createdAt: detail.created_at,
-    updatedAt: detail.updated_at,
-    platform: detail.platform,
-    history: detail.history ?? [],
-  };
-}
-
 app.get<{ Params: { name: string } }>('/api/teams/:name/tasks', async (request) => {
   try {
     const tasks = activeTasks(await svc.readTasks(request.params.name));
@@ -1703,33 +2189,34 @@ app.post<{ Params: { name: string }; Body: Record<string, unknown> }>(
       assignee: (body.owner ?? body.assignee) as string | null | undefined,
       status: body.status ? toTaskStatus(body.status as string) : 'todo',
     });
-    if (task.assignee) {
-      svc
-        .dispatchTask(request.params.name, task)
-        .catch((err) => request.log.warn({ err }, 'dispatchTask failed'));
-    }
     return toTeamTask(task);
   }
 );
 
 app.patch<{ Params: { name: string; id: string }; Body: Record<string, unknown> }>(
   '/api/teams/:name/tasks/:id',
-  async (request) => {
+  async (request, reply) => {
     const body = request.body ?? {};
     const patch: Record<string, unknown> = {};
+    const nextStatus = body.status !== undefined ? toTaskStatus(body.status as string) : undefined;
     if (body.subject !== undefined) patch.title = body.subject;
     if (body.title !== undefined) patch.title = body.title;
     if (body.description !== undefined) patch.description = body.description;
-    if (body.status !== undefined) patch.status = toTaskStatus(body.status as string);
+    if (nextStatus !== undefined) patch.status = nextStatus;
     if (body.owner !== undefined) patch.assignee = body.owner;
     if (body.assignee !== undefined) patch.assignee = body.assignee;
     if (body.result !== undefined) patch.result = body.result;
-    const task = await svc.patchTask(request.params.name, request.params.id, patch);
-    if (patch.assignee && task.assignee) {
-      svc
-        .dispatchTask(request.params.name, task)
-        .catch((err) => request.log.warn({ err }, 'dispatchTask failed'));
+
+    const tasks = await svc.readTasks(request.params.name);
+    const existingTask = tasks.find((task) => task.id === request.params.id);
+    if (isManualInProgressExitBlocked(existingTask?.status, nextStatus)) {
+      return reply.code(409).send({
+        ok: false,
+        error: 'Agent 正在处理中，不能手动完成或取消。请等待 agent 调用 complete_task。',
+      });
     }
+
+    const task = await svc.patchTask(request.params.name, request.params.id, patch);
     return toTeamTask(task);
   }
 );
@@ -1738,6 +2225,14 @@ app.delete<{ Params: { name: string; id: string } }>(
   '/api/teams/:name/tasks/:id',
   async (request, reply) => {
     try {
+      const tasks = await svc.readTasks(request.params.name);
+      const existingTask = tasks.find((task) => task.id === request.params.id);
+      if (existingTask?.status === 'doing') {
+        return reply.code(409).send({
+          ok: false,
+          error: 'Agent 正在处理中，不能手动删除任务。',
+        });
+      }
       await svc.patchTask(request.params.name, request.params.id, {
         status: 'done',
         result: '__deleted__',
@@ -1870,7 +2365,279 @@ app.get('/api/harnesses', async () => {
     }));
   } catch {
     // cc-connect 不可达时返回完整枚举列表
-    return CC_AGENT_TYPES.map((type) => ({ type, inUse: false }));
+    return CC_AGENT_TYPES.map((type) => ({
+      type,
+      inUse: false,
+    }));
+  }
+});
+
+function mapCcSessionListItem(session: CcSessionListItem, projectId: string): CcSession {
+  return {
+    id: session.agent_session_id || session.id,
+    title: session.name || session.session_key,
+    projectId,
+    sessionKey: session.session_key,
+    platform: session.platform,
+    userName: session.user_name ?? null,
+    chatName: session.chat_name ?? null,
+    active: session.active,
+    live: session.live,
+    historyCount: session.history_count,
+    createdAt: session.created_at,
+    updatedAt: session.updated_at,
+    lastMessage: session.last_message
+      ? {
+          role: session.last_message.role,
+          content: session.last_message.content,
+          timestamp: session.last_message.timestamp,
+        }
+      : null,
+  };
+}
+
+app.get<{ Params: { name: string } }>('/api/teams/:name/loop-assets', async (request, reply) => {
+  try {
+    const name = request.params.name;
+    const manifest = await svc.readTeamManifest(name);
+    let bindProject = manifest.bindProject || name;
+    let workDir = manifest.workDir || '';
+    let platforms: { type: string; connected?: boolean }[] = [];
+
+    try {
+      bindProject = await resolveRouteCcProjectName(name);
+      const project = await cc.getProject(bindProject).catch(() => null);
+      if (!workDir && project?.work_dir) workDir = project.work_dir;
+      platforms = Array.isArray(project?.platforms)
+        ? project.platforms.map((platform) => ({
+            type: platform.type,
+            connected: platform.connected,
+          }))
+        : [];
+    } catch {
+      /* Local manifest data is enough for a best-effort scan. */
+    }
+
+    const [tasks, messages] = await Promise.all([
+      svc.readTasks(name).catch(() => []),
+      svc.readMessages(name).catch(() => []),
+    ]);
+
+    return await loopAssetsScanner.scanTeam({
+      teamName: name,
+      displayName: manifest.displayName,
+      bindProject,
+      workDir,
+      teamRoot: manifest.rootPath,
+      memberCount: 1,
+      taskCount: activeTasks(tasks).length,
+      messageCount: messages.length,
+      platforms,
+    });
+  } catch (err) {
+    return reply.code(404).send({ error: err instanceof Error ? err.message : String(err) });
+  }
+});
+
+async function ensureLoopSessionProjectReady(teamName: string): Promise<{
+  bindProject: string;
+  projectExists: boolean;
+  isOnline: boolean;
+}> {
+  if (teamName === SYSTEM_MANAGER_TEAM_NAME) {
+    await ensureSystemManager();
+  }
+
+  let manifest: TeamManifest | null = null;
+  try {
+    manifest = await svc.readTeamManifestByProject(teamName);
+  } catch {
+    // Route name may already be a cc-connect project name.
+  }
+
+  const bindProject = manifest?.bindProject?.trim() || teamName;
+  let projectExists = false;
+  let isOnline = false;
+  let workDir = manifest?.workDir?.trim() || '';
+  const harness = manifest?.harness || 'claudecode';
+  const platformType = manifest?.platform || 'bridge';
+  const platformOptions = manifest?.platformOptions ?? {};
+
+  let projectWorkDir = '';
+  try {
+    const project = await cc.getProject(bindProject);
+    projectExists = true;
+    isOnline =
+      Array.isArray(project.platforms) && project.platforms.some((platform) => platform.connected);
+    if (typeof project.work_dir === 'string') projectWorkDir = project.work_dir.trim();
+    // Only inherit the project's work_dir when the manifest has none AND it isn't the
+    // cc-connect default template placeholder — adopting the placeholder would keep the
+    // agent pointed at a non-existent directory and break every session.
+    if (!workDir && !isPlaceholderWorkDir(projectWorkDir)) {
+      workDir = projectWorkDir;
+    }
+  } catch {
+    // Project can be missing after cc-connect reset; create it below when possible.
+  }
+
+  // Reconcile work_dir: cc-connect spawns the agent with chdir(work_dir), so a stale or
+  // placeholder work_dir makes every session fail with "启动 Agent 会话失败" — the session
+  // record is created (so the user sees the success message) but the agent never starts.
+  // This runs whether or not the project is "online": the Helm Loop's bind project is
+  // `my-project`, which is online via bridge yet still carries the template placeholder
+  // work_dir, so the isOnline branch below would skip it. The PATCH updates the live agent
+  // immediately and persists to config.toml (no restart required).
+  if (projectExists && workDir && needsWorkDirReconcile(projectWorkDir, workDir)) {
+    try {
+      await cc.updateProject(bindProject, { work_dir: workDir });
+      projectWorkDir = workDir;
+    } catch (err) {
+      app.log.warn({ err, bindProject, workDir }, 'cc-connect work_dir reconcile failed');
+    }
+  }
+
+  if (!isOnline) {
+    if (!projectExists) {
+      if (!workDir) {
+        throw new Error('团队缺少项目路径，无法启动 Loop runtime');
+      }
+      await cc.createProject(
+        bindProject,
+        harness,
+        workDir,
+        platformType,
+        platformOptions as Record<string, string>
+      );
+      projectExists = true;
+    }
+
+    await restartCcConnectAndReconnectBridge();
+    try {
+      const project = await cc.getProject(bindProject);
+      isOnline =
+        Array.isArray(project.platforms) &&
+        project.platforms.some((platform) => platform.connected);
+    } catch {
+      isOnline = false;
+    }
+  }
+
+  return { bindProject, projectExists, isOnline };
+}
+
+/**
+ * Resolve the work_dir for a direct-CLI session WITHOUT cc-connect side effects (no
+ * project create / restart). Prefers the team manifest's workDir; falls back to the
+ * cc-connect project work_dir only when it is a real path (never the template
+ * placeholder). The system-manager workDir is synced into its manifest from the runtime
+ * config, so this reads the same source for admin and team loops.
+ */
+async function resolveDirectCliWorkDir(teamName: string): Promise<string> {
+  if (teamName === SYSTEM_MANAGER_TEAM_NAME) {
+    await ensureSystemManager().catch(() => undefined);
+  }
+  let manifest: TeamManifest | null = null;
+  try {
+    manifest = await svc.readTeamManifestByProject(teamName);
+  } catch {
+    // Route name may already be a cc-connect project name.
+  }
+  const manifestWorkDir = manifest?.workDir?.trim() || '';
+  if (manifestWorkDir) return manifestWorkDir;
+  try {
+    const bindProject = manifest?.bindProject?.trim() || teamName;
+    const project = await cc.getProject(bindProject);
+    if (typeof project.work_dir === 'string') {
+      const dir = project.work_dir.trim();
+      if (dir && !isPlaceholderWorkDir(dir)) return dir;
+    }
+  } catch {
+    // Project may not exist — that's fine for direct-CLI.
+  }
+  return '';
+}
+
+/**
+ * Register a direct-CLI session route and dispatch a user turn to it. The subprocess
+ * spawns lazily (resuming a persisted claude session when possible) and this resolves
+ * once the turn is on stdin; the streamed reply arrives later via the manager event
+ * listener above.
+ */
+async function dispatchDirectCliMessage(params: {
+  teamName: string;
+  sessionKey: string;
+  workDir: string;
+  from: string;
+  to: string;
+  text: string;
+  messageId: string;
+}): Promise<void> {
+  directCliRoutes.set(params.sessionKey, {
+    teamName: params.teamName,
+    from: params.from,
+    to: params.to,
+  });
+  await directCliManager.send(params.sessionKey, {
+    text: params.text,
+    messageId: params.messageId,
+    workDir: params.workDir,
+  });
+}
+
+app.post<{
+  Params: { name: string };
+  Body: { sessionName?: unknown; message?: unknown; reuse?: unknown };
+}>('/api/teams/:name/loop-session', async (request, reply) => {
+  try {
+    const teamName = request.params.name;
+    const message = typeof request.body?.message === 'string' ? request.body.message.trim() : '';
+    const reuse = request.body?.reuse === true;
+    const requestedSessionName =
+      typeof request.body?.sessionName === 'string' ? request.body.sessionName.trim() : '';
+    const sessionName =
+      requestedSessionName || `Loop ${new Date().toISOString().replace(/[:.]/g, '-')}`;
+
+    const workDir = await resolveDirectCliWorkDir(teamName);
+    if (!workDir) {
+      return reply.code(400).send({ error: '团队缺少项目路径，无法启动 Loop runtime' });
+    }
+
+    // One long-lived lead subprocess per team, resumed across sends (--resume keeps the
+    // claude conversation continuous, like an interactive terminal session).
+    const sessionKey = `${teamName}:lead`;
+    // "Reused" means the claude conversation continues (--resume), which is true
+    // whenever a session id is known — in-memory OR persisted in the store. The
+    // in-memory-only `has()` would wrongly report false right after a Hermit
+    // restart even though the subprocess resumes the same conversation.
+    const reused = reuse && directCliManager.getSessionId(sessionKey) != null;
+
+    let messageSent = false;
+    if (message) {
+      const messageId = buildDirectReplyMessageId(sessionKey);
+      await dispatchDirectCliMessage({
+        teamName,
+        sessionKey,
+        workDir,
+        from: teamName,
+        to: 'user',
+        text: message,
+        messageId,
+      });
+      messageSent = true;
+    }
+
+    return {
+      session: {
+        id: directCliManager.getSessionId(sessionKey) ?? sessionKey,
+        name: sessionName,
+        session_key: sessionKey,
+        title: sessionName,
+      },
+      reused,
+      messageSent,
+    };
+  } catch (err) {
+    return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
   }
 });
 
@@ -1888,12 +2655,12 @@ app.post<{ Params: { name: string }; Body: Partial<TeamLaunchRequest> }>(
       const body = request.body ?? {};
       let manifest: TeamManifest | null = null;
       try {
-        manifest = await svc.readTeamManifest(name);
+        manifest = await svc.readTeamManifestByProject(name);
       } catch {
         // Team may only exist in cc-connect.
       }
       const bindProject = manifest?.bindProject ?? name;
-      const workDir = body.cwd ?? manifest?.workDir ?? '';
+      let workDir = body.cwd ?? manifest?.workDir ?? '';
       const harness = manifest?.harness ?? 'claudecode';
       const platformType = manifest?.platform ?? 'bridge';
       const platformOptions = manifest?.platformOptions ?? {};
@@ -1921,14 +2688,21 @@ app.post<{ Params: { name: string }; Body: Partial<TeamLaunchRequest> }>(
               platformOptions as Record<string, string>
             );
             projectExists = true;
-          } catch { /* CC Connect project creation is best-effort */ }
+          } catch {
+            /* CC Connect project creation is best-effort */
+          }
         }
         // Restart cc-connect to (re-)activate platform connections.
         // Covers: newly created project, existing project with disconnected platform,
         // Feishu/Lark IM that lost connection after cc-connect restart, etc.
         try {
-          await cc.restart();
-        } catch { /* restart is best-effort */ }
+          await restartCcConnectAndReconnectBridge();
+        } catch (err) {
+          request.log.warn(
+            { err, bindProject },
+            'cc-connect restart/bridge reconnect failed during team launch'
+          );
+        }
       }
 
       return {
@@ -1948,7 +2722,9 @@ app.post<{ Params: { name: string } }>('/api/teams/:name/stop', async (request)
   // Stop = delete project from cc-connect (best-effort, no restart)
   try {
     await cc.deleteProject(bindProject);
-  } catch { /* project may not exist in cc-connect */ }
+  } catch {
+    /* project may not exist in cc-connect */
+  }
   // Keep local team metadata intact by not deleting it
   // The team will show as offline (isAlive: false) on next data fetch
   return { ok: true };
@@ -1998,16 +2774,27 @@ app.post('/api/setup/feishu/poll', async (request, reply) => {
 
 app.post('/api/setup/feishu/save', async (request, reply) => {
   try {
-    const result = await (
-      await fetch(`${runtimeConfig.ccBaseUrl}/api/v1/setup/feishu/save`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          ...(runtimeConfig.ccToken ? { Authorization: `Bearer ${runtimeConfig.ccToken}` } : {}),
-        },
-        body: JSON.stringify(request.body ?? {}),
-      })
-    ).json();
+    const requestBody = (request.body ?? {}) as Record<string, unknown>;
+    const response = await fetch(`${runtimeConfig.ccBaseUrl}/api/v1/setup/feishu/save`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(runtimeConfig.ccToken ? { Authorization: `Bearer ${runtimeConfig.ccToken}` } : {}),
+      },
+      body: JSON.stringify(requestBody),
+    });
+    const result = (await response.json()) as { data?: unknown; error?: unknown };
+    if (!response.ok) {
+      return reply.code(response.status).send(result);
+    }
+    const resultData = result && typeof result.data === 'object' ? result.data : result;
+    if (resultData && typeof resultData === 'object' && !('error' in resultData)) {
+      await persistPlatformRoutingMetadataForProject(
+        typeof requestBody.project === 'string' ? requestBody.project : '',
+        typeof requestBody.platform_type === 'string' ? requestBody.platform_type : 'feishu',
+        requestBody
+      );
+    }
     return result;
   } catch (err) {
     return reply500(err);
@@ -2053,16 +2840,27 @@ app.post('/api/setup/weixin/poll', async (request, reply) => {
 
 app.post('/api/setup/weixin/save', async (request, reply) => {
   try {
-    const result = await (
-      await fetch(`${runtimeConfig.ccBaseUrl}/api/v1/setup/weixin/save`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          ...(runtimeConfig.ccToken ? { Authorization: `Bearer ${runtimeConfig.ccToken}` } : {}),
-        },
-        body: JSON.stringify(request.body ?? {}),
-      })
-    ).json();
+    const requestBody = (request.body ?? {}) as Record<string, unknown>;
+    const response = await fetch(`${runtimeConfig.ccBaseUrl}/api/v1/setup/weixin/save`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(runtimeConfig.ccToken ? { Authorization: `Bearer ${runtimeConfig.ccToken}` } : {}),
+      },
+      body: JSON.stringify(requestBody),
+    });
+    const result = (await response.json()) as { data?: unknown; error?: unknown };
+    if (!response.ok) {
+      return reply.code(response.status).send(result);
+    }
+    const resultData = result && typeof result.data === 'object' ? result.data : result;
+    if (resultData && typeof resultData === 'object' && !('error' in resultData)) {
+      await persistPlatformRoutingMetadataForProject(
+        typeof requestBody.project === 'string' ? requestBody.project : '',
+        'weixin',
+        requestBody
+      );
+    }
     return result;
   } catch (err) {
     return reply500(err);
@@ -2075,14 +2873,31 @@ app.post<{
   Body: { type: string; options?: Record<string, unknown>; work_dir?: string; agent_type?: string };
 }>('/api/projects/:name/add-platform', async (request, reply) => {
   try {
+    const existingProject = await cc.getProject(request.params.name).catch(() => null);
     const result = await cc.createProject(
       request.params.name,
-      request.body.agent_type ?? 'claudecode',
-      request.body.work_dir ?? '',
+      request.body.agent_type ?? existingProject?.agent_type ?? 'claudecode',
+      request.body.work_dir ?? existingProject?.work_dir ?? '',
       request.body.type,
       (request.body.options ?? {}) as Record<string, string>
     );
-    return result;
+
+    await persistPlatformRoutingMetadataForProject(
+      request.params.name,
+      request.body.type,
+      request.body.options ?? {}
+    );
+
+    if (result.restart_required) {
+      // Adding Feishu/Lark/other platform engines only writes cc-connect config; a restart is
+      // required before cc-connect listens to the new long-connection and Hermit must reconnect
+      // its Bridge adapter after that restart. Do it here so callers cannot accidentally leave
+      // cc-connect showing “connected” while Hermit is not listening.
+      await restartCcConnectAndReconnectBridge();
+      return { ok: true, data: { ...result, restart_required: false, restart_handled: true } };
+    }
+
+    return { ok: true, data: { ...result, restart_handled: false } };
   } catch (err) {
     return reply500(err);
   }
@@ -2263,6 +3078,8 @@ const MCP_TOOLS = [
       required: ['team_slug', 'dispatch_id', 'feedback'],
     },
   },
+  // Worker Society —— 去中心化自治社会的 MCP 工具（society_* 命名空间）。
+  ...SOCIETY_MCP_TOOLS,
 ];
 
 /** 执行 MCP tool，返回 content array */
@@ -2272,12 +3089,28 @@ async function executeMcpTool(
 ): Promise<{ type: string; text: string }[]> {
   const text = async (result: unknown) => [{ type: 'text', text: JSON.stringify(result, null, 2) }];
 
+  // Worker Society 工具（society_*）：命中即返回，未命中回退到既有派单/任务工具。
+  const societyResult = await executeSocietyMcpTool(toolName, args, workerSociety);
+  if (societyResult) return societyResult;
+
   if (toolName === 'list_tasks') {
     const tasks = await svc.readTasks(args.team_slug);
     return text(tasks);
   }
 
   if (toolName === 'claim_task') {
+    const tasks = await svc.readTasks(args.team_slug);
+    const existingTask = tasks.find((task) => task.id === args.task_id);
+    if (
+      existingTask?.dispatchMeta &&
+      existingTask.status === 'todo' &&
+      ['received', 'pending_accept'].includes(existingTask.dispatchMeta.status)
+    ) {
+      return text({
+        ok: false,
+        error: 'Cross-team tasks must be started from the target team TODO board by clicking 启动.',
+      });
+    }
     const task = await svc.patchTask(args.team_slug, args.task_id, { status: 'doing' });
     return text(task);
   }
@@ -2413,8 +3246,10 @@ app.post<{
 // Hermit 主仓 UI 首屏强依赖的几个 stub(占位实现)
 // ===========================================================================
 
-// hermit getAppVersion 期望返回字符串(不是数组),通配 stub 给的 [] 会让 JSON.parse 后类型对不上
-app.get('/api/version', async () => pkg.version);
+// hermit getAppVersion 期望返回 JSON 字符串；Fastify 直接 send(string) 会按 text/plain 返回。
+app.get('/api/version', async (_request, reply) =>
+  reply.type('application/json').send(JSON.stringify(pkg.version))
+);
 
 // GET /api/update/check — 检查是否有新版本
 const updateService = new UpdateService();
@@ -2556,9 +3391,10 @@ function readAppConfig() {
       return mergeConfigDefaults(DEFAULT_APP_CONFIG, raw);
     }
   } catch (err) {
-    const msg = err instanceof SyntaxError
-      ? `${HERMIT_APP_CONFIG_FILE} 格式错误: ${err.message}。将使用默认配置并覆盖修复。`
-      : `读取 ${HERMIT_APP_CONFIG_FILE} 失败`;
+    const msg =
+      err instanceof SyntaxError
+        ? `${HERMIT_APP_CONFIG_FILE} 格式错误: ${err.message}。将使用默认配置并覆盖修复。`
+        : `读取 ${HERMIT_APP_CONFIG_FILE} 失败`;
     app.log.warn({ err }, msg);
     // Auto-heal: rewrite with valid defaults
     try {
@@ -2693,13 +3529,14 @@ async function sendHarnessMessageViaBridge(params: {
   await waitForHarnessBridgeConnected();
 
   const sessionKey = params.sessionKey?.trim() || buildFallbackSessionKey(params.teamName);
+  const projectName = await resolveRouteCcProjectName(params.teamName);
   bridge.sendUserMessage({
     sessionKey,
     userId: 'hermit-user',
     userName: 'User',
     content: params.text,
     msgId: params.msgId,
-    project: params.teamName,
+    project: projectName,
   });
   return sessionKey;
 }
@@ -2774,7 +3611,10 @@ function mapCronJobToSchedule(
   let nextRunAt: string | undefined;
   if (cronJob.enabled && isNonEmptyString(cronJob.cron_expr)) {
     try {
-      const job = new Cron(cronJob.cron_expr.trim(), { timezone: DEFAULT_SCHEDULE_TIMEZONE, paused: true });
+      const job = new Cron(cronJob.cron_expr.trim(), {
+        timezone: DEFAULT_SCHEDULE_TIMEZONE,
+        paused: true,
+      });
       const next = job.nextRun();
       if (next) {
         nextRunAt = (next instanceof Date ? next : new Date(next)).toISOString();
@@ -2899,7 +3739,6 @@ app.post<{ Body: Record<string, unknown> }>('/api/schedules', async (request, re
         .code(400)
         .send({ error: 'teamName、cronExpression、launchConfig.prompt 不能为空' });
     }
-
     const created = await cc.createCronJob({
       project: teamName,
       session_key: sessionKey,
@@ -3237,25 +4076,23 @@ app.post<{ Body: { dirPath?: string } }>('/api/workspace/list', async (request)
 
   try {
     const entries = readdirSync(target, { withFileTypes: true });
-    const files = entries
-      .slice(0, 500)
-      .map((e) => {
-        const fullPath = path.join(target, e.name);
-        const isDirectory = e.isDirectory();
-        let size = 0;
-        try {
-          const stat = statSync(fullPath);
-          size = stat.size;
-        } catch {
-          /* ignore */
-        }
-        return {
-          name: e.name,
-          isDirectory,
-          size,
-          ext: isDirectory ? '' : path.extname(e.name).slice(1).toLowerCase(),
-        };
-      });
+    const files = entries.slice(0, 500).map((e) => {
+      const fullPath = path.join(target, e.name);
+      const isDirectory = e.isDirectory();
+      let size = 0;
+      try {
+        const stat = statSync(fullPath);
+        size = stat.size;
+      } catch {
+        /* ignore */
+      }
+      return {
+        name: e.name,
+        isDirectory,
+        size,
+        ext: isDirectory ? '' : path.extname(e.name).slice(1).toLowerCase(),
+      };
+    });
     return { path: target, files, hasParent: target !== path.dirname(target) };
   } catch {
     return { path: target, files: [], hasParent: false, error: `无法访问目录: ${target}` };
@@ -3725,63 +4562,38 @@ app.get<{ Params: { name: string } }>('/api/teams/:name/sessions', async (reques
     const workDir = team.workDir || team.bindProject || request.params.name;
     const localSessions = await localSessionScanner.scanSummaries(workDir, request.params.name);
 
-    // Attempt to merge cc-connect identity metadata (platform/chatName/userName/lastMessage)
-    let ccById = new Map<string, { platform: string; userName: string | null; chatName: string | null; lastMessage: { role: string; content: string; timestamp: string } | null }>();
+    // Merge cc-connect sessions into the response. External platform sessions (Feishu/Lark/etc.)
+    // may not have a local Claude JSONL yet, but users still expect to see them as listening sessions.
+    let ccSessions: CcSessionListItem[] = [];
     try {
       const bindProject = await resolveRouteCcProjectName(request.params.name);
-      const ccSessions = await cc.listSessions(bindProject);
-      for (const s of ccSessions) {
-        ccById.set(s.id, {
-          platform: s.platform,
-          userName: s.user_name ?? null,
-          chatName: s.chat_name ?? null,
-          lastMessage: s.last_message
-            ? { role: s.last_message.role, content: s.last_message.content, timestamp: s.last_message.timestamp }
-            : null,
-        });
-      }
-    } catch { /* cc-connect unavailable — local-only data */ }
+      ccSessions = await cc.listSessions(bindProject);
+    } catch {
+      /* cc-connect unavailable — local-only data */
+    }
 
-    return localSessions.map((s) => {
-      const ccMeta = ccById.get(s.id);
-      return {
-        id: s.id,
-        title: s.title || s.id,
-        projectId: request.params.name,
-        sessionKey: s.id,
-        platform: ccMeta?.platform ?? 'local',
-        userName: ccMeta?.userName ?? null,
-        chatName: ccMeta?.chatName ?? null,
-        active: s.active,
-        live: s.live,
-        historyCount: s.messageCount,
-        createdAt: s.createdAt,
-        updatedAt: s.updatedAt,
-        lastMessage: ccMeta?.lastMessage ?? null,
-      };
-    });
+    return mergeLocalAndCcSessions(localSessions, ccSessions, request.params.name);
   } catch {
     return [];
   }
 });
 
 // GET session detail — read local JSONL file for session history with pagination
-app.get<{ Params: { name: string; sessionId: string }; Querystring: { history_limit?: string; offset?: string } }>(
-  '/api/teams/:name/sessions/:sessionId',
-  async (request, reply) => {
-    const limit = request.query.history_limit
-      ? parseInt(request.query.history_limit, 10)
-      : 500;
-    const offset = request.query.offset
-      ? parseInt(request.query.offset, 10)
-      : 0;
-    const team = await svc.readTeamManifest(request.params.name);
-    const workDir = team.workDir || team.bindProject || request.params.name;
-    const detail = await localSessionScanner.readSessionDetail(workDir, request.params.sessionId, { offset, limit });
-    if (!detail) return reply.code(404).send({ error: 'Session not found' });
-    return detail;
-  }
-);
+app.get<{
+  Params: { name: string; sessionId: string };
+  Querystring: { history_limit?: string; offset?: string };
+}>('/api/teams/:name/sessions/:sessionId', async (request, reply) => {
+  const limit = request.query.history_limit ? parseInt(request.query.history_limit, 10) : 500;
+  const offset = request.query.offset ? parseInt(request.query.offset, 10) : 0;
+  const team = await svc.readTeamManifest(request.params.name);
+  const workDir = team.workDir || team.bindProject || request.params.name;
+  const detail = await localSessionScanner.readSessionDetail(workDir, request.params.sessionId, {
+    offset,
+    limit,
+  });
+  if (!detail) return reply.code(404).send({ error: 'Session not found' });
+  return detail;
+});
 
 // DELETE session — 关闭 cc-connect live session，使其从运行中转为历史会话。
 app.delete<{ Params: { name: string; sessionId: string } }>(
@@ -3842,15 +4654,8 @@ app.post<{ Params: { name: string }; Body: { text?: string; message?: string } }
     try {
       const text = request.body?.text ?? request.body?.message ?? '';
       if (text) {
-        let targetProject = request.params.name;
-        try {
-          const manifest = await svc.readTeamManifest(request.params.name);
-          targetProject = manifest.bindProject || request.params.name;
-        } catch {
-          // request.params.name may already be a cc-connect project name.
-        }
         await sendHarnessMessageViaBridge({
-          teamName: targetProject,
+          teamName: request.params.name,
           text,
         });
       }
@@ -3904,8 +4709,16 @@ app.get('/api/teams/tasks', async () => {
 // 团队任务子操作 — 全部委托给 svc.patchTask
 app.post<{ Params: { name: string; id: string } }>(
   '/api/teams/:name/tasks/:id/request-review',
-  async (request) => {
+  async (request, reply) => {
     try {
+      const tasks = await svc.readTasks(request.params.name);
+      const existingTask = tasks.find((task) => task.id === request.params.id);
+      if (existingTask?.status === 'doing') {
+        return reply.code(409).send({
+          ok: false,
+          error: 'Agent 正在处理中，不能手动提交审核。请等待 agent 调用 complete_task。',
+        });
+      }
       const task = await svc.patchTask(request.params.name, request.params.id, { status: 'done' });
       return { ok: true, data: toTeamTask(task) };
     } catch {
@@ -3922,12 +4735,24 @@ app.patch<{ Params: { name: string; id: string }; Body: Record<string, unknown>
 );
 app.patch<{ Params: { name: string; id: string }; Body: { status?: string } }>(
   '/api/teams/:name/tasks/:id/status',
-  async (request) => {
+  async (request, reply) => {
     try {
       const { status } = request.body ?? {};
+      const nextStatus = status ? toTaskStatus(status) : undefined;
+      const tasks = await svc.readTasks(request.params.name);
+      const existingTask = tasks.find((task) => task.id === request.params.id);
+      if (isManualInProgressExitBlocked(existingTask?.status, nextStatus)) {
+        return reply.code(409).send({
+          ok: false,
+          error: 'Agent 正在处理中，不能手动完成或取消。请等待 agent 调用 complete_task。',
+        });
+      }
       const task = await svc.patchTask(request.params.name, request.params.id, {
-        status: status ? toTaskStatus(status) : undefined,
+        status: nextStatus,
       });
+      if (task.dispatchMeta && task.status === 'done') {
+        await taskDispatch.onTaskCompleted(request.params.name, request.params.id).catch(() => {});
+      }
       return toTeamTask(task);
     } catch {
       return { ok: true };
@@ -3942,9 +4767,6 @@ app.patch<{ Params: { name: string; id: string }; Body: { owner?: string } }>(
       const task = await svc.patchTask(request.params.name, request.params.id, {
         assignee: body.owner ?? null,
       });
-      if (task.assignee) {
-        svc.dispatchTask(request.params.name, task).catch(() => {});
-      }
       return toTeamTask(task);
     } catch {
       return { ok: true };
@@ -3970,9 +4792,16 @@ app.post<{ Params: { name: string; id: string } }>(
   '/api/teams/:name/tasks/:id/start',
   async (request) => {
     try {
+      const existingTasks = await svc.readTasks(request.params.name);
+      const existingTask = existingTasks.find((task) => task.id === request.params.id);
+      if (existingTask?.dispatchMeta) {
+        await taskDispatch.startDispatchedTask(request.params.name, request.params.id);
+        return { notifiedOwner: true, crossTeamStarted: true };
+      }
+
       const task = await svc.patchTask(request.params.name, request.params.id, { status: 'doing' });
       if (task.assignee) {
-        svc.dispatchTask(request.params.name, task).catch(() => {});
+        await svc.dispatchTask(request.params.name, task).catch(() => {});
         return { notifiedOwner: true };
       }
       return { notifiedOwner: false };
@@ -3985,9 +4814,16 @@ app.post<{ Params: { name: string; id: string } }>(
   '/api/teams/:name/tasks/:id/start-by-user',
   async (request) => {
     try {
+      const existingTasks = await svc.readTasks(request.params.name);
+      const existingTask = existingTasks.find((task) => task.id === request.params.id);
+      if (existingTask?.dispatchMeta) {
+        await taskDispatch.startDispatchedTask(request.params.name, request.params.id);
+        return { notifiedOwner: true, crossTeamStarted: true };
+      }
+
       const task = await svc.patchTask(request.params.name, request.params.id, { status: 'doing' });
       if (task.assignee) {
-        svc.dispatchTask(request.params.name, task).catch(() => {});
+        await svc.dispatchTask(request.params.name, task).catch(() => {});
         return { notifiedOwner: true };
       }
       return { notifiedOwner: false };
@@ -4000,6 +4836,14 @@ app.post<{ Params: { name: string; id: string } }>(
   '/api/teams/:name/tasks/:id/soft-delete',
   async (request, reply) => {
     try {
+      const tasks = await svc.readTasks(request.params.name);
+      const existingTask = tasks.find((task) => task.id === request.params.id);
+      if (existingTask?.status === 'doing') {
+        return reply.code(409).send({
+          ok: false,
+          error: 'Agent 正在处理中，不能手动删除任务。',
+        });
+      }
       await svc.patchTask(request.params.name, request.params.id, {
         status: 'done',
         result: '__deleted__',
@@ -4094,18 +4938,17 @@ async function applyTeamConfigUpdate(
   const providerRefs = Array.isArray(body.providerRefs)
     ? normalizeStringArray(body.providerRefs)
     : undefined;
-  const platformAllowFrom = body.platformAllowFrom
-    ? normalizePlatformAllowFrom(body.platformAllowFrom)
-    : undefined;
-  const platformAllowChat = body.platformAllowChat
-    ? normalizePlatformAllowFrom(body.platformAllowChat)
-    : undefined;
+  const platformAllowFrom = normalizePlatformAllowUpdate(body.platformAllowFrom);
+  const platformAllowChat = normalizePlatformAllowUpdate(body.platformAllowChat);
 
-  // Validate agent type CLI availability before saving
+  // Validate agent type before checking CLI availability.
+  if (agentType && !CC_AGENT_TYPES.includes(agentType as CcAgentType)) {
+    throw new Error(`${agentType} 不是支持的运行时类型。`);
+  }
   if (agentType && agentType !== 'claudecode') {
     try {
-      const { execSync } = await import('node:child_process');
-      execSync(`which ${agentType}`, { stdio: 'pipe', timeout: 5000 });
+      const { execFileSync } = await import('node:child_process');
+      execFileSync('which', [agentType], { stdio: 'pipe', timeout: 5000 });
     } catch {
       throw new Error(
         `${agentType} CLI 未安装，无法切换到 ${agentType} 模式。请先安装对应的 CLI 工具。`
@@ -4118,7 +4961,9 @@ async function applyTeamConfigUpdate(
   if (description) localPatch.description = description;
   if (color) localPatch.color = color;
   if (agentType) localPatch.harness = agentType;
-  if (workDir) localPatch.workDir = workDir;
+  if (workDir) {
+    localPatch.workDir = workDir;
+  }
   if (permissionMode) localPatch.permissionMode = permissionMode;
   if (language) localPatch.language = language;
   if (managedSources) localPatch.managedSources = managedSources;
@@ -4168,6 +5013,7 @@ async function applyTeamConfigUpdate(
   } catch {
     bindProject = teamName;
   }
+
   if (Object.keys(ccPatch).length > 0) {
     try {
       const updateResult = await cc.updateProject(
@@ -4175,17 +5021,25 @@ async function applyTeamConfigUpdate(
         ccPatch as Parameters<CcConnectClient['updateProject']>[1]
       );
       if (updateResult.restart_required) {
-        try { await cc.reload(); } catch { /* best effort */ }
+        try {
+          await cc.reload();
+        } catch {
+          /* best effort */
+        }
       }
     } catch (err) {
-      ccSyncError = err instanceof Error ? err.message : String(err);
+      if (!isCcProjectNotFoundError(err)) {
+        ccSyncError = err instanceof Error ? err.message : String(err);
+      }
     }
   }
   if (providerRefs !== undefined) {
     try {
       await cc.setProviderRefs(bindProject, providerRefs);
     } catch (err) {
-      ccSyncError = err instanceof Error ? err.message : String(err);
+      if (!isCcProjectNotFoundError(err)) {
+        ccSyncError = err instanceof Error ? err.message : String(err);
+      }
     }
   }
 
@@ -4204,6 +5058,7 @@ async function applyTeamConfigUpdate(
     replyFooter: replyFooter ?? false,
     injectSender: injectSender ?? false,
     platformAllowFrom: platformAllowFrom ?? {},
+    platformAllowChat: platformAllowChat ?? {},
     providerRefs: providerRefs ?? [],
     ccSyncError,
   };
@@ -4295,7 +5150,7 @@ app.get<{ Params: { name: string } }>('/api/teams/:name/config', async (request,
     return {
       name,
       color,
-      projectPath: p.work_dir ?? '',
+      projectPath: p.work_dir || '',
       description,
       agentType: p.agent_type,
       workDir: p.work_dir ?? '',
@@ -4319,6 +5174,7 @@ app.get<{ Params: { name: string } }>('/api/teams/:name/config', async (request,
         reply_footer: resolvedReplyFooter,
         inject_sender: resolvedInjectSender,
         platform_allow_from: resolvedPlatformAllowFrom,
+        platform_allow_chat: resolvedPlatformAllowChat,
       },
     };
   } catch {
@@ -4412,6 +5268,7 @@ app.post<{
           { deadlineMinutes: 10, needsHumanReview: true }
         );
         broadcastSse('team-change', { type: 'inbox', teamName });
+        broadcastSse('team-change', { type: 'task', teamName: targetTeam });
         broadcastSse('collab-change', {
           dispatchId: result.dispatchId,
           status: result.status,
@@ -4420,14 +5277,15 @@ app.post<{
         });
         return {
           ok: result.status !== 'failed',
-          deliveredToInbox: true,
+          deliveredToInbox: false,
           messageId: sourceMsg.id,
           dispatchId: result.dispatchId,
           status: result.status,
           message: result.message,
           runtimeDelivery: {
-            attempted: true,
-            delivered: result.status !== 'failed',
+            attempted: false,
+            delivered: false,
+            reason: 'waiting_for_target_start',
           },
         };
       } catch (err) {
@@ -4445,6 +5303,7 @@ app.post<{
   // 本地存储用户消息
   const userMsg = await svc
     .appendMessage(teamName, {
+      id: msgId,
       from: 'user',
       to: teamName,
       role: 'user',
@@ -4456,16 +5315,37 @@ app.post<{
   // 广播 SSE 让前端触发消息刷新
   broadcastSse('team-change', { type: 'inbox', teamName });
 
-  const bridgeWasConnected = bridge.connected;
-  void sendHarnessMessageViaBridge({
-    teamName,
-    text,
-    sessionKey,
-    msgId,
-  }).catch((err) => {
-    request.log.warn({ err, teamName, sessionKey }, 'send-message bridge delivery failed');
-    broadcastSse('team-change', { type: 'inbox', teamName });
-  });
+  // Member DM: dispatch to the local claude CLI directly (bypass cc-connect). One
+  // subprocess per member, resumed across messages. The reply streams back via the
+  // manager event listener and is persisted on the turn's `result` event. cc-connect's
+  // bridge stays reserved for external IM (Feishu/WeChat).
+  const member = typeof request.body?.member === 'string' ? request.body.member.trim() : '';
+  const directSessionKey = `${teamName}:member:${member || 'lead'}`;
+  const memberWorkDir = await resolveDirectCliWorkDir(teamName).catch(() => '');
+  const dispatchedDirect = Boolean(memberWorkDir);
+  if (dispatchedDirect) {
+    void dispatchDirectCliMessage({
+      teamName,
+      sessionKey: directSessionKey,
+      workDir: memberWorkDir,
+      from: member || teamName,
+      to: 'user',
+      text,
+      // The agent reply needs its OWN id — distinct from the user message's
+      // `msgId`. Reusing `msgId` persisted the reply with the user message's id,
+      // colliding in the inbox so the renderer's id-keyed dedup dropped it
+      // (the team-3ond "回复的没了" bug).
+      messageId: buildDirectReplyMessageId(directSessionKey),
+    }).catch((err) => {
+      request.log.warn(
+        { err, teamName, sessionKey: directSessionKey },
+        'send-message direct-cli delivery failed'
+      );
+      broadcastSse('team-change', { type: 'inbox', teamName });
+    });
+  } else {
+    request.log.warn({ teamName }, 'send-message direct-cli skipped: no work_dir resolved');
+  }
 
   return {
     ok: true,
@@ -4473,7 +5353,7 @@ app.post<{
     messageId: userMsg?.id ?? msgId,
     runtimeDelivery: {
       attempted: true,
-      delivered: bridgeWasConnected,
+      delivered: dispatchedDirect,
     },
   };
 });
@@ -4485,8 +5365,16 @@ app.post<{
 // requestReview: 前端调用 /tasks/:id/review，服务端原路由是 /tasks/:id/request-review
 app.post<{ Params: { name: string; id: string } }>(
   '/api/teams/:name/tasks/:id/review',
-  async (request) => {
+  async (request, reply) => {
     try {
+      const tasks = await svc.readTasks(request.params.name);
+      const existingTask = tasks.find((task) => task.id === request.params.id);
+      if (existingTask?.status === 'doing') {
+        return reply.code(409).send({
+          ok: false,
+          error: 'Agent 正在处理中，不能手动提交审核。请等待 agent 调用 complete_task。',
+        });
+      }
       const task = await svc.patchTask(request.params.name, request.params.id, { status: 'done' });
       return { ok: true, data: toTeamTask(task) };
     } catch {
@@ -4606,6 +5494,8 @@ app.get<{ Params: { name: string; memberName: string } }>(
       let inputTokens = 0;
       let outputTokens = 0;
       let cacheReadTokens = 0;
+      let cacheCreationTokens = 0;
+      let totalTokens = 0;
       let messageCount = 0;
       let totalDurationMs = 0;
 
@@ -4616,6 +5506,8 @@ app.get<{ Params: { name: string; memberName: string } }>(
         inputTokens += s.inputTokens;
         outputTokens += s.outputTokens;
         cacheReadTokens += s.cacheReadTokens;
+        cacheCreationTokens += s.cacheCreationTokens;
+        totalTokens += s.totalTokens;
         messageCount += s.messageCount;
 
         if (s.startTime && (!earliestStart || s.startTime < earliestStart)) {
@@ -4649,6 +5541,8 @@ app.get<{ Params: { name: string; memberName: string } }>(
         inputTokens,
         outputTokens,
         cacheReadTokens,
+        cacheCreationTokens,
+        totalTokens,
         costUsd: 0,
         tasksCompleted,
         messageCount,
@@ -4666,6 +5560,8 @@ app.get<{ Params: { name: string; memberName: string } }>(
         inputTokens: 0,
         outputTokens: 0,
         cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        totalTokens: 0,
         costUsd: 0,
         tasksCompleted: 0,
         messageCount: 0,
@@ -4677,14 +5573,79 @@ app.get<{ Params: { name: string; memberName: string } }>(
   }
 );
 
-// tool-approval stubs
-app.post<{ Params: { name: string } }>('/api/teams/:name/tool-approval/respond', async () => ({
-  ok: true,
-}));
-app.post<{ Params: { name: string } }>('/api/teams/:name/tool-approval/settings', async () => ({
-  ok: true,
-}));
-app.post('/api/teams/tool-approval/read-file', async () => ({ content: '' }));
+// tool-approval: write the user's Allow/Deny choice back to the subprocess as a
+// control_response, unblocking the turn so it can emit `result` and persist the reply.
+app.post<{
+  Params: { name: string };
+  Body: { runId?: unknown; requestId?: unknown; allow?: unknown; message?: unknown };
+}>('/api/teams/:name/tool-approval/respond', async (request, reply) => {
+  const teamName = request.params.name;
+  const requestId = typeof request.body?.requestId === 'string' ? request.body.requestId : '';
+  const allow = request.body?.allow === true;
+  const message =
+    typeof request.body?.message === 'string' && request.body.message.trim()
+      ? request.body.message
+      : undefined;
+  if (!requestId) return reply.code(400).send({ ok: false, error: 'requestId required' });
+  const pending = permissionSessionByRequestId.get(requestId);
+  const sessionKey = pending?.sessionKey ?? `${teamName}:lead`;
+  // AskUserQuestion: pass the user's answers via updatedInput so the CLI delivers them
+  // without re-prompting (mirrors the multi-agent reference impl + --permission-prompt-tool spec).
+  let updatedInput: Record<string, unknown> | undefined;
+  if (allow && message && pending?.toolName === 'AskUserQuestion') {
+    const toolInput = pending.toolInput ?? {};
+    try {
+      updatedInput = { ...toolInput, answers: JSON.parse(message) as Record<string, string> };
+    } catch {
+      // If message isn't JSON, use it as the answer to the first question.
+      const questions = (toolInput.questions as { question?: string }[] | undefined) ?? [];
+      const answers: Record<string, string> = {};
+      if (questions[0]?.question) answers[questions[0].question] = message;
+      updatedInput = { ...toolInput, answers };
+    }
+  }
+  try {
+    directCliManager.respondPermission(sessionKey, requestId, allow, message, updatedInput);
+  } catch (err) {
+    app.log.warn({ err, sessionKey, requestId }, 'tool-approval respond failed');
+  }
+  permissionSessionByRequestId.delete(requestId);
+  return { ok: true };
+});
+
+// tool-approval: persist auto-allow settings per team (in-memory; renderer re-syncs on startup).
+app.post<{ Params: { name: string }; Body: Partial<ToolApprovalSettings> }>(
+  '/api/teams/:name/tool-approval/settings',
+  async (request) => {
+    const teamName = request.params.name;
+    const incoming = request.body ?? {};
+    const prev = readToolApprovalSettings(teamName);
+    toolApprovalSettingsByName.set(teamName, {
+      autoAllowAll: incoming.autoAllowAll ?? prev.autoAllowAll,
+      autoAllowFileEdits: incoming.autoAllowFileEdits ?? prev.autoAllowFileEdits,
+      autoAllowSafeBash: incoming.autoAllowSafeBash ?? prev.autoAllowSafeBash,
+      timeoutAction: incoming.timeoutAction ?? prev.timeoutAction,
+      timeoutSeconds: incoming.timeoutSeconds ?? prev.timeoutSeconds,
+    });
+    return { ok: true };
+  }
+);
+
+// tool-approval: read a file for the Edit/Write diff preview. Local-first, best-effort —
+// errors return empty content so the approval sheet still renders without the diff.
+app.post<{ Body: { filePath?: unknown } }>(
+  '/api/teams/tool-approval/read-file',
+  async (request) => {
+    const filePath = typeof request.body?.filePath === 'string' ? request.body.filePath : '';
+    if (!filePath) return { content: '' };
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return { content };
+    } catch {
+      return { content: '' };
+    }
+  }
+);
 
 // validate-cli-args
 app.post('/api/teams/validate-cli-args', async () => ({ valid: true, args: [], errors: [] }));
@@ -4743,6 +5704,110 @@ app.get<{ Querystring: { excludeTeam?: string } }>('/api/cross-team/targets', as
   }));
 });
 
+async function listDiscoverableWorkers(): Promise<DiscoverableWorker[]> {
+  const teams = await taskDispatch.discoverTeams();
+  return teams
+    .filter((team) => team.slug !== SYSTEM_MANAGER_TEAM_NAME && team.location === 'local')
+    .map(discoverableTeamToWorker)
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+app.get('/api/workers', async () => {
+  return { workers: await listDiscoverableWorkers() };
+});
+
+app.post<{
+  Params: { workerId: string };
+  Body: {
+    fromTeam?: string;
+    text?: unknown;
+    summary?: unknown;
+    sessionName?: unknown;
+    reuse?: unknown;
+    sessionKey?: unknown;
+  };
+}>('/api/workers/:workerId/invoke', async (request, reply) => {
+  try {
+    const workerId = request.params.workerId.trim();
+    const resolvedWorkerId = await resolveTeamSlugForMention(workerId);
+    if (!resolvedWorkerId || resolvedWorkerId === SYSTEM_MANAGER_TEAM_NAME) {
+      return reply.code(404).send({ error: `Unknown worker: ${workerId}` });
+    }
+
+    const workers = await listDiscoverableWorkers();
+    const worker = workers.find((entry) => entry.workerId === resolvedWorkerId);
+    if (!worker) return reply.code(404).send({ error: `Unknown worker: ${workerId}` });
+
+    const message = typeof request.body?.text === 'string' ? request.body.text.trim() : '';
+    if (!message) return reply.code(400).send({ error: 'text is required' });
+
+    const requestedSessionName =
+      typeof request.body?.sessionName === 'string' ? request.body.sessionName.trim() : '';
+    const summary = typeof request.body?.summary === 'string' ? request.body.summary.trim() : '';
+    const sessionName =
+      requestedSessionName ||
+      summary ||
+      `Admin Invoke ${new Date().toISOString().replace(/[:.]/g, '-')}`;
+    const reuse = request.body?.reuse !== false;
+    const fromTeam = typeof request.body?.fromTeam === 'string' ? request.body.fromTeam.trim() : '';
+    const fromSessionKey =
+      typeof request.body?.sessionKey === 'string' && request.body.sessionKey.trim().length > 0
+        ? request.body.sessionKey.trim()
+        : buildFallbackSessionKey(fromTeam || SYSTEM_MANAGER_TEAM_NAME);
+
+    const { bindProject } = await ensureLoopSessionProjectReady(resolvedWorkerId);
+    const sessionKey = `${buildFallbackSessionKey(resolvedWorkerId)}:${Date.now().toString(36)}`;
+    const sessions = reuse ? await cc.listSessions(bindProject).catch(() => []) : [];
+    let session = reuse
+      ? sessions.find((item) => item.name === sessionName && (item.live || item.active))
+      : undefined;
+    const reused = Boolean(session);
+    if (!session) {
+      const created = await cc.createSession(bindProject, sessionName, sessionKey);
+      session = {
+        id: created.id,
+        name: created.name || sessionName,
+        session_key: created.session_key || sessionKey,
+        agent_session_id: created.agent_session_id,
+        agent_type: created.agent_type,
+        active: created.active,
+        live: created.live,
+        history_count: created.history_count,
+        created_at: created.created_at,
+        updated_at: created.updated_at,
+        last_message: null,
+        platform: created.platform,
+      };
+    }
+
+    await sendHarnessMessageViaBridge({
+      teamName: resolvedWorkerId,
+      text: message,
+      sessionKey: session.session_key,
+    });
+    if (fromTeam) {
+      await svc.appendMessage(fromTeam, {
+        from: `${fromTeam}.user`,
+        to: resolvedWorkerId,
+        role: 'user',
+        content: `@${resolvedWorkerId} ${message}`,
+        meta: { source: CROSS_TEAM_SENT_SOURCE, sessionKey: fromSessionKey, summary },
+      });
+      broadcastSse('team-change', { type: 'inbox', teamName: fromTeam });
+    }
+    broadcastSse('team-change', { type: 'inbox', teamName: resolvedWorkerId });
+    return {
+      ok: true,
+      worker,
+      session: mapCcSessionListItem(session, resolvedWorkerId),
+      reused,
+      messageSent: true,
+    };
+  } catch (err) {
+    return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+  }
+});
+
 app.get<{ Params: { name: string } }>('/api/cross-team/outbox/:name', async (request) => {
   const teamSlug = request.params.name;
   const tasks = await svc.readTasks(teamSlug);
@@ -4897,11 +5962,6 @@ app.post<{
       typeof sessionKey === 'string' && sessionKey.trim().length > 0
         ? sessionKey.trim()
         : buildFallbackSessionKey(fromTeam);
-    const toSessionKey = buildFallbackSessionKey(resolvedToTeam);
-    const sentText = formatCrossTeamText(`${fromTeam}.${sender}`, depth, trimmedText, {
-      conversationId: threadId,
-      replyToConversationId,
-    });
     const meta = {
       taskRefs,
       actionMode,
@@ -4919,53 +5979,35 @@ app.post<{
       meta: { ...meta, source: CROSS_TEAM_SENT_SOURCE, sessionKey: fromSessionKey },
     });
 
-    await svc.appendMessage(resolvedToTeam, {
-      from: `${fromTeam}.${sender}`,
-      to: resolvedToTeam,
-      role: 'user',
-      content: sentText,
-      meta: {
-        ...meta,
-        source: CROSS_TEAM_SOURCE,
-        relayOfMessageId: outgoing.id,
-        sessionKey: toSessionKey,
-      },
-    });
-
-    const existingTasks = await svc.readTasks(resolvedToTeam).catch(() => []);
-    const existingTask = existingTasks.find((task) => task.dispatchMeta?.dispatchId === threadId);
-    if (!existingTask) {
-      const now = new Date().toISOString();
-      await svc.createTask(resolvedToTeam, {
-        title: summary || trimmedText.split(/\r?\n/, 1)[0]?.slice(0, 120) || '跨团队 @ 消息',
+    // Do not write the relayed message into the target inbox here. Cross-team
+    // transfer must first create a target TODO/review surface; the target inbox or
+    // runtime should only receive content after the user explicitly starts it.
+    const dispatchResult = await taskDispatch.dispatchTask(
+      fromTeam,
+      {
+        subject: summary || trimmedText.split(/\r?\n/, 1)[0]?.slice(0, 120) || '跨团队 @ 消息',
         description: trimmedText,
-        status: 'todo',
-        dispatchMeta: {
-          dispatchId: threadId,
-          originTeam: fromTeam,
-          targetTeam: resolvedToTeam,
-          status: 'pending_accept',
-          dispatchedAt: now,
-          receivedAt: now,
-        },
-      });
+        prompt: trimmedText,
+      },
+      resolvedToTeam,
+      { dispatchId: threadId, needsHumanReview: needsHumanReview ?? true }
+    );
+    if (dispatchResult.status === 'failed') {
+      return { ok: false, error: dispatchResult.message };
     }
 
     broadcastSse('team-change', { type: 'inbox', teamName: fromTeam });
-    broadcastSse('team-change', { type: 'inbox', teamName: resolvedToTeam });
     broadcastSse('team-change', { type: 'task', teamName: resolvedToTeam });
 
-    void sendHarnessMessageViaBridge({
-      teamName: resolvedToTeam,
-      text: sentText,
-    }).catch((err) => {
-      request.log.warn({ err }, 'cross-team runtime delivery failed after persistence');
-    });
-
     return {
       messageId: outgoing.id,
-      deliveredToInbox: true,
+      deliveredToInbox: false,
       deduplicated: false,
+      runtimeDelivery: {
+        attempted: false,
+        delivered: false,
+        reason: 'waiting_for_target_start',
+      },
     };
   }
 
@@ -4984,21 +6026,6 @@ app.post<{
   });
   broadcastSse('team-change', { type: 'inbox', teamName: fromTeam });
 
-  // Check collaboration toggle
-  try {
-    const configPath = path.join(os.homedir(), '.hermit', 'settings.json');
-    const raw = await fs.readFile(configPath, 'utf-8');
-    const settings = JSON.parse(raw);
-    if (!settings.taskBus?.collaboration) {
-      return {
-        ok: false,
-        error: 'Distributed collaboration is not enabled. Enable it in Settings → Task Bus.',
-      };
-    }
-  } catch {
-    return { ok: false, error: 'Could not read task bus configuration.' };
-  }
-
   const result = await taskDispatch.dispatchTask(
     fromTeam ?? 'unknown',
     { subject, description, prompt },
@@ -5011,15 +6038,7 @@ app.post<{
   const ok = result.status !== 'failed';
   if (ok) {
     broadcastSse('team-change', { type: 'inbox', teamName: resolvedToTeam });
-    void sendHarnessMessageViaBridge({
-      teamName: resolvedToTeam,
-      text: `[跨团队任务] ${fromTeam} 派发了任务：${subject}${description ? `\n\n${description}` : ''}`,
-    }).catch((err) => {
-      request.log.warn(
-        { err, fromTeam, resolvedToTeam },
-        'cross-team task runtime delivery failed'
-      );
-    });
+    broadcastSse('team-change', { type: 'task', teamName: resolvedToTeam });
   }
   return {
     ok,
@@ -5138,18 +6157,171 @@ app.put<{ Body: TaskBusConfig }>('/api/settings/task-bus', async (request) => {
   return { ok: true, connected: false, message: 'Task bus disabled' };
 });
 
+type TelemetryProjectRow = {
+  cwd: string;
+  displayName?: string;
+  teamSlug?: string;
+  bindProject?: string;
+  sessions: number;
+  messages: number;
+  tokensIn: number;
+  tokensOut: number;
+  tokensTotal: number;
+};
+
+type TelemetryStatusShape = {
+  connected: boolean;
+  lastScan: string | null;
+  sessions: number;
+  messages: number;
+  tokensIn: number;
+  tokensOut: number;
+  cacheRead: number;
+  cacheCreation: number;
+  totalTokens: number;
+  activeDays: number;
+  hourly: number[];
+  projects: TelemetryProjectRow[];
+  workSecondsByDay: Record<string, number>;
+};
+
+async function readTaskBusSettings(): Promise<TaskBusConfig> {
+  const configPath = path.join(os.homedir(), '.hermit', 'settings.json');
+  let settings: Record<string, unknown> = {};
+  try {
+    const raw = await fs.readFile(configPath, 'utf-8');
+    settings = JSON.parse(raw);
+  } catch {
+    // no settings
+  }
+  return (settings.taskBus ?? {}) as TaskBusConfig;
+}
+
+async function enrichTelemetryProjectNames<T extends { projects: TelemetryProjectRow[] }>(
+  status: T
+): Promise<T> {
+  const teams = await svc.listTeams().catch(() => []);
+  const byWorkDir = new Map<string, TeamManifest>();
+  const byBindProject = new Map<string, TeamManifest>();
+  for (const team of teams) {
+    if (team.slug === SYSTEM_MANAGER_TEAM_NAME) continue;
+    const workDir = (team.workDir || '').trim();
+    if (workDir) byWorkDir.set(path.resolve(workDir), team);
+    if (team.bindProject) byBindProject.set(team.bindProject, team);
+    byBindProject.set(team.slug, team);
+  }
+
+  return {
+    ...status,
+    projects: status.projects.map((project) => {
+      const cwd = (project.cwd || '').trim();
+      const team =
+        (cwd ? byWorkDir.get(path.resolve(cwd)) : undefined) ??
+        byBindProject.get(cwd) ??
+        byBindProject.get(path.basename(cwd));
+      if (!team) return project;
+      return {
+        ...project,
+        displayName: team.displayName || team.slug,
+        teamSlug: team.slug,
+        bindProject: team.bindProject,
+      };
+    }),
+  };
+}
+
+function telemetryEmptyStatus(): TelemetryStatusShape {
+  return {
+    connected: false,
+    lastScan: null,
+    sessions: 0,
+    messages: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    cacheRead: 0,
+    cacheCreation: 0,
+    totalTokens: 0,
+    activeDays: 0,
+    hourly: [],
+    projects: [],
+    workSecondsByDay: {},
+  };
+}
+
+function csvCell(value: unknown): string {
+  const text = String(value ?? '');
+  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+
+function buildUsageTelemetryExport(status: TelemetryStatusShape, format: 'csv' | 'json') {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  if (format === 'json') {
+    return {
+      filename: `hermit-loop-usage-${stamp}.json`,
+      mimeType: 'application/json;charset=utf-8',
+      content: JSON.stringify(status, null, 2),
+    };
+  }
+
+  const rows = [
+    [
+      'section',
+      'name',
+      'sessions',
+      'messages',
+      'tokensIn',
+      'tokensOut',
+      'cacheRead',
+      'cacheCreation',
+      'totalTokens',
+      'activeDays',
+      'durationSeconds',
+      'cwd',
+    ],
+    [
+      'summary',
+      '累计 Loop 数据',
+      status.sessions,
+      status.messages,
+      status.tokensIn,
+      status.tokensOut,
+      status.cacheRead,
+      status.cacheCreation,
+      status.totalTokens,
+      status.activeDays,
+      '',
+      '',
+    ],
+    ...Object.entries(status.workSecondsByDay)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([day, seconds]) => ['day', day, '', '', '', '', '', '', '', '', seconds, '']),
+    ...status.projects.map((project) => [
+      'project',
+      project.displayName || path.basename(project.cwd) || project.cwd,
+      project.sessions,
+      project.messages,
+      project.tokensIn,
+      project.tokensOut,
+      '',
+      '',
+      project.tokensTotal,
+      '',
+      '',
+      project.cwd,
+    ]),
+  ];
+
+  return {
+    filename: `hermit-loop-usage-${stamp}.csv`,
+    mimeType: 'text/csv;charset=utf-8',
+    content: rows.map((row) => row.map(csvCell).join(',')).join('\n'),
+  };
+}
+
 // POST /api/telemetry/scan → trigger manual scan
 app.post('/api/telemetry/scan', async (request, reply) => {
   try {
-    const configPath = path.join(os.homedir(), '.hermit', 'settings.json');
-    let settings: Record<string, unknown> = {};
-    try {
-      const raw = await fs.readFile(configPath, 'utf-8');
-      settings = JSON.parse(raw);
-    } catch {
-      // no settings
-    }
-    const taskBus = (settings.taskBus ?? {}) as TaskBusConfig;
+    const taskBus = await readTaskBusSettings();
     if (!taskBus.telemetry?.enabled) {
       return reply.code(400).send({ error: 'Telemetry is not enabled' });
     }
@@ -5157,7 +6329,7 @@ app.post('/api/telemetry/scan', async (request, reply) => {
     if (!result) {
       return reply.code(503).send({ error: 'Telemetry scan failed' });
     }
-    return {
+    return await enrichTelemetryProjectNames({
       ok: true,
       connected: taskBus.telemetry.uploadEnabled === true,
       lastScan: new Date().toISOString(),
@@ -5167,16 +6339,35 @@ app.post('/api/telemetry/scan', async (request, reply) => {
       tokensOut: result.aggregate.tokens.output,
       cacheRead: result.aggregate.tokens.cacheRead,
       cacheCreation: result.aggregate.tokens.cacheCreation,
+      totalTokens: result.aggregate.tokens.total,
       activeDays: result.aggregate.activeDays,
       hourly: result.aggregate.hourly,
       projects: result.aggregate.projects,
       workSecondsByDay: result.aggregate.workSecondsByDay,
-    };
+    });
   } catch (err) {
     return reply.code(500).send({ error: String(err) });
   }
 });
 
+// GET /api/telemetry/export → export Loop usage telemetry summary/projects
+app.get<{ Querystring: { format?: 'csv' | 'json' | string } }>(
+  '/api/telemetry/export',
+  async (request, reply) => {
+    try {
+      const format = request.query.format === 'json' ? 'json' : 'csv';
+      const taskBus = await readTaskBusSettings();
+      const redisCfg = taskBus.enabled ? taskBus.redis : undefined;
+      const status = await enrichTelemetryProjectNames(
+        (await getTelemetryStatus(redisCfg)) ?? telemetryEmptyStatus()
+      );
+      return buildUsageTelemetryExport(status, format);
+    } catch (err) {
+      return reply.code(500).send({ error: String(err) });
+    }
+  }
+);
+
 // GET /api/telemetry/conversations → local Feishu/Lark conversation telemetry
 app.get<{
   Querystring: {
@@ -5274,48 +6465,12 @@ app.get<{
 // GET /api/telemetry/status → current telemetry status (full stats)
 app.get('/api/telemetry/status', async (request, reply) => {
   try {
-    const configPath = path.join(os.homedir(), '.hermit', 'settings.json');
-    let settings: Record<string, unknown> = {};
-    try {
-      const raw = await fs.readFile(configPath, 'utf-8');
-      settings = JSON.parse(raw);
-    } catch {
-      // no settings
-    }
-    const taskBus = (settings.taskBus ?? {}) as TaskBusConfig;
+    const taskBus = await readTaskBusSettings();
     const redisCfg = taskBus.enabled ? taskBus.redis : undefined;
     const status = await getTelemetryStatus(redisCfg);
-    return (
-      status ?? {
-        connected: false,
-        lastScan: null,
-        sessions: 0,
-        messages: 0,
-        tokensIn: 0,
-        tokensOut: 0,
-        cacheRead: 0,
-        cacheCreation: 0,
-        activeDays: 0,
-        hourly: [],
-        projects: [],
-        workSecondsByDay: {},
-      }
-    );
+    return await enrichTelemetryProjectNames(status ?? telemetryEmptyStatus());
   } catch {
-    return {
-      connected: false,
-      lastScan: null,
-      sessions: 0,
-      messages: 0,
-      tokensIn: 0,
-      tokensOut: 0,
-      cacheRead: 0,
-      cacheCreation: 0,
-      activeDays: 0,
-      hourly: [],
-      projects: [],
-      workSecondsByDay: {},
-    };
+    return telemetryEmptyStatus();
   }
 });
 
@@ -5476,6 +6631,22 @@ app.post('/api/extensions/mcp/library/import', async (request) => {
   return ext.mcpLibraryImport((request.body ?? {}) as any);
 });
 
+app.get('/api/extensions/capability-packs', async () => {
+  return ext.capabilityPacksList();
+});
+
+app.post('/api/extensions/capability-packs/import', async (request) => {
+  return ext.capabilityPacksImport((request.body ?? {}) as any);
+});
+
+app.post('/api/extensions/capability-packs/export', async (request) => {
+  return ext.capabilityPacksExport((request.body ?? {}) as any);
+});
+
+app.post('/api/extensions/capability-packs/command-prompt', async (request) => {
+  return ext.capabilityPacksCommandPrompt((request.body ?? {}) as any);
+});
+
 app.get('/api/extensions/skills', async (request) => {
   const projectPath = (request.query as Record<string, string>).projectPath;
   const result = await ext.skillsList(projectPath);
@@ -5688,6 +6859,7 @@ try {
 // graceful shutdown
 const shutdown = async () => {
   try {
+    directCliManager.shutdown();
     bridge.dispose?.();
     await app.close();
     process.exit(0);
@@ -5697,3 +6869,6 @@ const shutdown = async () => {
 };
 process.on('SIGINT', shutdown);
 process.on('SIGTERM', shutdown);
+// Sync backstop: reap direct-CLI subprocesses on any exit path that skips the async
+// shutdown (e.g. process killed without a delivered signal). child.kill() is synchronous.
+process.on('exit', () => directCliManager.shutdown());