wave-agent-sdk 0.19.5 → 0.19.7

package/dist/managers/backgroundTaskManager.js

@@ -4,6 +4,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import { logger } from "../utils/globalLogger.js";
+import { resolveShellPath } from "../utils/shellResolver.js";
 export class BackgroundTaskManager {
     constructor(container, options) {
         this.container = container;
@@ -12,9 +13,6 @@ export class BackgroundTaskManager {
         this.callbacks = options.callbacks || {};
         this.workdir = options.workdir;
     }
-    get notificationQueue() {
-        return this.container.get("NotificationQueue");
-    }
     /**
      * Fire the onBackgroundTasksChange callback so UI consumers refresh.
      * Public so other managers (e.g. WorkflowManager) can trigger a refresh
@@ -36,14 +34,14 @@ export class BackgroundTaskManager {
     getAllTasks() {
         return Array.from(this.tasks.values());
     }
-    startShell(command, timeout) {
+    startShell(command, timeout, cwd) {
         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,
             },
@@ -140,13 +138,13 @@ export class BackgroundTaskManager {
             this.notifyTasksChange();
             // Skip notification if task was manually killed (user/agent-initiated stop)
             if (!wasKilled) {
-                const notificationQueue = this.container.has("NotificationQueue")
-                    ? this.container.get("NotificationQueue")
+                const messageQueue = this.container.has("MessageQueue")
+                    ? this.container.get("MessageQueue")
                     : undefined;
-                if (notificationQueue) {
+                if (messageQueue) {
                     const statusStr = shell.status;
                     const summary = `Command "${command}" ${statusStr} with exit code ${code ?? 0}`;
-                    notificationQueue.enqueue(`<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>`);
+                    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>`);
                 }
             }
         };
@@ -166,12 +164,12 @@ export class BackgroundTaskManager {
             shell.runtime = shell.endTime - startTime;
             this.notifyTasksChange();
             // Enqueue error notification
-            const notificationQueue = this.container.has("NotificationQueue")
-                ? this.container.get("NotificationQueue")
+            const messageQueue = this.container.has("MessageQueue")
+                ? this.container.get("MessageQueue")
                 : undefined;
-            if (notificationQueue) {
+            if (messageQueue) {
                 const summary = `Command "${command}" failed with error: ${stripAnsiColors(error.message)}`;
-                notificationQueue.enqueue(`<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>`);
+                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>`);
             }
         };
         child.stdout?.on("data", onStdout);
@@ -277,13 +275,13 @@ export class BackgroundTaskManager {
             this.notifyTasksChange();
             // Skip notification if task was manually killed (user/agent-initiated stop)
             if (!wasKilled) {
-                const notificationQueue = this.container.has("NotificationQueue")
-                    ? this.container.get("NotificationQueue")
+                const messageQueue = this.container.has("MessageQueue")
+                    ? this.container.get("MessageQueue")
                     : undefined;
-                if (notificationQueue) {
+                if (messageQueue) {
                     const statusStr = shell.status;
                     const summary = `Command "${command}" ${statusStr} with exit code ${code ?? 0}`;
-                    notificationQueue.enqueue(`<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>`);
+                    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>`);
                 }
             }
         });
@@ -300,12 +298,12 @@ export class BackgroundTaskManager {
             shell.runtime = shell.endTime - startTime;
             this.notifyTasksChange();
             // Enqueue error notification
-            const notificationQueue = this.container.has("NotificationQueue")
-                ? this.container.get("NotificationQueue")
+            const messageQueue = this.container.has("MessageQueue")
+                ? this.container.get("MessageQueue")
                 : undefined;
-            if (notificationQueue) {
+            if (messageQueue) {
                 const summary = `Command "${command}" failed with error: ${stripAnsiColors(error.message)}`;
-                notificationQueue.enqueue(`<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>`);
+                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>`);
             }
         });
         return id;

package/dist/managers/bangManager.d.ts

@@ -18,4 +18,3 @@ export declare class BangManager {
     executeCommand(command: string): Promise<number>;
     abortCommand(): void;
 }
-//# sourceMappingURL=bangManager.d.ts.map

package/dist/managers/bangManager.js

@@ -1,4 +1,5 @@
 import { spawn } from "child_process";
+import { resolveShellPath } from "../utils/shellResolver.js";
 export class BangManager {
     constructor(container, options) {
         this.container = container;
@@ -22,7 +23,7 @@ export class BangManager {
         this.messageManager.addBangMessage(command);
         return new Promise((resolve) => {
             const child = spawn(command, {
-                shell: true,
+                shell: resolveShellPath() ?? true,
                 stdio: "pipe",
                 cwd: this.workdir,
                 env: {

package/dist/managers/cronManager.d.ts

@@ -23,4 +23,3 @@ export declare class CronManager {
     private getDeterministicRandom;
     private checkJobs;
 }
-//# sourceMappingURL=cronManager.d.ts.map

package/dist/managers/foregroundTaskManager.d.ts

@@ -9,4 +9,3 @@ export declare class ForegroundTaskManager implements IForegroundTaskManager {
     backgroundCurrentTask(): Promise<void>;
     hasActiveTasks(): boolean;
 }
-//# sourceMappingURL=foregroundTaskManager.d.ts.map

package/dist/managers/forkedAgentManager.d.ts

@@ -48,4 +48,3 @@ export declare class ForkedAgentManager {
     getActiveForks(): ForkedAgentEntry[];
     private notifyChange;
 }
-//# sourceMappingURL=forkedAgentManager.d.ts.map

package/dist/managers/goalManager.d.ts

@@ -40,4 +40,3 @@ export declare class GoalManager {
     private parseEvaluationResponse;
     private formatElapsed;
 }
-//# sourceMappingURL=goalManager.d.ts.map

package/dist/managers/hookManager.d.ts

@@ -143,4 +143,3 @@ export declare class HookManager {
      */
     executePostCompactHooks(sessionId: string, transcriptPath: string, compactSummary: string): Promise<HookExecutionResult[]>;
 }
-//# sourceMappingURL=hookManager.d.ts.map

package/dist/managers/liveConfigManager.d.ts

@@ -83,4 +83,3 @@ export declare class LiveConfigManager {
      */
     private getConfigurationPaths;
 }
-//# sourceMappingURL=liveConfigManager.d.ts.map

package/dist/managers/lspManager.d.ts

@@ -39,4 +39,3 @@ export declare class LspManager implements ILspManager {
     cleanup(): Promise<void>;
 }
 export {};
-//# sourceMappingURL=lspManager.d.ts.map

package/dist/managers/mcpManager.d.ts

@@ -85,4 +85,3 @@ export declare class McpManager {
      */
     isMcpTool(name: string): boolean;
 }
-//# sourceMappingURL=mcpManager.d.ts.map

package/dist/managers/messageManager.d.ts

@@ -190,6 +190,13 @@ export declare class MessageManager {
      * Fires incremental callbacks for each finalized block.
      */
     finalizeStreamingBlocks(): void;
+    /**
+     * 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.
+     */
+    finalizeAbortedToolBlocks(error?: string): void;
     /**
      * Remove the last user message from the conversation
      * Used for hook error handling when the user prompt needs to be erased
@@ -247,4 +254,3 @@ export declare class MessageManager {
      */
     rebuildLoadedRuleIds(): void;
 }
-//# sourceMappingURL=messageManager.d.ts.map

package/dist/managers/messageManager.js

@@ -477,11 +477,22 @@ export class MessageManager {
         if (index < 0)
             return false;
         const block = lastMessage.blocks[index];
-        lastMessage.blocks[index] = {
-            type: block.type,
-            content: block.content,
-            stage: "end",
-        };
+        if (block.type === "reasoning") {
+            lastMessage.blocks[index] = {
+                type: "reasoning",
+                content: block.content,
+                stage: "end",
+                startTime: block.startTime,
+                endTime: Date.now(),
+            };
+        }
+        else {
+            lastMessage.blocks[index] = {
+                type: block.type,
+                content: block.content,
+                stage: "end",
+            };
+        }
         // Fire incremental callback to signal finalization
         const callbackParams = {
             messageId: lastMessage.id,
@@ -564,10 +575,12 @@ export class MessageManager {
         const chunk = newAccumulatedReasoning.slice(currentReasoning.length);
         if (reasoningBlockIndex >= 0) {
             // Update existing reasoning block
+            const existingStartTime = lastMessage.blocks[reasoningBlockIndex].startTime;
             lastMessage.blocks[reasoningBlockIndex] = {
                 type: "reasoning",
                 content: newAccumulatedReasoning,
                 stage: "streaming",
+                startTime: existingStartTime,
             };
         }
         else {
@@ -576,6 +589,7 @@ export class MessageManager {
                 type: "reasoning",
                 content: newAccumulatedReasoning,
                 stage: "streaming",
+                startTime: Date.now(),
             });
         }
         // Trigger callbacks with chunk and accumulated reasoning content
@@ -604,6 +618,51 @@ export class MessageManager {
             this.callbacks.onMessagesChange?.([...this.messages]);
         }
     }
+    /**
+     * 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.
+     */
+    finalizeAbortedToolBlocks(error) {
+        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];
+            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/dist/managers/messageQueue.d.ts

@@ -1,7 +1,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;
@@ -19,12 +19,35 @@ export declare class MessageQueue {
     transitionTo(newState: QueueState): boolean;
     enqueue(message: QueuedMessage): void;
     dequeue(): QueuedMessage | null;
+    /**
+     * Clear user-facing items (messages, bang commands) but preserve pending
+     * notifications so background task results are not lost on abort.
+     */
     clear(): void;
     hasPending(): boolean;
     getQueue(): QueuedMessage[];
     removeAt(index: number): boolean;
     removeById(id: string): boolean;
+    updateById(id: string, patch: {
+        content?: string;
+        images?: Array<{
+            path: string;
+            mimeType: string;
+        }>;
+        type?: "message" | "bang";
+    }): boolean;
     popLastEditable(): QueuedMessage | null;
     popAllEditable(): QueuedMessage[];
+    /**
+     * Enqueue a background task notification (XML string). Notifications are
+     * not user-editable and not surfaced in the queued-messages UI.
+     */
+    enqueueNotification(xml: string): void;
+    /** Whether any notification items are pending. */
+    hasNotifications(): boolean;
+    /**
+     * Drain all notification items, returning their XML content. Non-notification
+     * items (messages, bang commands) are preserved in the queue.
+     */
+    drainNotifications(): string[];
 }
-//# sourceMappingURL=messageQueue.d.ts.map

package/dist/managers/messageQueue.js

@@ -30,8 +30,12 @@ export class MessageQueue {
     dequeue() {
         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() {
-        this.queue = [];
+        this.queue = this.queue.filter((m) => m.type === "notification");
         this._state = "idle";
     }
     hasPending() {
@@ -56,6 +60,19 @@ export class MessageQueue {
         this.onMessageEnqueued?.();
         return true;
     }
+    updateById(id, patch) {
+        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() {
         for (let i = this.queue.length - 1; i >= 0; i--) {
             if (this.queue[i].editable !== false) {
@@ -78,4 +95,39 @@ 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) {
+        this.queue.push({
+            id: `mq-${this.nextId++}`,
+            type: "notification",
+            content: xml,
+            editable: false,
+        });
+        this.onMessageEnqueued?.();
+    }
+    /** Whether any notification items are pending. */
+    hasNotifications() {
+        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() {
+        const notifications = [];
+        const remaining = [];
+        for (const msg of this.queue) {
+            if (msg.type === "notification") {
+                notifications.push(msg.content);
+            }
+            else {
+                remaining.push(msg);
+            }
+        }
+        this.queue = remaining;
+        return notifications;
+    }
 }

package/dist/managers/permissionManager.d.ts

@@ -183,4 +183,3 @@ export declare class PermissionManager {
      */
     addPermissionRule(rule: string): Promise<void>;
 }
-//# sourceMappingURL=permissionManager.d.ts.map

package/dist/managers/permissionManager.js

@@ -11,7 +11,6 @@ import { RESTRICTED_TOOLS } from "../types/permissions.js";
 import { splitBashCommand, stripEnvVars, stripRedirections, hasWriteRedirections, getSmartPrefix, isDangerousFind, DANGEROUS_COMMANDS, } from "../utils/bashParser.js";
 import { isPathInside } from "../utils/pathSafety.js";
 import { BASH_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, READ_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "../constants/tools.js";
-import { getCurrentWorktreeSession } from "../utils/worktreeSession.js";
 const SAFE_COMMANDS = [
     "cd",
     "ls",
@@ -337,8 +336,9 @@ 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");
         const effectiveWorktreeName = this.worktreeName || worktreeSession?.worktreeName;
         const effectiveWorkdir = this.workdir || worktreeSession?.worktreePath;
         const effectiveMainRepoRoot = this.mainRepoRoot || worktreeSession?.repoRoot;

package/dist/managers/planManager.d.ts

@@ -25,4 +25,3 @@ export declare class PlanManager {
     isPlanEntryReminderPending(): boolean;
     consumePlanEntryReminder(): void;
 }
-//# sourceMappingURL=planManager.d.ts.map

package/dist/managers/pluginManager.d.ts

@@ -43,4 +43,3 @@ export declare class PluginManager {
      */
     getPlugin(name: string): Plugin | undefined;
 }
-//# sourceMappingURL=pluginManager.d.ts.map

package/dist/managers/pluginScopeManager.d.ts

@@ -43,4 +43,3 @@ export declare class PluginScopeManager {
      */
     private refreshPluginManager;
 }
-//# sourceMappingURL=pluginScopeManager.d.ts.map

package/dist/managers/reversionManager.d.ts

@@ -37,4 +37,3 @@ export declare class ReversionManager {
      */
     revertTo(messageIds: string[], allMessages: import("../types/index.js").Message[]): Promise<number>;
 }
-//# sourceMappingURL=reversionManager.d.ts.map

package/dist/managers/skillManager.d.ts

@@ -101,4 +101,3 @@ export declare class SkillManager extends EventEmitter {
      */
     registerPluginSkills(pluginName: string, skills: Skill[]): void;
 }
-//# sourceMappingURL=skillManager.d.ts.map

package/dist/managers/slashCommandManager.d.ts

@@ -88,4 +88,3 @@ export declare class SlashCommandManager {
      */
     abortCurrentCommand(): void;
 }
-//# sourceMappingURL=slashCommandManager.d.ts.map

package/dist/managers/subagentManager.d.ts

@@ -5,7 +5,6 @@ import { AIManager } from "./aiManager.js";
 import { MessageManager } from "./messageManager.js";
 import { ToolManager } from "./toolManager.js";
 import { BackgroundTaskManager } from "./backgroundTaskManager.js";
-import { NotificationQueue } from "./notificationQueue.js";
 import { UserMessageParams, type ToolBlockUpdateCallbackParams } from "../utils/messageOperations.js";
 import { Container } from "../utils/container.js";
 import type { PermissionManager } from "./permissionManager.js";
@@ -46,7 +45,6 @@ export interface SubagentInstance {
     toolManager: ToolManager;
     permissionManager: PermissionManager;
     backgroundTaskManager: BackgroundTaskManager;
-    notificationQueue: NotificationQueue;
     status: "initializing" | "active" | "completed" | "error" | "aborted";
     messages: Message[];
     usedTools: {
@@ -156,4 +154,3 @@ export declare class SubagentManager {
      */
     private createSubagentCallbacks;
 }
-//# sourceMappingURL=subagentManager.d.ts.map

package/dist/managers/subagentManager.js

@@ -5,10 +5,9 @@ import * as path from "path";
 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 { logger } from "../utils/globalLogger.js";
 export class SubagentManager {
     constructor(container, options) {
@@ -165,6 +164,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(),
             systemAdditionalDirectories: parentPermissionManager?.getSystemAdditionalDirectories(),
@@ -210,9 +215,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, {
             workdir: this.workdir,
@@ -226,7 +228,6 @@ export class SubagentManager {
             toolManager,
             permissionManager: subagentPermissionManager,
             backgroundTaskManager: subagentBackgroundTaskManager,
-            notificationQueue: subagentNotificationQueue,
             status: "initializing",
             messages: [],
             usedTools: [], // Initialize usedTools
@@ -420,12 +421,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")
+                        const messageQueue = this.container.has("MessageQueue")
+                            ? this.container.get("MessageQueue")
                             : undefined;
-                        if (notificationQueue) {
+                        if (messageQueue) {
                             const summary = `Agent task "${instance.description}" completed`;
-                            notificationQueue.enqueue(`<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>`);
+                            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>`);
                         }
                     }
                 }
@@ -452,13 +453,13 @@ 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")
+                        const messageQueue = this.container.has("MessageQueue")
+                            ? this.container.get("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(`<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>`);
+                            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/dist/managers/toolManager.d.ts

@@ -114,4 +114,3 @@ declare class ToolManager {
     getTaskManager(): import("../services/taskManager.js").TaskManager | undefined;
 }
 export { ToolManager };
-//# sourceMappingURL=toolManager.d.ts.map

package/dist/managers/workflowManager.d.ts

@@ -9,7 +9,7 @@ export declare class WorkflowManager {
     constructor(container: Container);
     private get stateStore();
     private get backgroundTaskManager();
-    private get notificationQueue();
+    private get messageQueue();
     private get subagentManager();
     private get workdir();
     private get sessionDir();
@@ -62,4 +62,3 @@ export declare class WorkflowManager {
      */
     cleanup(): void;
 }
-//# sourceMappingURL=workflowManager.d.ts.map

package/dist/managers/workflowManager.js

@@ -30,8 +30,8 @@ export class WorkflowManager {
     get backgroundTaskManager() {
         return this.container.get("BackgroundTaskManager");
     }
-    get notificationQueue() {
-        return this.container.get("NotificationQueue");
+    get messageQueue() {
+        return this.container.get("MessageQueue");
     }
     get subagentManager() {
         return this.container.get("SubagentManager");
@@ -209,7 +209,7 @@ export class WorkflowManager {
                 }
                 // Enqueue completion notification
                 const journalPath = journal.filePath;
-                this.notificationQueue.enqueue(taskNotificationToXml({
+                this.messageQueue.enqueueNotification(taskNotificationToXml({
                     type: "task_notification",
                     taskId: runId,
                     taskType: "workflow",
@@ -244,7 +244,7 @@ export class WorkflowManager {
                     task.stderr = run.error || "";
                     task.endTime = Date.now();
                 }
-                this.notificationQueue.enqueue(taskNotificationToXml({
+                this.messageQueue.enqueueNotification(taskNotificationToXml({
                     type: "task_notification",
                     taskId: runId,
                     taskType: "workflow",

package/dist/prompts/autoMemory.d.ts

@@ -1,2 +1 @@
 export declare function buildAutoMemoryPrompt(memoryDir: string): string;
-//# sourceMappingURL=autoMemory.d.ts.map

package/dist/prompts/autoMemoryExtraction.d.ts

@@ -2,4 +2,3 @@
  * Build the auto-memory extraction prompt for the background agent.
  */
 export declare function buildAutoMemoryExtractionPrompt(newMessageCount: number, existingMemoriesManifest: string): string;
-//# sourceMappingURL=autoMemoryExtraction.d.ts.map