fix: hide AgentSwarm calls rejected before any subagent starts (#4414)

While swarm mode is off the core rejects AgentSwarm before any subagent
starts, but the TUI still drew the call as a swarm whose members all
failed, and resumed sessions replayed it as a failed swarm card.

- Do not create the swarm panel while swarm mode is off, and remove the
  panel when a call ends before any subagent started (swarm mode off,
  input validation, a rejected approval, or a blocking hook).
- Create the panel when the first subagent spawns, so a swarm that does
  run is never hidden when the TUI's swarm state lags behind.
- Skip such calls when replaying a session.
- Tell the model to point the user to /swarm only when they asked for a
  swarm, and otherwise to continue without mentioning swarm mode.

Author: RealKai42

.changeset/hide-rejected-agent-swarm.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Stop showing a failed swarm for `AgentSwarm` calls rejected before any subagent starts, such as while swarm mode is off; after such a rejection, the agent points you to `/swarm` if you asked for a swarm.

apps/kimi-code/src/tui/components/messages/agent-swarm-progress.ts

@@ -295,6 +295,10 @@ export class AgentSwarmProgressComponent implements Component {
     return !this.inputComplete;
   }
 
+  hasSubagents(): boolean {
+    return this.membersByAgentId.size > 0;
+  }
+
   updateArgs(
     args: Record<string, unknown>,
     options: { readonly streamingArguments?: string | undefined } = {},
@@ -1192,6 +1196,20 @@ export function agentSwarmResultSummaryFromOutput(output: string): AgentSwarmRes
   };
 }
 
+/**
+ * Whether the output of a failed AgentSwarm call is a rejection that ended the
+ * call before any subagent started, such as a call made while swarm mode is
+ * off or one that failed input validation. The rejection is addressed to the
+ * model, so the transcript shows no swarm for it. Cancellations keep their
+ * aborted rendering.
+ */
+export function isAgentSwarmRejection(output: string): boolean {
+  return (
+    !/\b(?:aborted|cancelled|interrupted)\b/i.test(output) &&
+    !agentSwarmResultSummaryFromOutput(output).parsed
+  );
+}
+
 function parseAgentSwarmResultStatuses(output: string): AgentSwarmResultStatus[] {
   const xmlStatuses = parseAgentSwarmXmlResultStatuses(output);
   if (xmlStatuses.length > 0) return xmlStatuses;

apps/kimi-code/src/tui/controllers/session-replay.ts

@@ -8,6 +8,7 @@ import type {
   ToolCall,
 } from '@moonshot-ai/kimi-code-sdk';
 
+import { isAgentSwarmRejection } from '../components/messages/agent-swarm-progress';
 import { ToolCallComponent } from '../components/messages/tool-call';
 import { ShellRunComponent } from '../components/messages/shell-run';
 import { ReplayTurnBoundaryComponent } from '../components/messages/user-message';
@@ -511,6 +512,10 @@ export class SessionReplayRenderer {
       output: toolResultOutput(message.content),
       is_error: message.isError,
     };
+    if (call.name === 'AgentSwarm' && result.is_error === true && isAgentSwarmRejection(result.output)) {
+      this.host.streamingUI.discardToolCall(toolCallId);
+      return;
+    }
     call.result = result;
     this.applyStepContext(context);
     this.host.streamingUI.onToolCallEnd(toolCallId, result);

apps/kimi-code/src/tui/controllers/streaming-ui.ts

@@ -193,6 +193,18 @@ export class StreamingUIController {
     }
   }
 
