wave-agent-sdk 0.19.5 → 0.19.6

package/src/managers/aiManager.ts

@@ -38,6 +38,7 @@ 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";
@@ -260,11 +261,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 {
@@ -942,6 +963,7 @@ export class AIManager {
                 originalWorkdir: this.getOriginalWorkdir(),
                 language: this.getLanguage(),
                 isSubagent: !!this.subagentType,
+                worktreeSession: this.getWorktreeSession(),
                 autoMemory: autoMemoryOptions,
               },
             ), // Pass custom system prompt
@@ -1326,6 +1348,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",
           );
@@ -1502,6 +1534,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 +1558,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

@@ -7,6 +7,7 @@ import { stripAnsiColors } from "../utils/stringUtils.js";
 import { logger } from "../utils/globalLogger.js";
 import { Container } from "../utils/container.js";
 import { NotificationQueue } from "./notificationQueue.js";
+import { resolveShellPath } from "../utils/shellResolver.js";
 
 export interface BackgroundTaskManagerCallbacks {
   onBackgroundTasksChange?: (tasks: BackgroundTask[]) => void;
@@ -64,15 +65,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,
       },

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: {

package/src/managers/messageManager.ts

@@ -16,7 +16,7 @@ import {
   type AddNotificationMessageParams,
   generateMessageId,
 } from "../utils/messageOperations.js";
-import type { Message, Usage } from "../types/index.js";
+import type { Message, Usage, ToolBlock } from "../types/index.js";
 import { getLastApiRounds } from "../utils/groupMessagesByApiRound.js";
 import { join, isAbsolute, relative } from "path";
 import {
@@ -718,12 +718,23 @@ export class MessageManager {
       type: "text" | "reasoning";
       content: string;
       stage?: string;
+      startTime?: number;
     };
-    lastMessage.blocks[index] = {
-      type: block.type,
-      content: block.content,
-      stage: "end" as const,
-    };
+    if (block.type === "reasoning") {
+      lastMessage.blocks[index] = {
+        type: "reasoning",
+        content: block.content,
+        stage: "end" as const,
+        startTime: block.startTime,
+        endTime: Date.now(),
+      };
+    } else {
+      lastMessage.blocks[index] = {
+        type: block.type,
+        content: block.content,
+        stage: "end" as const,
+      };
+    }
 
     // Fire incremental callback to signal finalization
     const callbackParams = {
@@ -832,10 +843,16 @@ export class MessageManager {
 
     if (reasoningBlockIndex >= 0) {
       // Update existing reasoning block
+      const existingStartTime = (
+        lastMessage.blocks[reasoningBlockIndex] as {
+          startTime?: number;
+        }
+      ).startTime;
       lastMessage.blocks[reasoningBlockIndex] = {
         type: "reasoning",
         content: newAccumulatedReasoning,
         stage: "streaming",
+        startTime: existingStartTime,
       };
     } else {
       // Add new reasoning block if none exists
@@ -843,6 +860,7 @@ export class MessageManager {
         type: "reasoning",
         content: newAccumulatedReasoning,
         stage: "streaming",
+        startTime: Date.now(),
       });
     }
 
@@ -878,6 +896,54 @@ export class MessageManager {
     }
   }
 
+  /**
+   * Finalize any tool blocks still in a non-terminal stage (start/streaming/running)
+   * by marking them as ended with an error. Called when the AI call is aborted or
+   * fails mid-tool-stream so the UI stops showing the "running" spinner.
+   * Fires onToolBlockUpdated for each finalized tool block.
+   */
+  public finalizeAbortedToolBlocks(error?: string): void {
+    if (this.messages.length === 0) return;
+    const lastMessage = this.messages[this.messages.length - 1];
+    if (lastMessage.role !== "assistant") return;
+
+    const errorMessage = error ?? "Tool execution was aborted";
+    let finalized = false;
+
+    for (let i = 0; i < lastMessage.blocks.length; i++) {
+      const block = lastMessage.blocks[i] as ToolBlock;
+      if (block.type !== "tool" || block.stage === "end") continue;
+
+      const timestamp = Date.now();
+      lastMessage.blocks[i] = {
+        ...block,
+        stage: "end",
+        success: false,
+        error: errorMessage,
+        timestamp,
+      };
+      finalized = true;
+
+      this.callbacks.onToolBlockUpdated?.({
+        id: block.id ?? "",
+        messageId: lastMessage.id ?? "",
+        name: block.name,
+        parameters: block.parameters,
+        parametersChunk: block.parametersChunk,
+        compactParams: block.compactParams,
+        stage: "end",
+        success: false,
+        error: errorMessage,
+        isManuallyBackgrounded: block.isManuallyBackgrounded,
+        timestamp,
+      });
+    }
+
+    if (finalized) {
+      this.setMessages([...this.messages]);
+    }
+  }
+
   /**
    * Remove the last user message from the conversation
    * Used for hook error handling when the user prompt needs to be erased

package/src/managers/messageQueue.ts

@@ -74,6 +74,23 @@ export class MessageQueue {
     return true;
   }
 
+  updateById(
+    id: string,
+    patch: {
+      content?: string;
+      images?: Array<{ path: string; mimeType: string }>;
+      type?: "message" | "bang";
+    },
+  ): boolean {
+    const m = this.queue.find((x) => x.id === id);
+    if (!m) return false;
+    if (patch.content !== undefined) m.content = patch.content;
+    if (patch.images !== undefined) m.images = patch.images;
+    if (patch.type !== undefined) m.type = patch.type;
+    this.onMessageEnqueued?.();
+    return true;
+  }
+
   popLastEditable(): QueuedMessage | null {
     for (let i = this.queue.length - 1; i >= 0; i--) {
       if (this.queue[i].editable !== false) {

package/src/managers/permissionManager.ts

@@ -35,7 +35,7 @@ import {
 } from "../constants/tools.js";
 import { Container } from "../utils/container.js";
 import { ConfigurationService } from "../services/configurationService.js";
-import { getCurrentWorktreeSession } from "../utils/worktreeSession.js";
+import type { WorktreeSession } from "../utils/worktreeSession.js";
 
 const SAFE_COMMANDS = [
   "cd",
@@ -452,8 +452,11 @@ export class PermissionManager {
     }
 
     // 1.0 Check worktree safety for Write and Edit tools
-    // Support both CLI -w sessions (container-registered) and EnterWorktree mid-session (module-level)
-    const worktreeSession = getCurrentWorktreeSession();
+    // Support both CLI -w sessions (container-registered) and EnterWorktree mid-session
+    // (per-agent WorktreeSession stored in this session's container)
+    const worktreeSession = this.container.get<WorktreeSession | null>(
+      "WorktreeSession",
+    );
     const effectiveWorktreeName =
       this.worktreeName || worktreeSession?.worktreeName;
     const effectiveWorkdir = this.workdir || worktreeSession?.worktreePath;

package/src/managers/subagentManager.ts

@@ -7,7 +7,13 @@ import type { Message, Usage } from "../types/index.js";
 import { AIManager } from "./aiManager.js";
 import { MessageManager } from "./messageManager.js";
 import { ToolManager } from "./toolManager.js";
-import { AGENT_TOOL_NAME } from "../constants/tools.js";
+import {
+  AGENT_TOOL_NAME,
+  TASK_CREATE_TOOL_NAME,
+  TASK_GET_TOOL_NAME,
+  TASK_LIST_TOOL_NAME,
+  TASK_UPDATE_TOOL_NAME,
+} from "../constants/tools.js";
 import {
   addConsolidatedAbortListener,
   createAbortPromise,
@@ -321,6 +327,12 @@ export class SubagentManager {
       instanceDeniedRules: [
         ...(parentPermissionManager?.getInstanceDeniedRules?.() || []),
         AGENT_TOOL_NAME, // Always deny Agent tool in subagents to prevent recursion
+        // Deny Task tools in subagents — they share the parent's TaskManager
+        // and could mutate the main agent's task list
+        TASK_CREATE_TOOL_NAME,
+        TASK_GET_TOOL_NAME,
+        TASK_UPDATE_TOOL_NAME,
+        TASK_LIST_TOOL_NAME,
       ],
       additionalDirectories:
         parentPermissionManager?.getAdditionalDirectories(),

package/src/prompts/index.ts

@@ -1,7 +1,7 @@
 import * as os from "node:os";
 import { ToolPlugin } from "../tools/types.js";
 import { isGitRepository } from "../utils/gitUtils.js";
-import { getCurrentWorktreeSession } from "../utils/worktreeSession.js";
+import type { WorktreeSession } from "../utils/worktreeSession.js";
 import { buildAutoMemoryPrompt } from "./autoMemory.js";
 import {
   EXPLORE_SUBAGENT_TYPE,
@@ -252,6 +252,7 @@ export function buildSystemPrompt(
     originalWorkdir?: string;
     language?: string;
     isSubagent?: boolean;
+    worktreeSession?: WorktreeSession | null;
     autoMemory?: {
       directory: string;
       content: string;
@@ -292,7 +293,7 @@ export function buildSystemPrompt(
         ? "bash"
         : shell;
 
-    const worktreeSession = getCurrentWorktreeSession();
+    const worktreeSession = options.worktreeSession;
 
     dynamicText += `
 
@@ -326,6 +327,7 @@ export function enhanceSystemPromptWithEnvDetails(
   existingSystemPrompt: string,
   workdir: string,
   originalWorkdir?: string,
+  worktreeSession?: WorktreeSession | null,
 ): string {
   const isGitRepo = isGitRepository(workdir);
   const platform = os.platform();
@@ -338,8 +340,6 @@ export function enhanceSystemPromptWithEnvDetails(
       ? "bash"
       : shell;
 
-  const worktreeSession = getCurrentWorktreeSession();
-
   const notes = `Notes:
 - Agent threads always have their cwd reset between bash calls, as a result please only use absolute file paths.${worktreeSession ? `\n- You are in a git worktree at ${worktreeSession.worktreePath} (branch: ${worktreeSession.worktreeBranch}). Absolute paths from prior context may refer to the original repo at ${worktreeSession.originalCwd}; translate them to your worktree. Do NOT edit files outside this worktree.` : ""}
 - In your final response, share file paths (always absolute, never relative) that are relevant to the task. Include code snippets only when the exact text is load-bearing (e.g., a bug you found, a function signature the caller asked for) — do not recap code you merely read.

package/src/services/hook.ts

@@ -120,6 +120,15 @@ async function buildHookJsonInput(
     jsonInput.session_crons = context.sessionCrons ?? [];
   }
 
+  // Add last_assistant_message for Stop and SubagentStop events.
+  // Omitted when undefined (no text content in last assistant message).
+  if (
+    (context.event === "Stop" || context.event === "SubagentStop") &&
+    context.lastAssistantMessage !== undefined
+  ) {
+    jsonInput.last_assistant_message = context.lastAssistantMessage;
+  }
+
   return jsonInput;
 }
 

package/src/tools/bashTool.ts

@@ -173,14 +173,16 @@ The working directory persists between commands. Try to maintain your current wo
       };
     }
 
-    // Resolve shell path: on Windows, use Git Bash; on other platforms, use default
+    // Resolve shell path: on Windows, use Git Bash; on macOS/Linux, use bash or zsh
     const shellPath = resolveShellPath();
-    if (process.platform === "win32" && !shellPath) {
+    if (!shellPath) {
       return {
         success: false,
         content: "",
         error:
-          "Git Bash not found. Please install Git for Windows or set GIT_BASH_PATH environment variable.",
+          process.platform === "win32"
+            ? "Git Bash not found. Please install Git for Windows or set WAVE_GIT_BASH_PATH environment variable."
+            : "No suitable shell found. Please ensure bash or zsh is installed, or set WAVE_SHELL environment variable.",
       };
     }
 
@@ -242,7 +244,11 @@ The working directory persists between commands. Try to maintain your current wo
         };
       }
 
-      const { id: taskId } = backgroundTaskManager.startShell(command);
+      const { id: taskId } = backgroundTaskManager.startShell(
+        command,
+        undefined,
+        context.workdir,
+      );
       const task = backgroundTaskManager.getTask(taskId);
       const outputPath = task?.outputPath;
       const backgroundMsg = [
@@ -273,7 +279,7 @@ The working directory persists between commands. Try to maintain your current wo
       );
 
       const child: ChildProcess = spawn(wrappedCommand, {
-        shell: shellPath || true,
+        shell: shellPath,
         stdio: "pipe",
         detached: true,
         cwd: context.workdir,

package/src/tools/enterWorktreeTool.ts

@@ -4,11 +4,7 @@
  */
 
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import {
-  getCurrentWorktreeSession,
-  setCurrentWorktreeSession,
-  type WorktreeSession,
-} from "../utils/worktreeSession.js";
+import { type WorktreeSession } from "../utils/worktreeSession.js";
 import {
   createWorktree,
   validateWorktreeName,
@@ -72,7 +68,7 @@ export const enterWorktreeTool: ToolPlugin = {
     context: ToolContext,
   ): Promise<ToolResult> {
     // Validate not already in a worktree created by this session
-    if (getCurrentWorktreeSession()) {
+    if (context.aiManager?.getWorktreeSession()) {
       return {
         success: false,
         content:
@@ -119,19 +115,13 @@ export const enterWorktreeTool: ToolPlugin = {
       originalHeadCommit: worktreeInfo.originalHeadCommit,
     };
 
-    // Set module-level session state
-    setCurrentWorktreeSession(session);
-
-    // Update CWD via AIManager
+    // Set per-session worktree state and update CWD via AIManager
     const aiManager = context.aiManager;
     if (aiManager) {
+      aiManager.setWorktreeSession(session);
       aiManager.setWorkdir(worktreeInfo.path);
     }
 
-    // Also update the container's Workdir entry
-    // (Container is not directly accessible from ToolContext, but AIManager.setWorkdir
-    // handles both its internal field and process.chdir)
-
     // Trigger WorktreeCreate hook if worktree is new
     let hookTriggered = false;
     if (session.isNew && context.hookManager) {

package/src/tools/exitWorktreeTool.ts

@@ -4,10 +4,6 @@
  */
 
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import {
-  getCurrentWorktreeSession,
-  setCurrentWorktreeSession,
-} from "../utils/worktreeSession.js";
 import {
   removeWorktree,
   countWorktreeChanges,
@@ -89,8 +85,8 @@ export const exitWorktreeTool: ToolPlugin = {
       };
     }
 
-    // Validate: must be in an active worktree session
-    const session = getCurrentWorktreeSession();
+    // Validate: must be in an active worktree session (for this session)
+    const session = context.aiManager?.getWorktreeSession();
     if (!session) {
       return {
         success: false,
@@ -139,11 +135,9 @@ export const exitWorktreeTool: ToolPlugin = {
 
     if (action === "keep") {
       // Clear session state
-      setCurrentWorktreeSession(null);
-
-      // Restore CWD
       const aiManager = context.aiManager;
       if (aiManager) {
+        aiManager.setWorktreeSession(null);
         aiManager.setWorkdir(originalCwd);
       }
 
@@ -170,12 +164,10 @@ export const exitWorktreeTool: ToolPlugin = {
 
     removeWorktree(worktreeInfo);
 
-    // Clear session state
-    setCurrentWorktreeSession(null);
-
-    // Restore CWD
+    // Clear session state and restore CWD
     const aiManager = context.aiManager;
     if (aiManager) {
+      aiManager.setWorktreeSession(null);
       aiManager.setWorkdir(originalCwd);
     }
 

package/src/types/hooks.ts

@@ -198,6 +198,7 @@ export interface HookJsonInput {
   compact_summary?: string; // Present for PostCompact events
   background_tasks?: BackgroundTaskInfo[]; // Present for Stop events: running background tasks snapshot
   session_crons?: SessionCronInfo[]; // Present for Stop events: session-scoped cron jobs snapshot
+  last_assistant_message?: string; // Present for Stop and SubagentStop events: text content of the last assistant message
 }
 
 // Describes one in-flight background task in the Stop hook input.
@@ -245,6 +246,7 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
   compactSummary?: string; // Summary text for PostCompact
   backgroundTasks?: BackgroundTaskInfo[]; // Running background tasks snapshot (Stop only)
   sessionCrons?: SessionCronInfo[]; // Session-scoped cron jobs snapshot (Stop only)
+  lastAssistantMessage?: string; // Text content of last assistant message (Stop and SubagentStop only)
 }
 
 // Environment variables injected into hook processes

package/src/types/messaging.ts

@@ -95,6 +95,8 @@ export interface ReasoningBlock {
   type: "reasoning";
   content: string;
   stage?: "streaming" | "end";
+  startTime?: number; // Unix ms, set when the first reasoning content arrives
+  endTime?: number; // Unix ms, set when stage transitions to "end"
 }
 
 export interface FileHistoryBlock {

package/src/utils/containerSetup.ts

@@ -88,6 +88,10 @@ export function setupAgentContainer(
     container.register("MainRepoRoot", getGitMainRepoRoot(workdir));
   }
 
+  // Per-agent worktree session state (EnterWorktree/ExitWorktree). Stored in the
+  // container so it is isolated per session, not shared process-wide.
+  container.register("WorktreeSession", null);
+
   const notificationQueue = new NotificationQueue();
   container.register("NotificationQueue", notificationQueue);