feat(agent-core-v2): turn /tower into a mode parallel to plan mode

.changeset/tower-mode-command.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": minor
+---
+
+Add tower mode as a mode parallel to plan mode: run /tower to toggle it, or /tower <objective> to start multi-agent orchestration on an objective. Enable it with KIMI_CODE_EXPERIMENTAL_TOWER=1.

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

@@ -69,6 +69,7 @@ import {
   handleTitleCommand,
 } from './session';
 import { handleSwarmCommand } from './swarm';
+import { handleTowerCommand } from './tower';
 import { handleUndoCommand } from './undo';
 import { handleWebCommand } from './web';
 
@@ -96,6 +97,7 @@ export {
   showSettingsSelector,
 } from './config';
 export { handleSwarmCommand } from './swarm';
+export { handleTowerCommand } from './tower';
 export { handleFeedbackCommand, showMcpServers, showStatusReport, showUsage } from './info';
 export { handlePluginsCommand } from './plugins';
 export { handleReloadCommand, handleReloadTuiCommand } from './reload';
@@ -573,6 +575,9 @@ async function handleBuiltInSlashCommand(
     case 'swarm':
       await handleSwarmCommand(host, args);
       return;
+    case 'tower':
+      await handleTowerCommand(host, args);
+      return;
     case 'compact':
       await handleCompactCommand(host, args);
       return;

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

@@ -23,6 +23,7 @@ export {
   showSettingsSelector,
 } from './config';
 export { handleSwarmCommand } from './swarm';
+export { handleTowerCommand } from './tower';
 export { handleFeedbackCommand, showMcpServers, showStatusReport, showUsage } from './info';
 export { handlePluginsCommand } from './plugins';
 export { handleReloadCommand, handleReloadTuiCommand } from './reload';

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

@@ -176,6 +176,7 @@ export async function showStatusReport(host: SlashCommandHost): Promise<void> {
     thinkingEffort: appState.thinkingEffort,
     permissionMode: appState.permissionMode,
     planMode: appState.planMode,
+    towerMode: appState.towerMode,
     contextUsage: appState.contextUsage,
     contextTokens: appState.contextTokens,
     maxContextTokens: appState.maxContextTokens,

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

@@ -177,6 +177,15 @@ export const BUILTIN_SLASH_COMMANDS = [
     completeArgs: swarmArgumentCompletions,
     availability: 'idle-only',
   },
+  {
+    name: 'tower',
+    aliases: [],
+    description: 'Toggle tower mode or set the tower objective',
+    priority: 100,
+    argumentHint: '[on|off] | <objective>',
+    availability: 'always',
+    experimentalFlag: 'tower',
+  },
   {
     name: 'model',
     aliases: [],

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

@@ -87,7 +87,7 @@ export function resolveSlashCommandInput(options: ResolveSlashCommandInput): Sla
     // Skill activations are never blocked by a busy session: the TUI queues
     // them behind the running turn exactly like normal messages (see
     // sendSkillActivation), and Ctrl-S steers them as real activations, so
-    // commands like /tower can be issued any time.
+    // skill commands can be issued any time.
     return {
       kind: 'skill',
       commandName: parsed.name,

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

@@ -0,0 +1,66 @@
+import { NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import type { SlashCommandHost } from './dispatch';
+
+export async function handleTowerCommand(host: SlashCommandHost, args: string): Promise<void> {
+  if (host.session === undefined) {
+    if (!host.engineV2) {
+      host.showError(NO_ACTIVE_SESSION_MESSAGE);
+      return;
+    }
+    // v2 session-less: lazy-create the session, then toggle — the same path
+    // the first prompt takes.
+    const session = await host.ensureSession();
+    if (session === undefined) return;
+  }
+
+  const input = args.trim().toLowerCase();
+  if (input === 'on') {
+    await applyTowerMode(host, true);
+    return;
+  }
+  if (input === 'off') {
+    await applyTowerMode(host, false);
+    return;
+  }
+  if (input.length === 0) {
+    await applyTowerMode(host, !host.state.appState.towerMode);
+    return;
+  }
+
+  await startTowerObjective(host, args.trim());
+}
+
+async function startTowerObjective(host: SlashCommandHost, objective: string): Promise<void> {
+  if (!host.state.appState.towerMode) {
+    if (!(await setTowerMode(host, true))) return;
+    host.showNotice('Tower mode: ON');
+  }
+  host.sendNormalUserInput(objective);
+}
+
+async function applyTowerMode(host: SlashCommandHost, enabled: boolean): Promise<void> {
+  if (enabled && host.state.appState.towerMode) {
+    host.showStatus('Tower mode is already on.');
+    return;
+  }
+  if (!enabled && !host.state.appState.towerMode) {
+    host.showStatus('Tower mode is already off.');
+    return;
+  }
+  if (!(await setTowerMode(host, enabled))) return;
+  host.showNotice(enabled ? 'Tower mode: ON' : 'Tower mode: OFF');
+}
+
+async function setTowerMode(host: SlashCommandHost, enabled: boolean): Promise<boolean> {
+  try {
+    await host.requireSession().setTowerMode(enabled);
+  } catch (error) {
+    host.showError(
+      `Failed to ${enabled ? 'enable' : 'disable'} tower mode: ${formatErrorMessage(error)}`,
+    );
+    return false;
+  }
+  host.setAppState({ towerMode: enabled });
+  return true;
+}

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

@@ -391,6 +391,7 @@ export class FooterComponent implements Component {
     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.accent).bold('swarm'));
+    if (state.towerMode) modes.push(chalk.hex(colors.accent).bold('tower'));
     if (modes.length > 0) slots['mode'] = [modes.join(' ')];
 
     const goalBadge = formatGoalBadge(state.goal, colors, this.goalWallClockMs(state.goal));

apps/kimi-code/src/tui/components/messages/status-panel.ts

@@ -44,6 +44,7 @@ export interface StatusReportOptions {
   readonly thinkingEffort: ThinkingEffort;
   readonly permissionMode: PermissionMode;
   readonly planMode: boolean;
+  readonly towerMode: boolean;
   readonly contextUsage: number;
   readonly contextTokens: number;
   readonly maxContextTokens: number;
@@ -112,6 +113,7 @@ export function buildStatusReportLines(options: StatusReportOptions): string[] {
     { label: 'Directory', value: options.workDir },
     { label: 'Permissions', value: permission },
     { label: 'Plan mode', value: planMode ? 'on' : 'off' },
+    { label: 'Tower mode', value: options.towerMode ? 'on' : 'off' },
     { label: 'Session', value: sessionId },
   ];
   const title = options.sessionTitle?.trim();

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

@@ -717,6 +717,7 @@ export class SessionEventHandler {
     if (event.maxContextTokens !== undefined) patch.maxContextTokens = event.maxContextTokens;
     if (event.planMode !== undefined) patch.planMode = event.planMode;
     if (event.swarmMode !== undefined) patch.swarmMode = event.swarmMode;
+    if (event.towerMode !== undefined) patch.towerMode = event.towerMode;
     if (event.permission !== undefined) {
       patch.permissionMode = event.permission;
     }

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

@@ -259,6 +259,7 @@ function createInitialAppState(input: KimiTUIStartupInput): AppState {
     planMode: input.cliOptions.plan,
     inputMode: 'prompt',
     swarmMode: false,
+    towerMode: false,
     thinkingEffort: 'off',
     contextUsage: 0,
     contextTokens: 0,
@@ -2314,6 +2315,7 @@ export class KimiTUI {
       permissionMode: status.permission,
       planMode: status.planMode,
       swarmMode: status.swarmMode ?? false,
+      towerMode: status.towerMode ?? false,
       contextTokens: status.contextTokens,
       maxContextTokens: status.maxContextTokens,
       contextUsage: status.contextUsage,

apps/kimi-code/src/tui/types.ts

@@ -39,6 +39,7 @@ export interface AppState {
   /** 'bash' when the editor is in `!` shell-command mode. */
   inputMode: 'prompt' | 'bash';
   swarmMode: boolean;
+  towerMode: boolean;
   /** Live thinking effort of the active session (e.g. 'off', 'on', 'high');
    * mirrors the runtime. The single source of truth for the thinking state in
    * the TUI. */

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

@@ -173,6 +173,7 @@ describe('built-in slash command registry', () => {
         'status',
         'theme',
         'title',
+        'tower',
         'undo',
         'usage',
         'version',
@@ -197,4 +198,13 @@ describe('built-in slash command registry', () => {
     expect((command as KimiSlashCommand).experimentalFlag).toBe('secondary-model');
     expect(resolveSlashCommandAvailability(command!, '')).toBe('always');
   });
+
+  it('gates tower behind the tower experiment, always available', () => {
+    const command = findBuiltInSlashCommand('tower');
+    expect(command).toBeDefined();
+    expect((command as KimiSlashCommand).experimentalFlag).toBe('tower');
+    expect(resolveSlashCommandAvailability(command!, '')).toBe('always');
+    expect(resolveSlashCommandAvailability(command!, 'on')).toBe('always');
+    expect(resolveSlashCommandAvailability(command!, 'Ship feature X')).toBe('always');
+  });
 });

apps/kimi-code/test/tui/commands/resolve.test.ts

@@ -255,6 +255,22 @@ describe('resolveSlashCommandInput', () => {
     });
   });
 
+  it('resolves /tower to the builtin command when the tower flag is enabled', () => {
+    setExperimentalFeatures([{ id: 'tower', enabled: true }]);
+
+    expect(resolve('/tower Ship feature X')).toMatchObject({
+      kind: 'builtin',
+      name: 'tower',
+      args: 'Ship feature X',
+    });
+  });
+
+  it('does not resolve /tower as a builtin when the tower flag is disabled', () => {
+    expect(resolve('/tower Ship feature X')).toEqual({
+      kind: 'message',
+      input: '/tower Ship feature X',
+    });
+  });
 });
 
 describe('goal command resolution', () => {