wave-agent-sdk 0.19.5 → 0.19.7

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

@@ -2,7 +2,7 @@ export type QueueState = "idle" | "dispatching" | "running";
 
 export interface QueuedMessage {
   id?: string;
-  type?: "message" | "bang";
+  type?: "message" | "bang" | "notification";
   content: string;
   images?: Array<{ path: string; mimeType: string }>;
   longTextMap?: Record<string, string>;
@@ -44,8 +44,12 @@ export class MessageQueue {
     return this.queue.shift() ?? null;
   }
 
+  /**
+   * Clear user-facing items (messages, bang commands) but preserve pending
+   * notifications so background task results are not lost on abort.
+   */
   clear(): void {
-    this.queue = [];
+    this.queue = this.queue.filter((m) => m.type === "notification");
     this._state = "idle";
   }
 
@@ -74,6 +78,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) {
@@ -96,4 +117,41 @@ export class MessageQueue {
     this.queue = remaining;
     return editable;
   }
+
+  /**
+   * Enqueue a background task notification (XML string). Notifications are
+   * not user-editable and not surfaced in the queued-messages UI.
+   */
+  enqueueNotification(xml: string): void {
+    this.queue.push({
+      id: `mq-${this.nextId++}`,
+      type: "notification",
+      content: xml,
+      editable: false,
+    });
+    this.onMessageEnqueued?.();
+  }
+
+  /** Whether any notification items are pending. */
+  hasNotifications(): boolean {
+    return this.queue.some((m) => m.type === "notification");
+  }
+
+  /**
+   * Drain all notification items, returning their XML content. Non-notification
+   * items (messages, bang commands) are preserved in the queue.
+   */
+  drainNotifications(): string[] {
+    const notifications: string[] = [];
+    const remaining: QueuedMessage[] = [];
+    for (const msg of this.queue) {
+      if (msg.type === "notification") {
+        notifications.push(msg.content);
+      } else {
+        remaining.push(msg);
+      }
+    }
+    this.queue = remaining;
+    return notifications;
+  }
 }

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,13 +7,19 @@ 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,
 } from "../utils/abortUtils.js";
 import { BackgroundTaskManager } from "./backgroundTaskManager.js";