+  /** Drops a tool call together with its card, as if it had never rendered. */
+  discardToolCall(toolCallId: string): void {
+    const component = this._pendingToolComponents.get(toolCallId);
+    this._pendingToolComponents.delete(toolCallId);
+    this._activeToolCalls.delete(toolCallId);
+    if (component === undefined) return;
+    const children = this.host.state.transcriptContainer.children;
+    const index = children.indexOf(component);
+    if (index >= 0) children.splice(index, 1);
+    this.host.state.ui.requestRender();
+  }
+
   /**
    * Push the actual terminal status of a background agent task into the
    * matching `Agent` tool call component so its snapshot phase no longer

apps/kimi-code/src/tui/controllers/subagent-event-handler.ts

@@ -8,6 +8,7 @@ import {
   AgentSwarmProgressComponent,
   agentSwarmDescriptionFromArgs,
   agentSwarmGridHeightForTerminalRows,
+  isAgentSwarmRejection,
 } from '../components/messages/agent-swarm-progress';
 import { modelDisplayName } from '../components/dialogs/model-selector';
 import { MAIN_AGENT_ID } from '../constant/kimi-tui';
@@ -213,6 +214,7 @@ export class SubAgentEventHandler {
     toolCallId: string,
     args: Record<string, unknown>,
   ): void {
+    if (!this.showsAgentSwarmProgress(toolCallId)) return;
     const progress = this.ensureAgentSwarmProgress(toolCallId, args);
     progress.markInputComplete();
     this.requestRender();
@@ -223,6 +225,7 @@ export class SubAgentEventHandler {
     args: Record<string, unknown>,
     options: { readonly streamingArguments?: string | undefined },
   ): void {
+    if (!this.showsAgentSwarmProgress(toolCallId)) return;
     this.ensureAgentSwarmProgress(toolCallId, args, options);
     this.requestRender();
   }
@@ -235,7 +238,9 @@ export class SubAgentEventHandler {
     const progress = this.agentSwarmProgress.get(toolCallId);
     if (progress === undefined) return;
 
-    if (isError && isUserCancelledSubagentError(resultData.output)) {
+    if (isError && !progress.hasSubagents() && isAgentSwarmRejection(resultData.output)) {
+      this.removeAgentSwarmProgress(toolCallId, progress);
+    } else if (isError && isUserCancelledSubagentError(resultData.output)) {
       if (progress.isRequestStreaming()) {
         this.removeAgentSwarmProgress(toolCallId, progress);
       } else {
@@ -514,6 +519,7 @@ export class SubAgentEventHandler {
     // in-run update/fallback path.
     const modelDisplay = this.spawnedModelDisplay(event);
     const effortDisplay = this.subagentEffortDisplay(event.thinkingEffort);
+    this.ensureStartedAgentSwarmProgress(event.parentToolCallId);
     if (this.updateAgentSwarmProgress(event.parentToolCallId, (progress) => {
       progress.registerSubagent({
         agentId: event.subagentId,
@@ -678,6 +684,24 @@ export class SubAgentEventHandler {
     return true;
   }
 
+  /**
+   * While swarm mode is off the core rejects AgentSwarm before any subagent
+   * starts, so a new call gets no panel; a panel already on screen keeps
+   * following its call.
+   */
+  private showsAgentSwarmProgress(toolCallId: string): boolean {
+    return this.host.state.appState.swarmMode || this.agentSwarmProgress.has(toolCallId);
+  }
+
+  /** A swarm that spawns subagents always gets a panel, even when its call
+   *  streamed while swarm mode still showed as off. */
+  private ensureStartedAgentSwarmProgress(parentToolCallId: string): void {
+    if (this.agentSwarmProgress.has(parentToolCallId)) return;
+    const toolCall = this.host.streamingUI.getActiveToolCall(parentToolCallId);
+    if (toolCall?.name !== 'AgentSwarm') return;
+    this.ensureAgentSwarmProgress(parentToolCallId, toolCall.args).markInputComplete();
+  }
+
   private ensureAgentSwarmProgress(
     toolCallId: string,
     args: Record<string, unknown>,

apps/kimi-code/test/tui/activity-pane.test.ts

@@ -59,6 +59,7 @@ function makeDriverWithTerminalProgress(): {
 
 function startSwarmProgress(driver: ActivityDriver, state: TUIState): AgentSwarmProgressComponent {
   const handler = driver.sessionEventHandler.subAgentEventHandler;
+  state.appState = { ...state.appState, swarmMode: true };
   handler.handleAgentSwarmToolCallStarted('call_swarm', {
     description: 'Review changed files',
   });

apps/kimi-code/test/tui/components/messages/agent-swarm-progress.test.ts

@@ -11,6 +11,7 @@ import {
   agentSwarmPartialItemsCountFromArguments,
   agentSwarmPartialItemsFromArguments,
   calculateAgentSwarmGridLayout,
+  isAgentSwarmRejection,
 } from '#/tui/components/messages/agent-swarm-progress';
 import { AgentSwarmProgressEstimator } from '#/tui/components/messages/agent-swarm-progress-estimator';
 import { currentTheme, darkColors, lightColors } from '#/tui/theme';
@@ -156,6 +157,28 @@ describe('calculateAgentSwarmGridLayout', () => {
   });
 });
 
+describe('isAgentSwarmRejection', () => {
+  it('matches failures that ended the call before any subagent started', () => {
+    expect(isAgentSwarmRejection(
+      'Swarm mode is off, so AgentSwarm did not run and no subagents were started.',
+    )).toBe(true);
+    expect(isAgentSwarmRejection(
+      'AgentSwarm requires at least 2 items unless resume_agent_ids is provided.',
+    )).toBe(true);
+  });
+
+  it('does not match per-subagent results or cancellations', () => {
+    expect(isAgentSwarmRejection([
+      '<agent_swarm_result>',
+      '<summary>failed: 1</summary>',
+      '<subagent index="1" outcome="failed">Agent timed out.</subagent>',
+      '</agent_swarm_result>',
+    ].join('\n'))).toBe(false);
+    expect(isAgentSwarmRejection('Aborted by the user')).toBe(false);
+    expect(isAgentSwarmRejection('The user manually interrupted this subagent batch.')).toBe(false);
+  });
+});
+
 describe('AgentSwarmProgressComponent', () => {
   it('renders an orchestrating panel before subagents spawn', () => {
     const component = createComponent();

apps/kimi-code/test/tui/controllers/subagent-event-handler.test.ts

@@ -13,7 +13,7 @@ function makeSwarmHandler() {
   const dockChild = { render: vi.fn(() => ['dock line']) };
   const host = {
     state: {
-      appState: { availableModels: {} },
+      appState: { availableModels: {}, swarmMode: true },
       ui: {
         requestRender,
         terminal: { rows: 40, columns: 120 },