feat(cli): extend non-blocking slash commands to more builtins

docs/design/nonblocking-slash-commands.md

@@ -32,6 +32,19 @@ stdout while Ink is rendering.
   existing settings hooks without replacing the active conversation turn.
 - `/help`: opens the static help dialog.
 
+## Extended Command Set
+
+The same criteria were later applied to eleven more builtins:
+
+- UI-preference commands whose saved changes apply through the existing
+  settings hooks without touching the active turn: `/theme`, `/editor`,
+  `/vim`, `/voice`, and `/terminal-setup` (writes only external IDE
+  keybinding files).
+- Read-only status commands that neither read state the active turn is
+  writing nor mutate anything: `/tools`, `/lsp`, `/tasks`, `/hooks`
+  (read-only browse dialog), `/docs`, and `/bug` (the latter two only
+  append an Ink item and open a browser).
+
 The following categories remain serialized:
 
 - Commands that submit or transform a model turn, such as skills, `/summary`,

packages/cli/src/ui/commands/bugCommand.test.ts

@@ -54,6 +54,10 @@ describe('bugCommand', () => {
     vi.clearAllMocks();
   });
 
+  it('opts in to running during streaming', () => {
+    expect(bugCommand.canRunDuringStreaming).toBe(true);
+  });
+
   it('should generate the default GitHub issue URL', async () => {
     const mockContext = createMockCommandContext({
       services: {

packages/cli/src/ui/commands/bugCommand.ts

@@ -23,6 +23,7 @@ export const bugCommand: SlashCommand = {
   kind: CommandKind.BUILT_IN,
   argumentHint: '<description>',
   supportedModes: ['interactive', 'non_interactive', 'acp'] as const,
+  canRunDuringStreaming: true,
   action: async (context: CommandContext, args?: string): Promise<void> => {
     const bugDescription = (args || '').trim();
     const systemInfo = await getExtendedSystemInfo(context);

packages/cli/src/ui/commands/docsCommand.test.ts

@@ -35,6 +35,10 @@ describe('docsCommand', () => {
     vi.unstubAllEnvs();
   });
 
+  it('opts in to running during streaming', () => {
+    expect(docsCommand.canRunDuringStreaming).toBe(true);
+  });
+
   it("should add an info message and call 'open' in a non-sandbox environment", async () => {
     if (!docsCommand.action) {
       throw new Error('docsCommand must have an action.');

packages/cli/src/ui/commands/docsCommand.ts

@@ -21,6 +21,7 @@ export const docsCommand: SlashCommand = {
   },
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive', 'non_interactive', 'acp'] as const,
+  canRunDuringStreaming: true,
   action: async (context: CommandContext) => {
     const langPath = getCurrentLanguage()?.startsWith('zh') ? 'zh' : 'en';
     const docsUrl = `https://qwenlm.github.io/qwen-code-docs/${langPath}`;

packages/cli/src/ui/commands/editorCommand.test.ts

@@ -26,5 +26,6 @@ describe('editorCommand', () => {
   it('should have the correct name and description', () => {
     expect(editorCommand.name).toBe('editor');
     expect(editorCommand.description).toBe('set external editor preference');
+    expect(editorCommand.canRunDuringStreaming).toBe(true);
   });
 });

packages/cli/src/ui/commands/editorCommand.ts

@@ -18,6 +18,7 @@ export const editorCommand: SlashCommand = {
   },
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive'] as const,
+  canRunDuringStreaming: true,
   action: (): OpenDialogActionReturn => ({
     type: 'dialog',
     dialog: 'editor',

packages/cli/src/ui/commands/hooksCommand.test.ts

@@ -32,6 +32,10 @@ describe('hooksCommand', () => {
     });
   });
 
+  it('opts in to running during streaming', () => {
+    expect(hooksCommand.canRunDuringStreaming).toBe(true);
+  });
+
   describe('basic functionality', () => {
     it('should open hooks management dialog in interactive mode', async () => {
       const result = await hooksCommand.action!(mockContext, '');

packages/cli/src/ui/commands/hooksCommand.ts

@@ -197,6 +197,7 @@ export const hooksCommand: SlashCommand = {
   },
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive', 'non_interactive', 'acp'] as const,
+  canRunDuringStreaming: true,
   action: async (
     context: CommandContext,
     args: string,

packages/cli/src/ui/commands/lspCommand.test.ts

@@ -30,6 +30,10 @@ describe('lspCommand', () => {
     ]);
   });
 
+  it('opts in to running during streaming', () => {
+    expect(lspCommand.canRunDuringStreaming).toBe(true);
+  });
+
   it('returns an error when config is unavailable in non-interactive mode', async () => {
     if (!lspCommand.action) {
       throw new Error('lspCommand must have an action');

packages/cli/src/ui/commands/lspCommand.ts

@@ -42,6 +42,7 @@ export const lspCommand: SlashCommand = {
   },
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive', 'non_interactive', 'acp'] as const,
+  canRunDuringStreaming: true,
   action: async (
     context: CommandContext,
     _args?: string,

packages/cli/src/ui/commands/tasksCommand.test.ts

@@ -105,6 +105,10 @@ describe('tasksCommand', () => {
     } as unknown as Parameters<typeof createMockCommandContext>[0]);
   });
 
+  it('opts in to running during streaming', () => {
+    expect(tasksCommand.canRunDuringStreaming).toBe(true);
+  });
+
   it('reports an empty registry', async () => {
     const result = await tasksCommand.action!(context, '');
     expect(result).toEqual({

packages/cli/src/ui/commands/tasksCommand.ts

@@ -166,6 +166,7 @@ export const tasksCommand: SlashCommand = {
   // text dump as the only way to inspect background task state. See the
   // interactive-mode hint at the top of the output for the soft redirect.
   supportedModes: ['interactive', 'non_interactive', 'acp'] as const,
+  canRunDuringStreaming: true,
   action: async (context) => {
     const { config } = context.services;
     if (!config) {

packages/cli/src/ui/commands/terminalSetupCommand.test.ts

@@ -20,6 +20,7 @@ describe('terminalSetupCommand', () => {
     expect(terminalSetupCommand.name).toBe('terminal-setup');
     expect(terminalSetupCommand.description).toContain('multiline input');
     expect(terminalSetupCommand.kind).toBe('built-in');
+    expect(terminalSetupCommand.canRunDuringStreaming).toBe(true);
   });
 
   it('should return success message when terminal setup succeeds', async () => {

packages/cli/src/ui/commands/terminalSetupCommand.ts

@@ -24,6 +24,7 @@ export const terminalSetupCommand: SlashCommand = {
   },
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive'] as const,
+  canRunDuringStreaming: true,
 
   action: async (): Promise<MessageActionReturn> => {
     try {

packages/cli/src/ui/commands/themeCommand.test.ts

@@ -57,5 +57,6 @@ describe('themeCommand', () => {
   it('should have the correct name and description', () => {
     expect(themeCommand.name).toBe('theme');
     expect(themeCommand.description).toBe('change the theme');
+    expect(themeCommand.canRunDuringStreaming).toBe(true);
   });
 });

packages/cli/src/ui/commands/themeCommand.ts

@@ -20,6 +20,7 @@ export const themeCommand: SlashCommand = {
   },
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive'] as const,
+  canRunDuringStreaming: true,
   action: (_context, _args): OpenDialogActionReturn | MessageActionReturn => {
     // Reject before opening the dialog: with NO_COLOR the theme picker
     // cannot run, and returning a message lets the processor record the

packages/cli/src/ui/commands/toolsCommand.test.ts

@@ -27,6 +27,10 @@ const mockTools = [
 ] as Tool[];
 
 describe('toolsCommand', () => {
+  it('opts in to running during streaming', () => {
+    expect(toolsCommand.canRunDuringStreaming).toBe(true);
+  });
+
   it('should display an error if the tool registry is unavailable', async () => {
     const mockContext = createMockCommandContext({
       services: {

packages/cli/src/ui/commands/toolsCommand.ts

@@ -18,6 +18,7 @@ export const toolsCommand: SlashCommand = {
     return t('List available Qwen Code tools. Usage: /tools [desc]');
   },
   kind: CommandKind.BUILT_IN,
+  canRunDuringStreaming: true,
   action: async (context: CommandContext, args?: string): Promise<void> => {
     const subCommand = args?.trim();
 

packages/cli/src/ui/commands/vimCommand.test.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { vimCommand } from './vimCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+
+describe('vimCommand', () => {
+  it('should have the correct metadata', () => {
+    expect(vimCommand.name).toBe('vim');
+    expect(vimCommand.description).toBe('toggle vim mode on/off');
+    expect(vimCommand.canRunDuringStreaming).toBe(true);
+  });
+
+  it('should report entering vim mode when toggled on', async () => {
+    const mockContext = createMockCommandContext({
+      ui: {
+        toggleVimEnabled: vi.fn().mockResolvedValue(true),
+      },
+    });
+
+    const result = await vimCommand.action!(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Entered Vim mode. Run /vim again to exit.',
+    });
+  });
+
+  it('should report exiting vim mode when toggled off', async () => {
+    const mockContext = createMockCommandContext({
+      ui: {
+        toggleVimEnabled: vi.fn().mockResolvedValue(false),
+      },
+    });
+
+    const result = await vimCommand.action!(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Exited Vim mode.',
+    });
+  });
+});

packages/cli/src/ui/commands/vimCommand.ts

@@ -15,6 +15,7 @@ export const vimCommand: SlashCommand = {
   },
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive'] as const,
+  canRunDuringStreaming: true,
   action: async (context, _args) => {
     const newVimState = await context.ui.toggleVimEnabled();
 

packages/cli/src/ui/commands/voice-command.test.ts

@@ -28,6 +28,7 @@ describe('voice-command', () => {
   it('has the expected metadata', () => {
     expect(voiceCommand.name).toBe('voice');
     expect(voiceCommand.argumentHint).toBe('[hold|tap|off|status]');
+    expect(voiceCommand.canRunDuringStreaming).toBe(true);
   });
 
   it('prompts for a voice model before enabling', async () => {

packages/cli/src/ui/commands/voice-command.ts

@@ -23,6 +23,7 @@ export const voiceCommand: SlashCommand = {
   argumentHint: '[hold|tap|off|status]',
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive'] as const,
+  canRunDuringStreaming: true,
   action: (context, args) => {
     const settings = context.services.settings;
     const command = args.trim().toLowerCase();