-import { NotificationQueue } from "./notificationQueue.js";
+import { MessageQueue } from "./messageQueue.js";
 import { logger } from "../utils/globalLogger.js";
 import {
   UserMessageParams,
@@ -75,7 +81,6 @@ export interface SubagentInstance {
   toolManager: ToolManager;
   permissionManager: PermissionManager;
   backgroundTaskManager: BackgroundTaskManager;
-  notificationQueue: NotificationQueue;
   status: "initializing" | "active" | "completed" | "error" | "aborted";
   messages: Message[];
   usedTools: {
@@ -321,6 +326,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(),
@@ -381,10 +392,6 @@ export class SubagentManager {
     });
     subagentContainer.register("AIManager", aiManager);
 
-    // Create isolated NotificationQueue for the subagent/forked agent
-    const subagentNotificationQueue = new NotificationQueue();
-    subagentContainer.register("NotificationQueue", subagentNotificationQueue);
-
     // Create isolated BackgroundTaskManager for the subagent/forked agent
     const subagentBackgroundTaskManager = new BackgroundTaskManager(
       subagentContainer,
@@ -405,7 +412,6 @@ export class SubagentManager {
       toolManager,
       permissionManager: subagentPermissionManager,
       backgroundTaskManager: subagentBackgroundTaskManager,
-      notificationQueue: subagentNotificationQueue,
       status: "initializing",
       messages: [],
       usedTools: [], // Initialize usedTools
@@ -645,12 +651,12 @@ export class SubagentManager {
           }
           // Skip notification if task was already stopped (e.g. by main agent shutdown)
           if (!wasAlreadyKilled) {
-            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 = `Agent task "${instance.description}" completed`;
-              notificationQueue.enqueue(
+              messageQueue.enqueueNotification(
                 `<task-notification>\n<task-id>${instance.backgroundTaskId}</task-id>\n<task-type>agent</task-type>\n<status>completed</status>\n<summary>${summary}</summary>\n</task-notification>`,
               );
             }
@@ -682,14 +688,14 @@ export class SubagentManager {
           }
           // Skip notification if task was already stopped (e.g. by main agent shutdown)
           if (!wasAlreadyKilled) {
-            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 errorMsg =
                 error instanceof Error ? error.message : String(error);
               const summary = `Agent task "${instance.description}" failed: ${errorMsg}`;
-              notificationQueue.enqueue(
+              messageQueue.enqueueNotification(
                 `<task-notification>\n<task-id>${instance.backgroundTaskId}</task-id>\n<task-type>agent</task-type>\n<status>failed</status>\n<summary>${summary}</summary>\n</task-notification>`,
               );
             }

package/src/managers/workflowManager.ts

@@ -4,7 +4,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { Container } from "../utils/container.js";
 import { BackgroundTaskManager } from "./backgroundTaskManager.js";
-import { NotificationQueue } from "./notificationQueue.js";
+import { MessageQueue } from "./messageQueue.js";
 import { SubagentManager } from "./subagentManager.js";
 import { taskNotificationToXml } from "../utils/notificationXml.js";
 import { ConcurrencyLimiter } from "../workflow/concurrencyLimiter.js";
@@ -49,8 +49,8 @@ export class WorkflowManager {
     return this.container.get<BackgroundTaskManager>("BackgroundTaskManager")!;
   }
 
-  private get notificationQueue(): NotificationQueue {
-    return this.container.get<NotificationQueue>("NotificationQueue")!;
+  private get messageQueue(): MessageQueue {
+    return this.container.get<MessageQueue>("MessageQueue")!;
   }
 
   private get subagentManager(): SubagentManager {
@@ -295,7 +295,7 @@ export class WorkflowManager {
 
         // Enqueue completion notification
         const journalPath = journal.filePath;
-        this.notificationQueue.enqueue(
+        this.messageQueue.enqueueNotification(
           taskNotificationToXml({
             type: "task_notification",
             taskId: runId,
@@ -337,7 +337,7 @@ export class WorkflowManager {
           task.endTime = Date.now();
         }
 
-        this.notificationQueue.enqueue(
+        this.messageQueue.enqueueNotification(
           taskNotificationToXml({
             type: "task_notification",
             taskId: runId,

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/services/interactionService.ts

@@ -71,6 +71,13 @@ export class InteractionService {
         })),
       });
 
+      // Reserve loading state synchronously before any async work (hooks).
+      // This closes the race window where a concurrent notification/message
+      // could see isLoading=false during the await below and start a second
+      // sendAIMessage. sendAIMessage's generation guard is the backstop, but
+      // reserving here prevents the race at its source.
+      aiManager.setIsLoading(true);
+
       // Execute UserPromptSubmit hooks after adding the user message
       if (hookManager) {
         try {
@@ -104,6 +111,8 @@ export class InteractionService {
               "UserPromptSubmit hook blocked prompt processing with error:",
               processResult.errorMessage,
             );
+            // Release the loading state we reserved above
+            aiManager.setIsLoading(false);
             return; // Don't send to AI
           }
         } catch (error) {
@@ -116,6 +125,8 @@ export class InteractionService {
       await aiManager.sendAIMessage();
     } catch (error) {
       console.error("Failed to add user message:", error);
+      // Ensure loading state is released on error
+      aiManager.setIsLoading(false);
       // Loading state will be automatically updated by the useEffect that watches messages
     }
   }

package/src/services/taskManager.ts

@@ -7,6 +7,13 @@ import { logger } from "../utils/globalLogger.js";
 import { Container } from "../utils/container.js";
 import type { MessageManager } from "../managers/messageManager.js";
 
+function byIdAsc(a: Task, b: Task) {
+  const aNum = parseInt(a.id, 10);
+  const bNum = parseInt(b.id, 10);
+  if (!isNaN(aNum) && !isNaN(bNum)) return aNum - bNum;
+  return a.id.localeCompare(b.id);
+}
+
 export class TaskManager extends EventEmitter {
   private readonly baseDir: string;
   private taskListId: string;
@@ -234,7 +241,7 @@ export class TaskManager extends EventEmitter {
         }),
       );
 
-      return tasks.filter((t): t is Task => t !== null);
+      return tasks.filter((t): t is Task => t !== null).sort(byIdAsc);
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === "ENOENT") {
         return [];

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

@@ -1,7 +1,6 @@
 import { Container } from "./container.js";
 import { ForegroundTaskManager } from "../managers/foregroundTaskManager.js";
 import { BackgroundTaskManager } from "../managers/backgroundTaskManager.js";
-import { NotificationQueue } from "../managers/notificationQueue.js";
 import { MessageQueue } from "../managers/messageQueue.js";
 import { TaskManager } from "../services/taskManager.js";
 import { MessageManager } from "../managers/messageManager.js";
@@ -88,8 +87,9 @@ export function setupAgentContainer(
     container.register("MainRepoRoot", getGitMainRepoRoot(workdir));
   }
 
-  const notificationQueue = new NotificationQueue();
-  container.register("NotificationQueue", notificationQueue);
+  // 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 messageQueue = new MessageQueue();
   container.register("MessageQueue", messageQueue);