wave-agent-sdk 0.19.5 → 0.19.7

package/dist/utils/worktreeUtils.d.ts

@@ -39,4 +39,3 @@ export declare function countWorktreeChanges(worktreePath: string, originalHeadC
     changedFiles: number;
     commits: number;
 } | null;
-//# sourceMappingURL=worktreeUtils.d.ts.map

package/dist/workflow/budgetTracker.d.ts

@@ -9,4 +9,3 @@ export declare class BudgetTracker {
     get total(): number | null;
     toBudgetInfo(): import("./types.js").BudgetInfo;
 }
-//# sourceMappingURL=budgetTracker.d.ts.map

package/dist/workflow/concurrencyLimiter.d.ts

@@ -11,4 +11,3 @@ export declare class ConcurrencyLimiter {
     get activeCount(): number;
     get pendingCount(): number;
 }
-//# sourceMappingURL=concurrencyLimiter.d.ts.map

package/dist/workflow/journal.d.ts

@@ -16,4 +16,3 @@ export declare class Journal {
     close(): Promise<void>;
     static load(filePath: string): Promise<Journal>;
 }
-//# sourceMappingURL=journal.d.ts.map

package/dist/workflow/progressReporter.d.ts

@@ -18,4 +18,3 @@ export declare class ProgressReporter {
     onEvent(listener: (event: WorkflowProgressEvent) => void): void;
     private emit;
 }
-//# sourceMappingURL=progressReporter.d.ts.map

package/dist/workflow/runState.d.ts

@@ -13,4 +13,3 @@ export declare class RunStateStore {
     /** List all persisted run IDs */
     listRuns(): Promise<string[]>;
 }
-//# sourceMappingURL=runState.d.ts.map

package/dist/workflow/scriptRuntime.d.ts

@@ -32,4 +32,3 @@ export declare function executeScript(script: string, apis: {
     meta: WorkflowMeta;
     result: unknown;
 }>;
-//# sourceMappingURL=scriptRuntime.d.ts.map

package/dist/workflow/structuredOutput.d.ts

@@ -24,4 +24,3 @@ export declare function extractStructuredResult(messages: Array<{
     }>;
 }>, schema: object): unknown | null;
 export { STRUCTURED_OUTPUT_TOOL_NAME };
-//# sourceMappingURL=structuredOutput.d.ts.map

package/dist/workflow/types.d.ts

