fix(hooks): terminate hook child processes when user exits CLI

packages/cli/src/ui/AppContainer.tsx

@@ -41,6 +41,7 @@ import {
   Storage,
   SessionEndReason,
   SessionStartSource,
+  type PermissionMode,
 } from '@qwen-code/qwen-code-core';
 import { buildResumedHistoryItems } from './utils/resumeHistoryUtils.js';
 import { validateAuthMethod } from '../config/auth.js';
@@ -308,7 +309,11 @@ export const AppContainer = (props: AppContainerProps) => {
 
       if (hookSystem) {
         hookSystem
-          .fireSessionStartEvent(sessionStartSource, config.getModel() ?? '')
+          .fireSessionStartEvent(
+            sessionStartSource,
+            config.getModel() ?? '',
+            String(config.getApprovalMode()) as PermissionMode,
+          )
           .then(() => {
             debugLogger.debug('SessionStart event completed successfully');
           })

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

@@ -59,6 +59,7 @@ describe('clearCommand', () => {
           }),
           getModel: () => 'test-model',
           getToolRegistry: () => undefined,
+          getApprovalMode: () => 'default',
         },
       },
       session: {
@@ -108,6 +109,7 @@ describe('clearCommand', () => {
     expect(mockFireSessionStartEvent).toHaveBeenCalledWith(
       SessionStartSource.Clear,
       'test-model',
+      expect.any(String), // permissionMode
     );
 
     // SessionEnd should be called before SessionStart

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

@@ -13,6 +13,7 @@ import {
   SessionStartSource,
   ToolNames,
   SkillTool,
+  type PermissionMode,
 } from '@qwen-code/qwen-code-core';
 
 export const clearCommand: SlashCommand = {
@@ -72,6 +73,7 @@ export const clearCommand: SlashCommand = {
           ?.fireSessionStartEvent(
             SessionStartSource.Clear,
             config.getModel() ?? '',
+            String(config.getApprovalMode()) as PermissionMode,
           );
       } catch (err) {
         config.getDebugLogger().warn(`SessionStart hook failed: ${err}`);

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

@@ -9,6 +9,7 @@ import {
   SessionService,
   type Config,
   SessionStartSource,
+  type PermissionMode,
 } from '@qwen-code/qwen-code-core';
 import { buildResumedHistoryItems } from '../utils/resumeHistoryUtils.js';
 import type { UseHistoryManagerReturn } from './useHistoryManager.js';
@@ -78,6 +79,7 @@ export function useResumeCommand(
           ?.fireSessionStartEvent(
             SessionStartSource.Resume,
             config.getModel() ?? '',
+            String(config.getApprovalMode()) as PermissionMode,
           );
       } catch (err) {
         config.getDebugLogger().warn(`SessionStart hook failed: ${err}`);

packages/core/src/config/config.ts

@@ -810,19 +810,33 @@ export class Config {
               return;
             }
 
+            // Check if request was aborted
+            if (request.signal?.aborted) {
+              this.messageBus?.publish({
+                type: MessageBusType.HOOK_EXECUTION_RESPONSE,
+                correlationId: request.correlationId,
+                success: false,
+                error: new Error('Hook execution cancelled (aborted)'),
+              } as HookExecutionResponse);
+              return;
+            }
+
             // Execute the appropriate hook based on eventName
             let result;
             const input = request.input || {};
+            const signal = request.signal;
             switch (request.eventName) {
               case 'UserPromptSubmit':
                 result = await hookSystem.fireUserPromptSubmitEvent(
                   (input['prompt'] as string) || '',
+                  signal,
                 );
                 break;
               case 'Stop':
                 result = await hookSystem.fireStopEvent(
                   (input['stop_hook_active'] as boolean) || false,
                   (input['last_assistant_message'] as string) || '',
+                  signal,
                 );
                 break;
               case 'PreToolUse': {
@@ -832,6 +846,7 @@ export class Config {
                   (input['tool_use_id'] as string) || '',
                   (input['permission_mode'] as PermissionMode | undefined) ??
                     PermissionMode.Default,
+                  signal,
                 );
                 break;
               }
@@ -842,6 +857,7 @@ export class Config {
                   (input['tool_response'] as Record<string, unknown>) || {},
                   (input['tool_use_id'] as string) || '',
                   (input['permission_mode'] as PermissionMode) || 'default',
+                  signal,
                 );
                 break;
               case 'PostToolUseFailure':
@@ -852,6 +868,7 @@ export class Config {
                   (input['error'] as string) || '',
                   input['is_interrupt'] as boolean | undefined,
                   (input['permission_mode'] as PermissionMode) || 'default',
+                  signal,
                 );
                 break;
               case 'Notification':
@@ -860,6 +877,7 @@ export class Config {
                   (input['notification_type'] as NotificationType) ||
                     'permission_prompt',
                   (input['title'] as string) || undefined,
+                  signal,
                 );
                 break;
               case 'PermissionRequest':
@@ -871,6 +889,7 @@ export class Config {
                   (input['permission_suggestions'] as
                     | PermissionSuggestion[]
                     | undefined) || undefined,
+                  signal,
                 );
                 break;
               case 'SubagentStart':
@@ -879,6 +898,7 @@ export class Config {
                   (input['agent_type'] as string) || '',
                   (input['permission_mode'] as PermissionMode) ||
                     PermissionMode.Default,
+                  signal,
                 );
                 break;
               case 'SubagentStop':
@@ -890,6 +910,7 @@ export class Config {
                   (input['stop_hook_active'] as boolean) || false,
                   (input['permission_mode'] as PermissionMode) ||
                     PermissionMode.Default,
+                  signal,
                 );
                 break;
               default:

packages/core/src/confirmation-bus/message-bus.ts

@@ -90,10 +90,17 @@ export class MessageBus extends EventEmitter {
     request: Omit<TRequest, 'correlationId'>,
     responseType: TResponse['type'],
     timeoutMs: number = 60000,
+    signal?: AbortSignal,
   ): Promise<TResponse> {
     const correlationId = randomUUID();
 
     return new Promise<TResponse>((resolve, reject) => {
+      // Check if already aborted
+      if (signal?.aborted) {
+        reject(new Error('Request aborted'));
+        return;
+      }
+
       const timeoutId = setTimeout(() => {
         cleanup();
         reject(new Error(`Request timed out waiting for ${responseType}`));
@@ -102,8 +109,20 @@ export class MessageBus extends EventEmitter {
       const cleanup = () => {
         clearTimeout(timeoutId);
         this.unsubscribe(responseType, responseHandler);
+        if (signal) {
+          signal.removeEventListener('abort', abortHandler);
+        }
+      };
+
+      const abortHandler = () => {
+        cleanup();
+        reject(new Error('Request aborted'));
       };
 
+      if (signal) {
+        signal.addEventListener('abort', abortHandler);
+      }
+
       const responseHandler = (response: TResponse) => {
         // Check if this response matches our request
         if (

packages/core/src/confirmation-bus/types.ts

@@ -109,6 +109,8 @@ export interface HookExecutionRequest {
   eventName: string;
   input: Record<string, unknown>;
   correlationId: string;
+  /** Optional AbortSignal to cancel hook execution */
+  signal?: AbortSignal;
 }
 
 export interface HookExecutionResponse {

packages/core/src/core/client.ts

@@ -535,7 +535,7 @@ export class GeminiClient {
       return new Turn(this.getChat(), prompt_id);
     }
 
-    const compressed = await this.tryCompressChat(prompt_id, false);
+    const compressed = await this.tryCompressChat(prompt_id, false, signal);
 
     if (compressed.compressionStatus === CompressionStatus.COMPRESSED) {
       yield { type: GeminiEventType.ChatCompressed, value: compressed };
@@ -677,7 +677,13 @@ export class GeminiClient {
     }
     // Fire Stop hook through MessageBus (only if hooks are enabled)
     // This must be done before any early returns to ensure hooks are always triggered
-    if (hooksEnabled && messageBus && !turn.pendingToolCalls.length) {
+    if (
+      hooksEnabled &&
+      messageBus &&
+      !turn.pendingToolCalls.length &&
+      signal &&
+      !signal.aborted
+    ) {
       // Get response text from the chat history
       const history = this.getHistory();
       const lastModelMessage = history
@@ -700,26 +706,38 @@ export class GeminiClient {
             stop_hook_active: true,
             last_assistant_message: responseText,
           },
+          signal,
         },
         MessageBusType.HOOK_EXECUTION_RESPONSE,
       );
+
+      // Check if aborted after hook execution
+      if (signal.aborted) {
+        return turn;
+      }
+
       const hookOutput = response.output
         ? createHookOutput('Stop', response.output)
         : undefined;
 
       const stopOutput = hookOutput as StopHookOutput | undefined;
 
+      // This should happen regardless of the hook's decision
+      if (stopOutput?.systemMessage) {
+        yield {
+          type: GeminiEventType.HookSystemMessage,
+          value: stopOutput.systemMessage,
+        };
+      }
+
       // For Stop hooks, blocking/stop execution should force continuation
       if (
         stopOutput?.isBlockingDecision() ||
         stopOutput?.shouldStopExecution()
       ) {
-        // Emit system message if provided (e.g., "🔄 Ralph iteration 5")
-        if (stopOutput.systemMessage) {
-          yield {
-            type: GeminiEventType.HookSystemMessage,
-            value: stopOutput.systemMessage,
-          };
+        // Check if aborted before continuing
+        if (signal.aborted) {
+          return turn;
         }
 
         const continueReason = stopOutput.getEffectiveReason();
@@ -844,6 +862,7 @@ export class GeminiClient {
   async tryCompressChat(
     prompt_id: string,
     force: boolean = false,
+    signal?: AbortSignal,
   ): Promise<ChatCompressionInfo> {
     const compressionService = new ChatCompressionService();
 
@@ -854,6 +873,7 @@ export class GeminiClient {
       this.config.getModel(),
       this.config,
       this.hasFailedCompressionAttempt,
+      signal,
     );
 
     // Handle compression result

packages/core/src/core/toolHookTriggers.ts

@@ -81,6 +81,7 @@ export async function firePreToolUseHook(
   toolInput: Record<string, unknown>,
   toolUseId: string,
   permissionMode: string,
+  signal?: AbortSignal,
 ): Promise<PreToolUseHookResult> {
   if (!messageBus) {
     return { shouldProceed: true };
@@ -100,6 +101,7 @@ export async function firePreToolUseHook(
           tool_input: toolInput,
           tool_use_id: toolUseId,
         },
+        signal,
       },
       MessageBusType.HOOK_EXECUTION_RESPONSE,
     );
@@ -178,6 +180,7 @@ export async function firePostToolUseHook(
   toolResponse: Record<string, unknown>,
   toolUseId: string,
   permissionMode: string,
+  signal?: AbortSignal,
 ): Promise<PostToolUseHookResult> {
   if (!messageBus) {
     return { shouldStop: false };
@@ -198,6 +201,7 @@ export async function firePostToolUseHook(
           tool_response: toolResponse,
           tool_use_id: toolUseId,
         },
+        signal,
       },
       MessageBusType.HOOK_EXECUTION_RESPONSE,
     );
@@ -255,6 +259,7 @@ export async function firePostToolUseFailureHook(
   errorMessage: string,
   isInterrupt?: boolean,
   permissionMode?: string,
+  signal?: AbortSignal,
 ): Promise<PostToolUseFailureHookResult> {
   if (!messageBus) {
     return {};
@@ -276,6 +281,7 @@ export async function firePostToolUseFailureHook(
           error: errorMessage,
           is_interrupt: isInterrupt,
         },
+        signal,
       },
       MessageBusType.HOOK_EXECUTION_RESPONSE,
     );
@@ -319,6 +325,7 @@ export async function fireNotificationHook(
   message: string,
   notificationType: NotificationType,
   title?: string,
+  signal?: AbortSignal,
 ): Promise<NotificationHookResult> {
   if (!messageBus) {
     return {};
@@ -337,6 +344,7 @@ export async function fireNotificationHook(
           notification_type: notificationType,
           title,
         },
+        signal,
       },
       MessageBusType.HOOK_EXECUTION_RESPONSE,
     );
@@ -390,6 +398,7 @@ export async function firePermissionRequestHook(
   toolInput: Record<string, unknown>,
   permissionMode: string,
   permissionSuggestions?: PermissionSuggestion[],
+  signal?: AbortSignal,
 ): Promise<PermissionRequestHookResult> {
   if (!messageBus) {
     return { hasDecision: false };
@@ -409,6 +418,7 @@ export async function firePermissionRequestHook(
           permission_mode: permissionMode,
           permission_suggestions: permissionSuggestions,
         },
+        signal,
       },
       MessageBusType.HOOK_EXECUTION_RESPONSE,
     );

packages/core/src/hooks/hookEventHandler.test.ts

@@ -712,6 +712,7 @@ describe('HookEventHandler', () => {
         expect.any(Object), // input object
         expect.any(Function), // onHookStart callback
         expect.any(Function), // onHookEnd callback
+        undefined, // signal
       );
     });