feat: 添加 Windows Terminal swarm 后端及 swarm 增强

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: unraid

src/components/PromptInput/useSwarmBanner.ts

@@ -81,11 +81,17 @@ export function useSwarmBanner(): SwarmBannerInfo {
     const viewedTeammate = getViewedTeammateTask(state)
     const viewedColor = toThemeColor(viewedTeammate?.identity.color)
     const inProcessMode = isInProcessEnabled()
-    const nativePanes = getCachedDetectionResult()?.isNative ?? false
+    const detection = getCachedDetectionResult()
+    const nativePanes = detection?.isNative ?? false
+    const backendType = detection?.backend.type
 
     if (insideTmux === false && !inProcessMode && !nativePanes) {
+      const hint =
+        backendType === 'windows-terminal'
+          ? 'View teammates in the Windows Terminal tabs spawned for each teammate'
+          : `View teammates: \`tmux -L ${getSwarmSocketName()} a\``
       return {
-        text: `View teammates: \`tmux -L ${getSwarmSocketName()} a\``,
+        text: hint,
         bgColor: viewedColor,
       }
     }

src/utils/agentSwarmsEnabled.ts

@@ -1,42 +1,15 @@
-import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
 import { isEnvTruthy } from './envUtils.js'
 
-/**
- * Check if --agent-teams flag is provided via CLI.
- * Checks process.argv directly to avoid import cycles with bootstrap/state.
- * Note: The flag is only shown in help for ant users, but if external users
- * pass it anyway, it will work (subject to the killswitch).
- */
-function isAgentTeamsFlagSet(): boolean {
-  return process.argv.includes('--agent-teams')
-}
-
 /**
  * Centralized runtime check for agent teams/teammate features.
  * This is the single gate that should be checked everywhere teammates
  * are referenced (prompts, code, tools isEnabled, UI, etc.).
  *
- * Ant builds: always enabled.
- * External builds require both:
- * 1. Opt-in via CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS env var OR --agent-teams flag
- * 2. GrowthBook gate 'tengu_amber_flint' enabled (killswitch)
+ * Fork build: enabled by default. Can be disabled via
+ * CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0 if needed.
  */
 export function isAgentSwarmsEnabled(): boolean {
-  // Ant: always on
-  if (process.env.USER_TYPE === 'ant') {
-    return true
-  }
-
-  // External: require opt-in via env var or --agent-teams flag
-  if (
-    !isEnvTruthy(process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS) &&
-    !isAgentTeamsFlagSet()
-  ) {
-    return false
-  }
-
-  // Killswitch — always respected for external users
-  if (!getFeatureValue_CACHED_MAY_BE_STALE('tengu_amber_flint', true)) {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS_DISABLED)) {
     return false
   }
 

src/utils/swarm/__tests__/agentTeamsLifecycle.test.ts

@@ -0,0 +1,279 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+let terminateCalls: string[] = []
+
+mock.module('src/utils/swarm/backends/registry.js', () => {
+  const executor = {
+    type: 'in-process' as const,
+    setContext() {},
+    async isAvailable() {
+      return true
+    },
+    async spawn(config: { name: string; teamName: string; color?: string }) {
+      return {
+        success: true,
+        agentId: `${config.name}@${config.teamName}`,
+        taskId: `task-${config.name}`,
+        backendType: 'in-process',
+        color: config.color,
+        isSplitPane: false,
+      }
+    },
+    async sendMessage() {},
+    async terminate(agentId: string) {
+      terminateCalls.push(agentId)
+      return true
+    },
+    async kill() {
+      return true
+    },
+    async isActive() {
+      return true
+    },
+  }
+
+  return {
+    getTeammateExecutor: async () => executor,
+    getInProcessBackend: () => executor,
+    detectAndGetBackend: async () => ({
+      backend: { type: 'in-process' },
+      isNative: false,
+      needsIt2Setup: false,
+    }),
+    isInProcessEnabled: () => true,
+    markInProcessFallback: () => {},
+    resetBackendDetection: () => {},
+    getCachedBackend: () => null,
+    getCachedDetectionResult: () => null,
+    getResolvedTeammateMode: () => 'in-process',
+    ensureBackendsRegistered: async () => {},
+    getBackendByType: () => ({
+      type: 'tmux',
+      killPane: async () => true,
+    }),
+  }
+})
+
+let tempHome: string
+let previousConfigDir: string | undefined
+let previousAnthropicApiKey: string | undefined
+let state: any
+
+function setState(updater: (prev: any) => any): void {
+  state = updater(state)
+}
+
+function readTeamConfig(teamName: string): any {
+  return JSON.parse(
+    readFileSync(join(tempHome, 'teams', teamName, 'config.json'), 'utf-8'),
+  )
+}
+
+function writeTeamConfig(teamName: string, config: unknown): void {
+  const teamDir = join(tempHome, 'teams', teamName)
+  mkdirSync(teamDir, { recursive: true })
+  writeFileSync(join(teamDir, 'config.json'), JSON.stringify(config, null, 2))
+}
+
+beforeEach(() => {
+  terminateCalls = []
+  previousConfigDir = process.env.CLAUDE_CONFIG_DIR
+  previousAnthropicApiKey = process.env.ANTHROPIC_API_KEY
+  tempHome = join(
+    tmpdir(),
+    `agent-teams-lifecycle-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+  )
+  process.env.CLAUDE_CONFIG_DIR = tempHome
+  process.env.ANTHROPIC_API_KEY = 'test-key'
+  state = {
+    teamContext: undefined,
+    tasks: {},
+    inbox: { messages: [] },
+    toolPermissionContext: {
+      mode: 'default',
+      alwaysAllowRules: {},
+      alwaysDenyRules: {},
+      additionalWorkingDirectories: new Map(),
+    },
+    mainLoopModel: null,
+    mainLoopModelForSession: null,
+    agentNameRegistry: new Map(),
+    mcp: { tools: [] },
+  }
+})
+
+afterEach(() => {
+  if (previousConfigDir === undefined) {
+    delete process.env.CLAUDE_CONFIG_DIR
+  } else {
+    process.env.CLAUDE_CONFIG_DIR = previousConfigDir
+  }
+  if (previousAnthropicApiKey === undefined) {
+    delete process.env.ANTHROPIC_API_KEY
+  } else {
+    process.env.ANTHROPIC_API_KEY = previousAnthropicApiKey
+  }
+  rmSync(tempHome, { recursive: true, force: true })
+})
+
+describe('Agent Teams lifecycle', () => {
+  test('runs TeamCreate -> spawn -> TaskUpdate -> SendMessage -> TeamDelete', async () => {
+    const { TeamCreateTool } = await import(
+      '@claude-code-best/builtin-tools/tools/TeamCreateTool/TeamCreateTool.js'
+    )
+    const { spawnTeammate } = await import(
+      '@claude-code-best/builtin-tools/tools/shared/spawnMultiAgent.js'
+    )
+    const { TaskCreateTool } = await import(
+      '@claude-code-best/builtin-tools/tools/TaskCreateTool/TaskCreateTool.js'
+    )
+    const { TaskUpdateTool } = await import(
+      '@claude-code-best/builtin-tools/tools/TaskUpdateTool/TaskUpdateTool.js'
+    )
+    const { SendMessageTool } = await import(
+      '@claude-code-best/builtin-tools/tools/SendMessageTool/SendMessageTool.js'
+    )
+    const { TeamDeleteTool } = await import(
+      '@claude-code-best/builtin-tools/tools/TeamDeleteTool/TeamDeleteTool.js'
+    )
+
+    const context = {
+      getAppState: () => state,
+      setAppState: setState,
+      options: {
+        agentDefinitions: { activeAgents: [] },
+      },
+      abortController: new AbortController(),
+    } as any
+
+    const created = await TeamCreateTool.call(
+      { team_name: 'alpha', description: 'test team' },
+      context,
+      undefined as any,
+      undefined as any,
+    )
+    expect(created.data.team_name).toBe('alpha')
+
+    const spawned = await spawnTeammate(
+      {
+        name: 'worker',
+        prompt: 'handle assigned tasks',
+        team_name: 'alpha',
+      },
+      context,
+    )
+    expect(spawned.data.agent_id).toBe('worker@alpha')
+
+    const task = await TaskCreateTool.call(
+      { subject: 'Check lifecycle', description: 'Verify team task flow' },
+      context,
+    )
+    await TaskUpdateTool.call(
+      { taskId: task.data.task.id, owner: 'worker' },
+      context,
+    )
+
+    const message = await SendMessageTool.call(
+      {
+        to: 'worker',
+        summary: 'Status request',
+        message: 'Please report status.',
+      },
+      context,
+      async () => ({ behavior: 'allow' as const }),
+      undefined as any,
+    )
+    expect(message.data.success).toBe(true)
+
+    const blockedDelete = await TeamDeleteTool.call(
+      {},
+      context,
+      undefined as any,
+      undefined as any,
+    )
+    expect(blockedDelete.data.success).toBe(false)
+    expect(terminateCalls).toEqual(['worker@alpha'])
+
+    const config = readTeamConfig('alpha')
+    config.members = config.members.map((member: any) =>
+      member.name === 'worker' ? { ...member, isActive: false } : member,
+    )
+    writeTeamConfig('alpha', config)
+
+    const deleted = await TeamDeleteTool.call(
+      {},
+      context,
+      undefined as any,
+      undefined as any,
+    )
+    expect(deleted.data.success).toBe(true)
+  })
+
+  test('TeamDelete waits for active teammates to become inactive before cleanup', async () => {
+    const { TeamDeleteTool } = await import(
+      '@claude-code-best/builtin-tools/tools/TeamDeleteTool/TeamDeleteTool.js'
+    )
+    const now = Date.now()
+    writeTeamConfig('alpha', {
+      name: 'alpha',
+      createdAt: now,
+      leadAgentId: 'team-lead@alpha',
+      members: [
+        {
+          agentId: 'team-lead@alpha',
+          name: 'team-lead',
+          joinedAt: now,
+          tmuxPaneId: '',
+          cwd: tempHome,
+          subscriptions: [],
+        },
+        {
+          agentId: 'worker@alpha',
+          name: 'worker',
+          joinedAt: now,
+          tmuxPaneId: 'in-process',
+          cwd: tempHome,
+          subscriptions: [],
+          backendType: 'in-process',
+        },
+      ],
+    })
+    state.teamContext = {
+      teamName: 'alpha',
+      teamFilePath: join(tempHome, 'teams', 'alpha', 'config.json'),
+      leadAgentId: 'team-lead@alpha',
+      teammates: {
+        'worker@alpha': {
+          name: 'worker',
+          tmuxSessionName: 'in-process',
+          tmuxPaneId: 'in-process',
+          cwd: tempHome,
+          spawnedAt: now,
+        },
+      },
+    }
+
+    setTimeout(() => {
+      const config = readTeamConfig('alpha')
+      config.members = config.members.map((member: any) =>
+        member.name === 'worker' ? { ...member, isActive: false } : member,
+      )
+      writeTeamConfig('alpha', config)
+    }, 25)
+
+    const result = await TeamDeleteTool.call(
+      { wait_ms: 1000 },
+      {
+        getAppState: () => state,
+        setAppState: setState,
+      } as any,
+      undefined as any,
+      undefined as any,
+    )
+
+    expect(result.data.success).toBe(true)
+  })
+})