@@ -78,4 +78,3 @@ export interface WorkflowProgressEvent {
     agentIndex?: number;
     timestamp: number;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/workflow/workflowApis.d.ts

@@ -41,4 +41,3 @@ export interface WorkflowApis {
 }
 export declare function createWorkflowApis(ctx: WorkflowApiContext): WorkflowApis;
 export {};
-//# sourceMappingURL=workflowApis.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.19.5",
+  "version": "0.19.7",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/src/agent.ts

@@ -10,7 +10,6 @@ import { BangManager } from "./managers/bangManager.js";
 import { CronManager } from "./managers/cronManager.js";
 import { GoalManager } from "./managers/goalManager.js";
 import { BackgroundTaskManager } from "./managers/backgroundTaskManager.js";
-import { NotificationQueue } from "./managers/notificationQueue.js";
 import { MessageQueue, type QueuedMessage } from "./managers/messageQueue.js";
 import { SlashCommandManager } from "./managers/slashCommandManager.js";
 import { PluginManager } from "./managers/pluginManager.js";
@@ -42,6 +41,7 @@ import { TaskManager } from "./services/taskManager.js";
 import { btw } from "./services/aiService.js";
 import { convertMessagesForAPI } from "./utils/convertMessagesForAPI.js";
 import { supportsVision } from "./utils/modelCapabilities.js";
+import type { WorktreeSession } from "./utils/worktreeSession.js";
 import { parseTaskNotificationXml } from "./utils/notificationXml.js";
 import { InitializationService } from "./services/initializationService.js";
 import { InteractionService } from "./services/interactionService.js";
@@ -76,9 +76,8 @@ export class Agent {
   private goalManager: GoalManager; // Add goal manager instance
   private hookManager: HookManager; // Add hooks manager instance
   private reversionManager: ReversionManager;
-  private notificationQueue: NotificationQueue; // Add notification queue instance
-  private messageQueue: MessageQueue; // Add message queue instance
-  private pendingNotificationPromises: Promise<void>[] = []; // Track pending notification processing
+  private messageQueue: MessageQueue; // Unified queue for messages, bang commands, and notifications
+  private dispatchPromise: Promise<void> | null = null; // Track current dispatch for teardown
   private memoryRuleManager: MemoryRuleManager; // Add memory rule manager instance
   private liveConfigManager: LiveConfigManager; // Add live configuration manager
   private taskManager: TaskManager;
@@ -206,25 +205,8 @@ export class Agent {
     this.bangManager = this.container.get("BangManager")!;
     this.cronManager = this.container.get("CronManager")!;
     this.goalManager = this.container.get("GoalManager")!;
-    this.notificationQueue = this.container.get("NotificationQueue")!;
     this.messageQueue = this.container.get("MessageQueue")!;
 
-    // Wire up notification queue to trigger AI when notifications arrive while idle
-    this.notificationQueue.onNotificationsEnqueued = () => {
-      // If the AI is NOT loading (idle), trigger a new AI cycle to process notifications
-      if (!this.aiManager.isLoading) {
-        const pendingPromise = this.processPendingNotifications().catch(
-          (error) => {
-            this.logger?.error(
-              "Failed to process pending notifications:",
-              error,
-            );
-          },
-        );
-        this.pendingNotificationPromises.push(pendingPromise);
-      }
-    };
-
     // Wire up CWD change callback from AIManager to sync Agent's workdir
     this.aiManager.setOnCwdChange((newCwd) => {
       this.workdir = newCwd;
@@ -232,18 +214,20 @@ export class Agent {
       this.options.callbacks?.onWorkdirChange?.(newCwd);
     });
 
-    // Wire up message queue to process when agent becomes idle
-    this.messageQueue.onMessageEnqueued = () => this.tryDequeue();
+    // Wire up message queue to process when agent becomes idle.
+    // Both user messages and background task notifications enqueue here,
+    // unified through a single dispatch path (tryDispatch).
+    this.messageQueue.onMessageEnqueued = () => this.tryDispatch();
 
     // Wire up AI loading changes to process queue when AI becomes idle
     this.aiManager.onLoadingChange = (loading: boolean) => {
-      if (!loading) this.tryDequeue();
+      if (!loading) this.tryDispatch();
     };
 
     // Wire up bang manager callback for command running changes
     this.bangManager.onCommandRunningChange = (running: boolean) => {
       this.options.callbacks?.onCommandRunningChange?.(running);
-      if (!running) this.tryDequeue();
+      if (!running) this.tryDispatch();
     };
 
     // Set initial permission mode if provided
@@ -298,6 +282,15 @@ export class Agent {
     this.options.callbacks?.onWorkdirChange?.(newCwd);
   }
 
+  /**
+   * Set this session's worktree session state (used by CLI -w startup to inject the
+   * session created before the agent existed). Delegates to AIManager so the state is
+   * stored in this agent's own DI container.
+   */
+  public setWorktreeSession(session: WorktreeSession | null): void {
+    this.aiManager.setWorktreeSession(session);
+  }
+
   /** Get project memory content */
   public get projectMemory(): string {
     const memoryService =
@@ -336,9 +329,11 @@ export class Agent {
     return this.bangManager?.isCommandRunning ?? false;
   }
 
-  /** Get queued messages */
+  /** Get queued user-facing messages (excludes background notifications) */
   public get queuedMessages(): QueuedMessage[] {
-    return this.messageQueue.getQueue();
+    return this.messageQueue
+      .getQueue()
+      .filter((m) => m.type !== "notification");
   }
 
   /** Get goal status string */
@@ -390,28 +385,52 @@ export class Agent {
   }
 
   /**
-   * Unified dequeue trigger — checks state machine before processing.
-   * Called from onMessageEnqueued, onLoadingChange(false), and
-   * onCommandRunningChange(false).
+   * Update a queued message's content by its ID (does not change queue order)
+   * @param id - The ID of the message to update
+   * @param patch - The fields to update
+   * @returns true if the message was updated, false if not found
+   */
+  public updateQueuedMessageById(
+    id: string,
+    patch: {
+      content?: string;
+      images?: Array<{ path: string; mimeType: string }>;
+      type?: "message" | "bang";
+    },
+  ): boolean {
+    const updated = this.messageQueue.updateById(id, patch);
+    if (updated) {
+      this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
+    }
+    return updated;
+  }
+
+  /**
+   * Unified dispatch trigger — checks state machine before processing.
+   * Handles user messages, bang commands, and background task notifications
+   * through a single serialized path. Called from onMessageEnqueued,
+   * onLoadingChange(false), and onCommandRunningChange(false).
    */
-  private tryDequeue(): void {
+  private tryDispatch(): void {
     if (this.messageQueue.state !== "idle") return;
     if (!this.messageQueue.hasPending()) return;
     if (this.aiManager.isLoading || this.isCommandRunning) return;
 
     this.messageQueue.transitionTo("dispatching");
-    this.processQueuedMessage()
+    this.dispatchPromise = this.processQueuedMessage()
       .catch((error) => {
         this.logger?.error("Failed to process queued message:", error);
       })
       .finally(() => {
         this.messageQueue.transitionTo("idle");
-        this.tryDequeue(); // Re-check after processing
+        this.dispatchPromise = null;
+        this.tryDispatch(); // Re-check after processing
       });
   }
 
   /**
-   * Process the next queued message when the agent becomes idle.
+   * Process the next queued item when the agent becomes idle.
+   * Handles three item types: user messages, bang commands, and notifications.
    */
   private async processQueuedMessage(): Promise<void> {
     const next = this.messageQueue.dequeue();
@@ -423,6 +442,25 @@ export class Agent {
     if (next.type === "bang") {
       await this.bangManager?.executeCommand(next.content);
       await this.messageManager.saveSession();
+    } else if (next.type === "notification") {
+      // Drain all pending notifications and batch them into a single AI turn
+      const allNotifications = [
+        next.content,
+        ...this.messageQueue.drainNotifications(),
+      ];
+      for (const xml of allNotifications) {
+        const block = parseTaskNotificationXml(xml);
+        if (block) {
+          this.messageManager.addNotificationMessage({
+            taskId: block.taskId,
+            taskType: block.taskType,
+            status: block.status,
+            summary: block.summary,
+            outputFile: block.outputFile,
+          });
+        }
+      }
+      await this.aiManager.sendAIMessage({ recursionDepth: 0 });
     } else {
       await this.sendMessage(next.content, next.images);
     }
@@ -650,31 +688,6 @@ export class Agent {
     this.aiManager.abortAIMessage();
   }
 
-  /**
-   * Process pending background task notifications by injecting them as user messages
-   * and triggering a new AI response cycle.
-   */
-  private async processPendingNotifications(): Promise<void> {
-    const notifications = this.notificationQueue.dequeueAll();
-    if (notifications.length === 0) return;
-
-    for (const notification of notifications) {
-      const block = parseTaskNotificationXml(notification);
-      if (block) {
-        this.messageManager.addNotificationMessage({
-          taskId: block.taskId,
-          taskType: block.taskType,
-          status: block.status,
-          summary: block.summary,
-          outputFile: block.outputFile,
-        });
-      }
-    }
-
-    // Trigger AI to process the notifications
-    await this.aiManager.sendAIMessage({ recursionDepth: 0 });
-  }
-
   /** Execute bash command (bang command) */
   public async bang(command: string): Promise<void> {
     // If the agent is busy, enqueue the bang command
@@ -835,8 +848,9 @@ export class Agent {
   /** Unified interrupt method, interrupts both AI messages and command execution */
   public abortMessage(): void {
     if (this.aiManager.isLoading || this.isCommandRunning) {
-      // Clear queue first to prevent processQueuedMessage from dequeuing
-      // when abortAIMessage triggers onLoadingChange(false)
+      // Clear user-facing queue items first to prevent processQueuedMessage
+      // from dequeuing when abortAIMessage triggers onLoadingChange(false).
+      // Notifications are preserved so background task results aren't lost.
       this.messageQueue.clear();
       this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
     }
@@ -926,15 +940,14 @@ export class Agent {
     }).catch(() => {});
     await shutdownTelemetry();
 
-    // Clear notification callback first to prevent any late triggers from
+    // Clear message queue callback first to prevent any late triggers from
     // starting async work during teardown
-    this.notificationQueue.onNotificationsEnqueued = undefined;
+    this.messageQueue.onMessageEnqueued = undefined;
 
-    // Await any pending notification processing to prevent race conditions
+    // Await any pending dispatch to prevent race conditions
     // with test teardown (e.g., V8 coverage stream cleanup)
-    if (this.pendingNotificationPromises.length > 0) {
-      await Promise.allSettled(this.pendingNotificationPromises);
-      this.pendingNotificationPromises = [];
+    if (this.dispatchPromise) {
+      await this.dispatchPromise.catch(() => {});
     }
 
     // Fire SessionEnd hooks (fire-and-forget, don't block shutdown)

package/src/managers/aiManager.ts

@@ -38,9 +38,10 @@ import {
   buildExitedPlanModeReminder,
 } from "../prompts/planModeReminders.js";
 import { Container } from "../utils/container.js";
+import type { WorktreeSession } from "../utils/worktreeSession.js";
 import { recoverTruncatedJson } from "../utils/stringUtils.js";
 import { ConfigurationService } from "../services/configurationService.js";
-import type { NotificationQueue } from "./notificationQueue.js";
+import type { MessageQueue } from "./messageQueue.js";
 
 import { logger } from "../utils/globalLogger.js";
 import {
@@ -114,6 +115,7 @@ export interface AIManagerOptions {
 
 export class AIManager {
   public isLoading: boolean = false;
+  private turnGeneration = 0; // Guards against concurrent sendAIMessage turns
   private abortController: AbortController | null = null;
   onLoadingChange?: (loading: boolean) => void;
   private toolAbortController: AbortController | null = null;
@@ -260,11 +262,31 @@ export class AIManager {
 
   /**
    * Update the working directory mid-session (e.g., when entering/exiting a worktree).
-   * Also updates process.chdir() so bash commands use the new directory.
+   * Only updates this session's DI container; it does NOT change the process-level
+   * process.cwd(), so concurrent sessions in the same stdio process are unaffected.
+   * Triggers `_onCwdChange` (wired by Agent to `onWorkdirChange`) so the host is
+   * notified of worktree switches. Unlike bash `cd`, this does NOT run CwdChanged
+   * hooks (worktree has its own WorktreeCreate/WorktreeRemove hooks).
    */
   public setWorkdir(newWorkdir: string): void {
     this.container.register("Workdir", newWorkdir);
-    process.chdir(newWorkdir);
+    this._onCwdChange?.(newWorkdir);
+  }
+
+  /**
+   * Get this session's worktree session state (null if not in a worktree).
+   */
+  public getWorktreeSession(): WorktreeSession | null {
+    return (
+      this.container.get<WorktreeSession | null>("WorktreeSession") ?? null
+    );
+  }
+
+  /**
+   * Set this session's worktree session state.
+   */
+  public setWorktreeSession(session: WorktreeSession | null): void {
+    this.container.register("WorktreeSession", session);
   }
 
   public setOnCwdChange(callback: (newCwd: string) => void): void {
@@ -376,6 +398,10 @@ export class AIManager {
   }
 
   public abortAIMessage(): void {
+    // Bump generation so the in-flight turn's end-of-turn setIsLoading(false)
+    // is skipped (generation mismatch), preventing it from racing with this abort.
+    this.turnGeneration++;
+
     // Interrupt AI service
     if (this.abortController) {
       try {
@@ -797,6 +823,15 @@ export class AIManager {
     const { recursionDepth = 0, model, allowedRules, maxTokens } = options;
     let turnOffset = recursionDepth;
 
+    // Reserve this turn synchronously before any async work. Bumping the
+    // generation invalidates any in-flight turn's end-of-turn cleanup, and
+    // recording myGeneration lets us skip cleanup if a newer turn (or abort)
+    // has superseded us. setIsLoading(true) here also closes the "idle but
+    // previous turn not finished" race window by marking us busy immediately.
+    this.turnGeneration++;
+    const myGeneration = this.turnGeneration;
+    this.setIsLoading(true);
+
     outer: while (true) {
       let shouldRestart = false;
 
@@ -818,9 +853,8 @@ export class AIManager {
         }).catch(() => {}); // Non-blocking
       }
 
-      // Set loading state early for the initial call, before any async work
+      // Apply allowed rules for the initial call
       if (turnOffset === 0) {
-        this.setIsLoading(true);
         if (allowedRules && allowedRules.length > 0) {
           this.permissionManager?.addTemporaryRules(allowedRules);
         }
@@ -942,6 +976,7 @@ export class AIManager {
                 originalWorkdir: this.getOriginalWorkdir(),
                 language: this.getLanguage(),
                 isSubagent: !!this.subagentType,
+                worktreeSession: this.getWorktreeSession(),
                 autoMemory: autoMemoryOptions,
               },
             ), // Pass custom system prompt
@@ -1326,6 +1361,16 @@ export class AIManager {
             message: error instanceof Error ? error.message : String(error),
           }).catch(() => {}); // Non-blocking
 
+          // Finalize any streaming text/reasoning blocks so the UI stops ticking
+          // its in-progress timer (e.g. when the request is aborted mid-thought).
+          this.messageManager.finalizeStreamingBlocks();
+
+          // Finalize any tool blocks stuck in start/streaming/running so the UI
+          // stops showing the yellow "running" spinner (e.g. abort mid-tool-stream).
+          this.messageManager.finalizeAbortedToolBlocks(
+            error instanceof Error ? error.message : undefined,
+          );
+
           this.messageManager.addErrorBlock(
             error instanceof Error ? error.message : "Unknown error occurred",
           );
@@ -1343,8 +1388,6 @@ export class AIManager {
 
         // Save session in each iteration to ensure message persistence
         await this.messageManager.saveSession();
-        // Set loading to false first
-        this.setIsLoading(false);
 
         // Clear temporary rules
         this.permissionManager?.clearTemporaryRules();
@@ -1443,11 +1486,11 @@ export class AIManager {
 
         // Inject pending notifications from background tasks (after Stop hooks,
         // aligned with Claude Code which fires Stop hooks unconditionally)
-        const notificationQueue = this.container.has("NotificationQueue")
-          ? this.container.get<NotificationQueue>("NotificationQueue")
+        const messageQueue = this.container.has("MessageQueue")
+          ? this.container.get<MessageQueue>("MessageQueue")
           : undefined;
-        if (notificationQueue && notificationQueue.hasPending()) {
-          const notifications = notificationQueue.dequeueAll();
+        if (messageQueue && messageQueue.hasNotifications()) {
+          const notifications = messageQueue.drainNotifications();
           for (const notification of notifications) {
             const block = parseTaskNotificationXml(notification);
             if (block) {
@@ -1466,7 +1509,16 @@ export class AIManager {
         }
       }
 
-      if (!shouldRestart) break outer;
+      if (!shouldRestart) {
+        // Release loading state only after ALL cleanup is done (session save,
+        // Stop hooks, notification injection). Generation check ensures a
+        // superseded (aborted or newer) turn doesn't clobber the current
+        // loading state.
+        if (myGeneration === this.turnGeneration) {
+          this.setIsLoading(false);
+        }
+        break outer;
+      }
     }
   }
 
@@ -1502,6 +1554,20 @@ export class AIManager {
             }))
           : undefined;
 
+      // Extract text content from the last assistant message so hooks can
+      // inspect the final response without reading the transcript file.
+      const allMessages = this.messageManager.getMessages();
+      const lastAssistant = [...allMessages]
+        .reverse()
+        .find((m) => m.role === "assistant");
+      const lastAssistantText = lastAssistant
+        ? lastAssistant.blocks
+            .filter((b) => b.type === "text")
+            .map((b) => b.content)
+            .join("\n")
+            .trim() || undefined
+        : undefined;
+
       const context: ExtendedHookExecutionContext = {
         event: hookName,
         projectDir: this.getWorkdir(),
@@ -1512,6 +1578,7 @@ export class AIManager {
         subagentType: this.subagentType, // Include subagent type in hook context
         backgroundTasks, // Stop-only: running background tasks snapshot
         sessionCrons, // Stop-only: session cron jobs snapshot
+        lastAssistantMessage: lastAssistantText, // Stop/SubagentStop: last assistant message text
         // Stop hooks don't need toolName, toolInput, toolResponse, or userPrompt
         env: Object.fromEntries(
           Object.entries(process.env).filter((e) => e[1] !== undefined),

package/src/managers/backgroundTaskManager.ts

@@ -6,7 +6,8 @@ import { BackgroundTask, BackgroundShell } from "../types/processes.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import { logger } from "../utils/globalLogger.js";
 import { Container } from "../utils/container.js";
-import { NotificationQueue } from "./notificationQueue.js";
+import { MessageQueue } from "./messageQueue.js";
+import { resolveShellPath } from "../utils/shellResolver.js";
 
 export interface BackgroundTaskManagerCallbacks {
   onBackgroundTasksChange?: (tasks: BackgroundTask[]) => void;
@@ -31,10 +32,6 @@ export class BackgroundTaskManager {
     this.workdir = options.workdir;
   }
 
-  private get notificationQueue(): NotificationQueue {
-    return this.container.get<NotificationQueue>("NotificationQueue")!;
-  }
-
   /**
    * Fire the onBackgroundTasksChange callback so UI consumers refresh.
    * Public so other managers (e.g. WorkflowManager) can trigger a refresh
@@ -64,15 +61,16 @@ export class BackgroundTaskManager {
   public startShell(
     command: string,
     timeout?: number,
+    cwd?: string,
   ): { id: string; child: ChildProcess; detach: () => void } {
     const id = this.generateId();
     const startTime = Date.now();
 
     const child = spawn(command, {
-      shell: true,
+      shell: resolveShellPath() ?? true,
       stdio: "pipe",
       detached: true,
-      cwd: this.workdir,
+      cwd: cwd ?? this.workdir,
       env: {
         ...process.env,
       },
@@ -176,13 +174,13 @@ export class BackgroundTaskManager {
 
       // Skip notification if task was manually killed (user/agent-initiated stop)
       if (!wasKilled) {
-        const notificationQueue = this.container.has("NotificationQueue")
-          ? this.container.get<NotificationQueue>("NotificationQueue")
+        const messageQueue = this.container.has("MessageQueue")
+          ? this.container.get<MessageQueue>("MessageQueue")
           : undefined;
-        if (notificationQueue) {
+        if (messageQueue) {
           const statusStr = shell.status;
           const summary = `Command "${command}" ${statusStr} with exit code ${code ?? 0}`;
-          notificationQueue.enqueue(
+          messageQueue.enqueueNotification(
             `<task-notification>\n<task-id>${id}</task-id>\n<task-type>shell</task-type>\n<output-file>${logPath}</output-file>\n<status>${statusStr}</status>\n<summary>${summary}</summary>\n</task-notification>`,
           );
         }
@@ -206,12 +204,12 @@ export class BackgroundTaskManager {
       this.notifyTasksChange();
 
       // Enqueue error notification
-      const notificationQueue = this.container.has("NotificationQueue")
-        ? this.container.get<NotificationQueue>("NotificationQueue")
+      const messageQueue = this.container.has("MessageQueue")
+        ? this.container.get<MessageQueue>("MessageQueue")
         : undefined;
-      if (notificationQueue) {
+      if (messageQueue) {
         const summary = `Command "${command}" failed with error: ${stripAnsiColors(error.message)}`;
-        notificationQueue.enqueue(
+        messageQueue.enqueueNotification(
           `<task-notification>\n<task-id>${id}</task-id>\n<task-type>shell</task-type>\n<output-file>${logPath}</output-file>\n<status>failed</status>\n<summary>${summary}</summary>\n</task-notification>`,
         );
       }
@@ -335,13 +333,13 @@ export class BackgroundTaskManager {
 
       // Skip notification if task was manually killed (user/agent-initiated stop)
       if (!wasKilled) {
-        const notificationQueue = this.container.has("NotificationQueue")
-          ? this.container.get<NotificationQueue>("NotificationQueue")
+        const messageQueue = this.container.has("MessageQueue")
+          ? this.container.get<MessageQueue>("MessageQueue")
           : undefined;
-        if (notificationQueue) {
+        if (messageQueue) {
           const statusStr = shell.status;
           const summary = `Command "${command}" ${statusStr} with exit code ${code ?? 0}`;
-          notificationQueue.enqueue(
+          messageQueue.enqueueNotification(
             `<task-notification>\n<task-id>${id}</task-id>\n<task-type>shell</task-type>\n<output-file>${logPath}</output-file>\n<status>${statusStr}</status>\n<summary>${summary}</summary>\n</task-notification>`,
           );
         }
@@ -362,12 +360,12 @@ export class BackgroundTaskManager {
       this.notifyTasksChange();
 
       // Enqueue error notification
-      const notificationQueue = this.container.has("NotificationQueue")
-        ? this.container.get<NotificationQueue>("NotificationQueue")
+      const messageQueue = this.container.has("MessageQueue")
+        ? this.container.get<MessageQueue>("MessageQueue")
         : undefined;
-      if (notificationQueue) {
+      if (messageQueue) {
         const summary = `Command "${command}" failed with error: ${stripAnsiColors(error.message)}`;
-        notificationQueue.enqueue(
+        messageQueue.enqueueNotification(
           `<task-notification>\n<task-id>${id}</task-id>\n<task-type>shell</task-type>\n<output-file>${logPath}</output-file>\n<status>failed</status>\n<summary>${summary}</summary>\n</task-notification>`,
         );
       }

package/src/managers/bangManager.ts

@@ -1,6 +1,7 @@
 import { spawn, type ChildProcess } from "child_process";
 import type { MessageManager } from "./messageManager.js";
 import { Container } from "../utils/container.js";
+import { resolveShellPath } from "../utils/shellResolver.js";
 
 export interface BangManagerOptions {
   workdir: string;
@@ -45,7 +46,7 @@ export class BangManager {
 
     return new Promise<number>((resolve) => {
       const child = spawn(command, {
-        shell: true,
+        shell: resolveShellPath() ?? true,
         stdio: "pipe",
         cwd: this.workdir,
         env: {