feat: add /swarm parallel agent-swarm orchestration

.changeset/swarm-agent-orchestration.md

@@ -0,0 +1,6 @@
+---
+"@moonshot-ai/agent-core": minor
+"@moonshot-ai/kimi-code": minor
+---
+
+Add `/swarm` command and Swarm tool: decompose a task into parallel role-specialized subagents and synthesize their results.

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

@@ -42,6 +42,7 @@ import {
   handleInitCommand,
   handleTitleCommand,
 } from './session';
+import { handleSwarmCommand } from './swarm';
 
 // ---------------------------------------------------------------------------
 // Re-exports — keep existing consumers working
@@ -104,6 +105,7 @@ export interface SlashCommandHost {
   switchToSession(session: Session, message: string): Promise<void>;
   beginSessionRequest(): void;
   failSessionRequest(message: string): void;
+  appendUserTranscriptEntry(content: string): void;
   sendQueuedMessage(session: Session, item: QueuedMessage): void;
 
   // UI
@@ -255,6 +257,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/registry.ts

@@ -36,6 +36,13 @@ export const BUILTIN_SLASH_COMMANDS = [
     priority: 100,
     availability: (args) => (args.trim().toLowerCase() === 'clear' ? 'idle-only' : 'always'),
   },
+  {
+    name: 'swarm',
+    aliases: [],
+    description: 'Run a task as a parallel agent swarm',
+    priority: 100,
+    availability: 'idle-only',
+  },
   {
     name: 'model',
     aliases: [],

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

@@ -0,0 +1,44 @@
+import { NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import type { SlashCommandHost } from './dispatch';
+
+export function buildSwarmPrompt(task: string): string {
+  return [
+    'Use the Swarm tool to accomplish the following task.',
+    'Call the Swarm tool exactly once with this task as its `task` argument; do not do the work yourself.',
+    '',
+    'Task:',
+    task,
+  ].join('\n');
+}
+
+export async function handleSwarmCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const session = host.session;
+  if (session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+  const task = args.trim();
+  if (task.length === 0) {
+    host.showError('Usage: /swarm <task>');
+    return;
+  }
+  // Show the readable command in the transcript before the turn starts. The
+  // prompt actually sent to the model is the verbose buildSwarmPrompt wrapper,
+  // so without this the live transcript would show a Swarm tool card with no
+  // preceding user request.
+  host.appendUserTranscriptEntry(`/swarm ${task}`);
+  // Route through the same session-request lifecycle as a normal send /
+  // skill activation rather than calling session.prompt raw. beginSessionRequest
+  // flips streamingPhase out of 'idle' synchronously, so the input gate closes
+  // immediately and shows the waiting pane; otherwise, during the window before
+  // turn.started arrives the UI still thinks it is idle and a fast follow-up
+  // message could be dispatched as a second concurrent prompt and be silently
+  // dropped as agent_busy.
+  host.beginSessionRequest();
+  try {
+    await session.prompt(buildSwarmPrompt(task));
+  } catch (error) {
+    host.failSessionRequest(`Failed to start swarm: ${formatErrorMessage(error)}`);
+  }
+}

apps/kimi-code/src/tui/components/messages/managed-tool-card.ts

@@ -0,0 +1,50 @@
+import type { Component } from '@earendil-works/pi-tui';
+
+import type { SwarmEvent } from './swarm-dashboard-model';
+import type { ToolCallBlockData, ToolResultBlockData } from '#/tui/types';
+
+/**
+ * Narrow shared contract for a card that the streaming-UI managed tool-call
+ * lifecycle owns in `_pendingToolComponents` (keyed by tool call id). Both
+ * `ToolCallComponent` and `SwarmCard` implement it, so callers can hold a
+ * registry value and dispatch the lifecycle methods below polymorphically.
+ *
+ * The interface is deliberately minimal: it only carries members the callers
+ * invoke on the union without first knowing which concrete card they hold.
+ * Anything reached only after `isSwarm()` returns false (the whole subagent
+ * API, progress lines, plan info, background-task terminal status, …) is left
+ * off and accessed via `instanceof ToolCallComponent` narrowing at the call
+ * site instead.
+ */
+export interface ManagedToolCard extends Component {
+  /** True iff this card drives the `Swarm` coordinator dashboard. */
+  isSwarm(): boolean;
+
+  /**
+   * Fold a swarm dashboard event into the card and re-render in place. A safe
+   * no-op on a non-swarm card so callers can route blindly after an
+   * `isSwarm()` guard without re-narrowing.
+   */
+  applySwarm(event: SwarmEvent): void;
+
+  /** Deliver the tool result and drive the card to its terminal state. */
+  setResult(result: ToolResultBlockData): void;
+
+  /** Re-sync the live tool-call metadata (args, truncation, …). */
+  updateToolCall(toolCall: ToolCallBlockData): void;
+
+  /** Tool-output expansion toggle (Ctrl+O). No-op on cards without a body. */
+  setExpanded(expanded: boolean): void;
+
+  /**
+   * Plan-box expansion toggle. Returns true iff the card actually owns a plan
+   * preview (so the caller can decide whether to consume the keystroke).
+   */
+  setPlanExpanded(expanded: boolean): boolean;
+
+  /** Release any timers/resources. Must be safe to call more than once. */
+  dispose(): void;
+
+  /** Readonly view of the backing tool call (id, name, description). */
+  readonly toolCallView: Readonly<ToolCallBlockData>;
+}