fix(core): address post-merge monitor tool and UI routing issues

packages/cli/src/nonInteractiveCli.test.ts

@@ -29,7 +29,10 @@ import type { LoadedSettings } from './config/settings.js';
 import { CommandKind, type ExecutionMode } from './ui/commands/types.js';
 import { filterCommandsForMode } from './services/commandUtils.js';
 import { _resetCleanupFunctionsForTest } from './utils/cleanup.js';
-import { AlreadyReportedError, _resetExitLatchForTest } from './utils/errors.js';
+import {
+  AlreadyReportedError,
+  _resetExitLatchForTest,
+} from './utils/errors.js';
 
 // Mock core modules
 vi.mock('./ui/hooks/atCommandProcessor.js');

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

@@ -71,6 +71,7 @@ describe('clearCommand', () => {
           }),
           getBackgroundShellRegistry: vi.fn().mockReturnValue({
             getAll: vi.fn().mockReturnValue([]),
+            hasRunningEntries: vi.fn().mockReturnValue(false),
             reset: mockResetBackgroundShells,
             abortAll: mockAbortBackgroundShells,
           }),
@@ -307,6 +308,7 @@ describe('clearCommand', () => {
             }),
             getBackgroundShellRegistry: vi.fn().mockReturnValue({
               getAll: vi.fn().mockReturnValue([]),
+              hasRunningEntries: vi.fn().mockReturnValue(false),
               reset: mockResetBackgroundShells,
               abortAll: mockAbortBackgroundShells,
             }),
@@ -380,6 +382,7 @@ describe('clearCommand', () => {
             }),
             getBackgroundShellRegistry: vi.fn().mockReturnValue({
               getAll: vi.fn().mockReturnValue([]),
+              hasRunningEntries: vi.fn().mockReturnValue(false),
               reset: vi.fn(),
             }),
             getMonitorRegistry: vi.fn().mockReturnValue({
@@ -430,6 +433,7 @@ describe('clearCommand', () => {
             }),
             getBackgroundShellRegistry: vi.fn().mockReturnValue({
               getAll: vi.fn().mockReturnValue([]),
+              hasRunningEntries: vi.fn().mockReturnValue(false),
               reset: vi.fn(),
             }),
             getMonitorRegistry: vi.fn().mockReturnValue({
@@ -470,5 +474,61 @@ describe('clearCommand', () => {
       expect(mockStartNewSession).not.toHaveBeenCalled();
       expect(mockResetChat).not.toHaveBeenCalled();
     });
+
+    it('blocks session clearing while a background shell is still running', async () => {
+      if (!clearCommand.action)
+        throw new Error('clearCommand must have an action.');
+
+      const blockedContext = createMockCommandContext({
+        executionMode: 'non_interactive',
+        services: {
+          config: {
+            getBackgroundTaskRegistry: vi.fn().mockReturnValue({
+              hasUnfinalizedTasks: vi.fn().mockReturnValue(false),
+              reset: vi.fn(),
+            }),
+            getBackgroundShellRegistry: vi.fn().mockReturnValue({
+              getAll: vi.fn().mockReturnValue([
+                {
+                  shellId: 'shell_123',
+                  status: 'running',
+                },
+              ]),
+              hasRunningEntries: vi.fn().mockReturnValue(true),
+              reset: vi.fn(),
+            }),
+            getMonitorRegistry: vi.fn().mockReturnValue({
+              getRunning: vi.fn().mockReturnValue([]),
+              reset: vi.fn(),
+            }),
+            getHookSystem: mockGetHookSystem,
+            startNewSession: mockStartNewSession,
+            getGeminiClient: vi.fn().mockReturnValue({
+              resetChat: mockResetChat,
+            } as unknown as GeminiClient),
+            getModel: vi.fn().mockReturnValue('test-model'),
+            getApprovalMode: vi.fn().mockReturnValue('default'),
+            getToolRegistry: vi.fn().mockReturnValue({
+              getAllTools: vi.fn().mockReturnValue([]),
+            }),
+            getDebugLogger: vi.fn().mockReturnValue({ warn: vi.fn() }),
+          },
+        },
+        session: {
+          startNewSession: vi.fn(),
+        },
+      });
+
+      const result = await clearCommand.action(blockedContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content:
+          "Stop the current session's running background tasks before starting a new session.",
+      });
+      expect(mockStartNewSession).not.toHaveBeenCalled();
+      expect(mockResetChat).not.toHaveBeenCalled();
+    });
   });
 });

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

