feat: agent swarm

.changeset/template-agent-swarm.md

@@ -0,0 +1,7 @@
+---
+"@moonshot-ai/agent-core": minor
+"@moonshot-ai/kimi-code-sdk": minor
+"@moonshot-ai/kimi-code": minor
+---
+
+Add template-based AgentSwarm launches with live TUI progress.

apps/kimi-code/src/cli/run-prompt.ts

@@ -474,6 +474,8 @@ function runPromptTurn(
         case 'subagent.completed':
         case 'subagent.failed':
         case 'subagent.spawned':
+        case 'subagent.started':
+        case 'subagent.suspended':
         case 'tool.list.updated':
         case 'turn.started':
         case 'turn.step.completed':

apps/kimi-code/src/tui/commands/dispatch.ts

@@ -42,6 +42,7 @@ import { handleProviderCommand } from './provider';
 import { handleFeedbackCommand, showMcpServers, showStatusReport, showUsage } from './info';
 import { handlePluginsCommand } from './plugins';
 import { handleReloadCommand, handleReloadTuiCommand } from './reload';
+import { handleSwarmCommand } from './swarm';
 import {
   handleExportDebugZipCommand,
   handleExportMdCommand,
@@ -73,6 +74,7 @@ export {
   showPermissionPicker,
   showSettingsSelector,
 } from './config';
+export { handleSwarmCommand } from './swarm';
 export {
   handleFeedbackCommand,
   showMcpServers,
@@ -300,6 +302,9 @@ async function handleBuiltInSlashCommand(
     case 'plan':
       await handlePlanCommand(host, args);
       return;
+    case 'swarm':
+      await handleSwarmCommand(host, args);
+      return;
     case 'compact':
       await handleCompactCommand(host, args);
       return;

apps/kimi-code/src/tui/commands/index.ts

@@ -23,6 +23,7 @@ export {
   showPermissionPicker,
   showSettingsSelector,
 } from './config';
+export { handleSwarmCommand } from './swarm';
 export {
   handleFeedbackCommand,
   showMcpServers,

apps/kimi-code/src/tui/commands/registry.ts

@@ -17,6 +17,11 @@ const GOAL_NEXT_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [
   { value: 'manage', description: 'Manage upcoming goals' },
 ];
 
+const SWARM_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [
+  { value: 'on', description: 'Turn swarm mode on' },
+  { value: 'off', description: 'Turn swarm mode off' },
+];
+
 /** Argument autocompletion for the `/goal` command (subcommands). */
 export function goalArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
   const nextMatch = argumentPrefix.match(/^next\s+(\S*)$/i);
@@ -31,6 +36,11 @@ export function goalArgumentCompletions(argumentPrefix: string): AutocompleteIte
   return completeLeadingArg(GOAL_ARG_COMPLETIONS, argumentPrefix);
 }
 
+/** Argument autocompletion for the `/swarm` command (subcommands). */
+export function swarmArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
+  return completeLeadingArg(SWARM_ARG_COMPLETIONS, argumentPrefix);
+}
+
 export const BUILTIN_SLASH_COMMANDS = [
   {
     name: 'yolo',
@@ -67,6 +77,14 @@ export const BUILTIN_SLASH_COMMANDS = [
     priority: 100,
     availability: (args) => (args.trim().toLowerCase() === 'clear' ? 'idle-only' : 'always'),
   },
+  {
+    name: 'swarm',
+    aliases: [],
+    description: 'Toggle swarm mode or run one task in swarm mode',
+    priority: 100,
+    completeArgs: swarmArgumentCompletions,
+    availability: 'idle-only',
+  },
   {
     name: 'model',
     aliases: [],

apps/kimi-code/src/tui/commands/swarm.ts

@@ -0,0 +1,137 @@
+import type { PermissionMode } from '@moonshot-ai/kimi-code-sdk';
+
+import {
+  SwarmStartPermissionPromptComponent,
+  type SwarmStartPermissionChoice,
+} from '../components/dialogs/swarm-start-permission-prompt';
+import {
+  SwarmModeMarkerComponent,
+  type SwarmModeMarkerState,
+} from '../components/messages/swarm-markers';
+import { LLM_NOT_SET_MESSAGE, NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import type { SlashCommandHost } from './dispatch';
+
+export async function handleSwarmCommand(host: SlashCommandHost, args: string): Promise<void> {
+  if (host.session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  const prompt = args.trim();
+  const mode = swarmModeSubcommand(prompt);
+  if (mode !== undefined) {
+    await applySwarmMode(host, mode);
+    return;
+  }
+
+  if (prompt.length === 0) {
+    await applySwarmMode(host, !host.state.appState.swarmMode);
+    return;
+  }
+
+  if (host.state.appState.model.trim().length === 0) {
+    host.showError(LLM_NOT_SET_MESSAGE);
+    return;
+  }
+
+  if (host.state.appState.permissionMode === 'manual') {
+    showSwarmStartPermissionPrompt(host, prompt);
+    return;
+  }
+
+  await startSwarmTask(host, prompt);
+}
+
+function showSwarmStartPermissionPrompt(host: SlashCommandHost, prompt: string): void {
+  const commandText = `/swarm ${prompt}`;
+  const cancelStart = (): void => {
+    host.restoreInputText(commandText);
+    host.showStatus('Swarm task not started.');
+  };
+  host.mountEditorReplacement(
+    new SwarmStartPermissionPromptComponent({
+      colors: host.state.theme.colors,
+      onSelect: (choice) => {
+        host.restoreEditor();
+        void startSwarmWithPermission(host, prompt, choice);
+      },
+      onCancel: cancelStart,
+    }),
+  );
+}
+
+async function startSwarmWithPermission(
+  host: SlashCommandHost,
+  prompt: string,
+  choice: SwarmStartPermissionChoice,
+): Promise<void> {
+  if (choice === 'auto') {
+    if (!(await setPermissionForSwarm(host, choice))) return;
+  }
+  await startSwarmTask(host, prompt);
+}
+
+async function setPermissionForSwarm(host: SlashCommandHost, mode: PermissionMode): Promise<boolean> {
+  try {
+    await host.requireSession().setPermission(mode);
+  } catch (error) {
+    host.showError(`Failed to set permission mode: ${formatErrorMessage(error)}`);
+    return false;
+  }
+  host.setAppState({ permissionMode: mode });
+  return true;
+}
+
+async function startSwarmTask(host: SlashCommandHost, prompt: string): Promise<void> {
+  if (!host.state.appState.swarmMode && !(await setSwarmMode(host, true, 'task'))) {
+    return;
+  }
+  renderSwarmModeMarker(host, 'active');
+  host.sendNormalUserInput(prompt);
+}
+
+async function applySwarmMode(host: SlashCommandHost, enabled: boolean): Promise<void> {
+  if (enabled && host.state.appState.swarmMode) {
+    host.showStatus('Swarm mode is already on.');
+    return;
+  }
+  if (!enabled && !host.state.appState.swarmMode) {
+    host.showStatus('Swarm mode is already off.');
+    return;
+  }
+  if (!(await setSwarmMode(host, enabled, 'manual'))) return;
+  renderSwarmModeMarker(host, enabled ? 'active' : 'inactive');
+}
+
+async function setSwarmMode(
+  host: SlashCommandHost,
+  enabled: boolean,
+  trigger: 'manual' | 'task',
+): Promise<boolean> {
+  try {
+    await host.requireSession().setSwarmMode(enabled, trigger);
+  } catch (error) {
+    host.showError(
+      `Failed to ${enabled ? 'enable' : 'disable'} swarm mode: ${formatErrorMessage(error)}`,
+    );
+    return false;
+  }
+  host.setAppState({ swarmMode: enabled });
+  host.state.swarmModeEntry = enabled ? trigger : undefined;
+  return true;
+}
+
+function swarmModeSubcommand(input: string): boolean | undefined {
+  const command = input.toLowerCase();
+  if (command === 'on') return true;
+  if (command === 'off') return false;
+  return undefined;
+}
+
+function renderSwarmModeMarker(host: SlashCommandHost, state: SwarmModeMarkerState): void {
+  host.state.transcriptContainer.addChild(
+    new SwarmModeMarkerComponent(state, host.state.theme.colors),
+  );
+  host.state.ui.requestRender();
+}

apps/kimi-code/src/tui/commands/undo.ts

@@ -2,6 +2,7 @@ import type { Component } from '@earendil-works/pi-tui';
 
 import { WelcomeComponent } from '../components/chrome/welcome';
 import { AgentGroupComponent } from '../components/messages/agent-group';
+import { AgentSwarmProgressComponent } from '../components/messages/agent-swarm-progress';
 import { AssistantMessageComponent } from '../components/messages/assistant-message';
 import { BackgroundAgentStatusComponent } from '../components/messages/background-agent-status';
 import { CronMessageComponent } from '../components/messages/cron-message';
@@ -167,6 +168,7 @@ function isUndoContextComponent(child: Component): boolean {
     child instanceof ThinkingComponent ||
     child instanceof ToolCallComponent ||
     child instanceof AgentGroupComponent ||
+    child instanceof AgentSwarmProgressComponent ||
     child instanceof ReadGroupComponent ||
     child instanceof SkillActivationComponent ||
     child instanceof BackgroundAgentStatusComponent ||

apps/kimi-code/src/tui/components/chrome/footer.ts

@@ -287,9 +287,12 @@ export class FooterComponent implements Component {
 
     // ── Line 1: mode badges + model + [N task(s) running] + [N agent(s) running] + cwd + git + hints ──
     const left: string[] = [];
-    if (state.permissionMode === 'auto') left.push(chalk.hex(colors.warning).bold('auto'));
-    if (state.permissionMode === 'yolo') left.push(chalk.hex(colors.warning).bold('yolo'));
-    if (state.planMode) left.push(chalk.hex(colors.primary).bold('plan'));
+    const modes: string[] = [];
+    if (state.permissionMode === 'auto') modes.push(chalk.hex(colors.warning).bold('auto'));
+    if (state.permissionMode === 'yolo') modes.push(chalk.hex(colors.warning).bold('yolo'));
+    if (state.planMode) modes.push(chalk.hex(colors.primary).bold('plan'));
+    if (state.swarmMode) modes.push(chalk.hex(colors.success).bold('swarm'));
+    if (modes.length > 0) left.push(modes.join(' '));
 
     const goalBadge = formatGoalBadge(state.goal, colors, this.goalWallClockMs(state.goal));
     if (goalBadge !== null) left.push(goalBadge);

apps/kimi-code/src/tui/components/chrome/moon-loader.ts

@@ -18,6 +18,7 @@ export class MoonLoader extends Text {
   private interval: number;
   private colorFn?: (s: string) => string;
   private label: string;
+  private displayText = '';
 
   constructor(
     ui: TUI,
@@ -59,10 +60,15 @@ export class MoonLoader extends Text {
     this.updateDisplay();
   }
 
+  renderInline(): string {
+    return this.displayText;
+  }
+
   private updateDisplay(): void {
     const frame = this.frames[this.currentFrame]!;
     const coloredFrame = this.colorFn ? this.colorFn(frame) : frame;
-    this.setText(this.label ? `${coloredFrame} ${this.label}` : coloredFrame);
+    this.displayText = this.label ? `${coloredFrame} ${this.label}` : coloredFrame;
+    this.setText(this.displayText);
     this.ui.requestRender();
   }
 }