@@ -12,26 +12,12 @@ import {
   SessionEndReason,
   SessionStartSource,
   ToolNames,
-  type Config,
   type PermissionMode,
 } from '@qwen-code/qwen-code-core';
-
-function hasBlockingBackgroundWork(config: Config): boolean {
-  return (
-    config.getBackgroundTaskRegistry().hasUnfinalizedTasks() ||
-    config.getMonitorRegistry().getRunning().length > 0 ||
-    config
-      .getBackgroundShellRegistry()
-      .getAll()
-      .some((entry) => entry.status === 'running')
-  );
-}
-
-function resetBackgroundStateForSessionSwitch(config: Config): void {
-  config.getBackgroundTaskRegistry().reset();
-  config.getMonitorRegistry().reset();
-  config.getBackgroundShellRegistry().reset();
-}
+import {
+  hasBlockingBackgroundWork,
+  resetBackgroundStateForSessionSwitch,
+} from '../utils/backgroundWorkUtils.js';
 
 export const clearCommand: SlashCommand = {
   name: 'clear',

packages/cli/src/ui/hooks/useResumeCommand.test.ts

@@ -163,6 +163,7 @@ describe('useResumeCommand', () => {
       }),
       getBackgroundShellRegistry: () => ({
         getAll: vi.fn().mockReturnValue([]),
+        hasRunningEntries: vi.fn().mockReturnValue(false),
         reset: vi.fn(),
       }),
       getMonitorRegistry: () => ({
@@ -248,6 +249,7 @@ describe('useResumeCommand', () => {
       }),
       getBackgroundShellRegistry: () => ({
         getAll: vi.fn().mockReturnValue([]),
+        hasRunningEntries: vi.fn().mockReturnValue(false),
         reset: vi.fn(),
       }),
       getMonitorRegistry: () => ({
@@ -306,6 +308,7 @@ describe('useResumeCommand', () => {
       }),
       getBackgroundShellRegistry: () => ({
         getAll: vi.fn().mockReturnValue([]),
+        hasRunningEntries: vi.fn().mockReturnValue(false),
         reset: vi.fn(),
       }),
       getMonitorRegistry: () => ({
@@ -364,6 +367,7 @@ describe('useResumeCommand', () => {
       }),
       getBackgroundShellRegistry: () => ({
         getAll: vi.fn().mockReturnValue([]),
+        hasRunningEntries: vi.fn().mockReturnValue(false),
         reset: vi.fn(),
       }),
       getMonitorRegistry: () => ({

packages/cli/src/ui/hooks/useResumeCommand.ts

@@ -15,6 +15,10 @@ import {
 import { buildResumedHistoryItems } from '../utils/resumeHistoryUtils.js';
 import type { UseHistoryManagerReturn } from './useHistoryManager.js';
 import { MessageType, type HistoryItem } from '../types.js';
+import {
+  hasBlockingBackgroundWork,
+  resetBackgroundStateForSessionSwitch,
+} from '../utils/backgroundWorkUtils.js';
 
 export interface UseResumeCommandOptions {
   config: Config | null;
@@ -45,23 +49,6 @@ export interface UseResumeCommandResult {
 const BACKGROUND_WORK_SWITCH_BLOCKED_MESSAGE =
   "Stop the current session's running background tasks before resuming another session.";
 
-function hasBlockingBackgroundWork(config: Config): boolean {
-  return (
-    config.getBackgroundTaskRegistry().hasUnfinalizedTasks() ||
-    config.getMonitorRegistry().getRunning().length > 0 ||
-    config
-      .getBackgroundShellRegistry()
-      .getAll()
-      .some((entry) => entry.status === 'running')
-  );
-}
-
-function resetBackgroundStateForSessionSwitch(config: Config): void {
-  config.getBackgroundTaskRegistry().reset();
-  config.getMonitorRegistry().reset();
-  config.getBackgroundShellRegistry().reset();
-}
-
 export function useResumeCommand(
   options?: UseResumeCommandOptions,
 ): UseResumeCommandResult {

packages/cli/src/ui/utils/backgroundWorkUtils.test.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import type { Config } from '@qwen-code/qwen-code-core';
+import {
+  hasBlockingBackgroundWork,
+  resetBackgroundStateForSessionSwitch,
+} from './backgroundWorkUtils.js';
+
+function createMockConfig(overrides?: {
+  hasUnfinalizedTasks?: boolean;
+  runningMonitors?: unknown[];
+  hasRunningEntries?: boolean;
+}): Config {
+  return {
+    getBackgroundTaskRegistry: () => ({
+      hasUnfinalizedTasks: () => overrides?.hasUnfinalizedTasks ?? false,
+      reset: vi.fn(),
+    }),
+    getMonitorRegistry: () => ({
+      getRunning: () => overrides?.runningMonitors ?? [],
+      reset: vi.fn(),
+    }),
+    getBackgroundShellRegistry: () => ({
+      hasRunningEntries: () => overrides?.hasRunningEntries ?? false,
+      reset: vi.fn(),
+    }),
+  } as unknown as Config;
+}
+
+describe('hasBlockingBackgroundWork', () => {
+  it('returns false when nothing is running', () => {
+    expect(hasBlockingBackgroundWork(createMockConfig())).toBe(false);
+  });
+
+  it('returns true when background tasks are unfinalized', () => {
+    expect(
+      hasBlockingBackgroundWork(
+        createMockConfig({ hasUnfinalizedTasks: true }),
+      ),
+    ).toBe(true);
+  });
+
+  it('returns true when monitors are running', () => {
+    expect(
+      hasBlockingBackgroundWork(
+        createMockConfig({ runningMonitors: [{ id: 'm1' }] }),
+      ),
+    ).toBe(true);
+  });
+
+  it('returns true when shell entries are running', () => {
+    expect(
+      hasBlockingBackgroundWork(createMockConfig({ hasRunningEntries: true })),
+    ).toBe(true);
+  });
+
+  it('short-circuits: does not check monitors or shells when tasks are unfinalized', () => {
+    const config = {
+      getBackgroundTaskRegistry: () => ({
+        hasUnfinalizedTasks: () => true,
+        reset: vi.fn(),
+      }),
+      getMonitorRegistry: () => {
+        throw new Error('should not be called');
+      },
+      getBackgroundShellRegistry: () => {
+        throw new Error('should not be called');
+      },
+    } as unknown as Config;
+
+    expect(hasBlockingBackgroundWork(config)).toBe(true);
+  });
+
+  it('short-circuits: does not check shells when monitors are running', () => {
+    const config = {
+      getBackgroundTaskRegistry: () => ({
+        hasUnfinalizedTasks: () => false,
+        reset: vi.fn(),
+      }),
+      getMonitorRegistry: () => ({
+        getRunning: () => [{ id: 'm1' }],
+        reset: vi.fn(),
+      }),
+      getBackgroundShellRegistry: () => {
+        throw new Error('should not be called');
+      },
+    } as unknown as Config;
+
+    expect(hasBlockingBackgroundWork(config)).toBe(true);
+  });
+});
+
+describe('resetBackgroundStateForSessionSwitch', () => {
+  it('calls reset on all three registries', () => {
+    const resetTasks = vi.fn();
+    const resetMonitors = vi.fn();
+    const resetShells = vi.fn();
+
+    const config = {
+      getBackgroundTaskRegistry: () => ({ reset: resetTasks }),
+      getMonitorRegistry: () => ({ reset: resetMonitors }),
+      getBackgroundShellRegistry: () => ({ reset: resetShells }),
+    } as unknown as Config;
+
+    resetBackgroundStateForSessionSwitch(config);
+
+    expect(resetTasks).toHaveBeenCalledOnce();
+    expect(resetMonitors).toHaveBeenCalledOnce();
+    expect(resetShells).toHaveBeenCalledOnce();
+  });
+});

packages/cli/src/ui/utils/backgroundWorkUtils.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Config } from '@qwen-code/qwen-code-core';
+
+export function hasBlockingBackgroundWork(config: Config): boolean {
+  return (
+    config.getBackgroundTaskRegistry().hasUnfinalizedTasks() ||
+    config.getMonitorRegistry().getRunning().length > 0 ||
+    config.getBackgroundShellRegistry().hasRunningEntries()
+  );
+}
+
+export function resetBackgroundStateForSessionSwitch(config: Config): void {
+  config.getBackgroundTaskRegistry().reset();
+  config.getMonitorRegistry().reset();
+  config.getBackgroundShellRegistry().reset();
+}

packages/cli/src/utils/errors.test.ts

@@ -267,7 +267,8 @@ describe('errors', () => {
             {
               error: {
                 type: 'AlreadyReportedError',
-                message: '[API Error: 402 Model X is not available for billing.]',
+                message:
+                  '[API Error: 402 Model X is not available for billing.]',
                 code: 42,
               },
             },