wave-agent-sdk 0.19.6 → 0.19.8

package/dist/agent.d.ts

@@ -22,9 +22,8 @@ export declare class Agent {
     private goalManager;
     private hookManager;
     private reversionManager;
-    private notificationQueue;
     private messageQueue;
-    private pendingNotificationPromises;
+    private dispatchPromise;
     private memoryRuleManager;
     private liveConfigManager;
     private taskManager;
@@ -90,7 +89,7 @@ export declare class Agent {
     get isCompacting(): boolean;
     /** Get bash command execution status */
     get isCommandRunning(): boolean;
-    /** Get queued messages */
+    /** Get queued user-facing messages (excludes background notifications) */
     get queuedMessages(): QueuedMessage[];
     /** Get goal status string */
     get goalStatus(): string;
@@ -128,13 +127,15 @@ export declare class Agent {
         type?: "message" | "bang";
     }): boolean;
     /**
-     * Unified dequeue trigger — checks state machine before processing.
-     * Called from onMessageEnqueued, onLoadingChange(false), and
-     * onCommandRunningChange(false).
+     * 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;
+    private tryDispatch;
     /**
-     * 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 processQueuedMessage;
     /** Get background bash shell output */
@@ -221,11 +222,6 @@ export declare class Agent {
      */
     restoreSession(sessionId: string): Promise<void>;
     abortAIMessage(): void;
-    /**
-     * Process pending background task notifications by injecting them as user messages
-     * and triggering a new AI response cycle.
-     */
-    private processPendingNotifications;
     /** Execute bash command (bang command) */
     bang(command: string): Promise<void>;
     clearMessages(): Promise<void>;
@@ -394,5 +390,11 @@ export declare class Agent {
      * Check if there are any running background tasks or active subagents
      */
     get hasRunningBackgroundWork(): boolean;
+    /**
+     * Check if there are pending items (messages, bang commands, or background
+     * task notifications) in the message queue. Background task completion
+     * notifications are enqueued before the main agent's dispatch consumes them,
+     * so callers waiting for the agent to fully settle must also wait on this.
+     */
+    get hasPendingMessages(): boolean;
 }
-//# sourceMappingURL=agent.d.ts.map

package/dist/agent.js

@@ -51,7 +51,7 @@ export class Agent {
      */
     constructor(options) {
         this.bangManager = null;
-        this.pendingNotificationPromises = []; // Track pending notification processing
+        this.dispatchPromise = null; // Track current dispatch for teardown
         this.sessionStartTime = Date.now();
         const { logger, workdir, systemPrompt, stream = true } = options;
         // Set working directory early as we need it for loading configuration
@@ -111,36 +111,27 @@ 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;
             this.container.register("Workdir", newCwd);
             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) => {
             if (!loading)
-                this.tryDequeue();
+                this.tryDispatch();
         };
         // Wire up bang manager callback for command running changes
         this.bangManager.onCommandRunningChange = (running) => {
             this.options.callbacks?.onCommandRunningChange?.(running);
             if (!running)
-                this.tryDequeue();
+                this.tryDispatch();
         };
         // Set initial permission mode if provided
         if (options.permissionMode) {
@@ -218,9 +209,11 @@ export class Agent {
     get isCommandRunning() {
         return this.bangManager?.isCommandRunning ?? false;
     }
-    /** Get queued messages */
+    /** Get queued user-facing messages (excludes background notifications) */
     get queuedMessages() {
-        return this.messageQueue.getQueue();
+        return this.messageQueue
+            .getQueue()
+            .filter((m) => m.type !== "notification");
     }
     /** Get goal status string */
     get goalStatus() {
@@ -279,11 +272,12 @@ export class Agent {
         return updated;
     }
     /**
-     * Unified dequeue trigger — checks state machine before processing.
-     * Called from onMessageEnqueued, onLoadingChange(false), and
-     * onCommandRunningChange(false).
+     * 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).
      */
-    tryDequeue() {
+    tryDispatch() {
         if (this.messageQueue.state !== "idle")
             return;
         if (!this.messageQueue.hasPending())
@@ -291,17 +285,19 @@ export class Agent {
         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.
      */
     async processQueuedMessage() {
         const next = this.messageQueue.dequeue();
@@ -313,6 +309,26 @@ export class Agent {
             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);
         }
@@ -489,29 +505,6 @@ export class Agent {
     abortAIMessage() {
         this.aiManager.abortAIMessage();
     }
-    /**
-     * Process pending background task notifications by injecting them as user messages
-     * and triggering a new AI response cycle.
-     */
-    async processPendingNotifications() {
-        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) */
     async bang(command) {
         // If the agent is busy, enqueue the bang command
@@ -640,8 +633,9 @@ export class Agent {
     /** Unified interrupt method, interrupts both AI messages and command execution */
     abortMessage() {
         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);
         }
@@ -715,14 +709,13 @@ export class Agent {
             exitReason: "destroy",
         }).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;
-        // Await any pending notification processing to prevent race conditions
+        this.messageQueue.onMessageEnqueued = undefined;
+        // 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)
         try {
@@ -985,4 +978,13 @@ export class Agent {
         const activeSubagents = this.subagentManager.getActiveInstances().length > 0;
         return runningTasks || activeSubagents;
     }
+    /**
+     * Check if there are pending items (messages, bang commands, or background
+     * task notifications) in the message queue. Background task completion
+     * notifications are enqueued before the main agent's dispatch consumes them,
+     * so callers waiting for the agent to fully settle must also wait on this.
+     */
+    get hasPendingMessages() {
+        return this.messageQueue.hasPending();
+    }
 }

package/dist/constants/goalPrompts.d.ts

@@ -1,2 +1 @@
 export declare const GOAL_EVALUATION_SYSTEM_PROMPT = "You are a goal evaluator. Given a goal condition and a conversation, determine whether the goal has been achieved.\n\nRules:\n- Judge ONLY based on what the conversation shows \u2014 tool outputs, test results, file contents, etc.\n- Do NOT assume work is done without evidence in the conversation.\n- Be strict and conservative: when uncertain, return met: false.\n- Be concise: your reason should be 1-2 sentences.\n\nRespond with JSON only, no other text:\n{\"met\": boolean, \"reason\": \"short explanation\"}";
-//# sourceMappingURL=goalPrompts.d.ts.map

package/dist/constants/subagents.d.ts

@@ -2,4 +2,3 @@ export declare const BASH_SUBAGENT_TYPE = "Bash";
 export declare const EXPLORE_SUBAGENT_TYPE = "Explore";
 export declare const PLAN_SUBAGENT_TYPE = "Plan";
 export declare const GENERAL_PURPOSE_SUBAGENT_TYPE = "general-purpose";
-//# sourceMappingURL=subagents.d.ts.map

package/dist/constants/toolLimits.d.ts

@@ -9,4 +9,3 @@ export declare const BASH_MAX_OUTPUT_CHARS = 30000;
 export declare const SKILL_BASH_MAX_OUTPUT_CHARS = 30000;
 /** Preview size in characters when output is persisted to disk. */
 export declare const PREVIEW_SIZE_BYTES = 2048;
-//# sourceMappingURL=toolLimits.d.ts.map

package/dist/constants/tools.d.ts

@@ -22,4 +22,3 @@ export declare const WEB_FETCH_TOOL_NAME = "WebFetch";
 export declare const ENTER_WORKTREE_TOOL_NAME = "EnterWorktree";
 export declare const EXIT_WORKTREE_TOOL_NAME = "ExitWorktree";
 export declare const WORKFLOW_TOOL_NAME = "Workflow";
-//# sourceMappingURL=tools.d.ts.map

package/dist/core/plugin.d.ts

@@ -87,4 +87,3 @@ export declare class PluginCore {
      */
     removeEnabledPlugin(scope: Scope, pluginId: string): Promise<void>;
 }
-//# sourceMappingURL=plugin.d.ts.map

package/dist/core/session.d.ts

@@ -1,3 +1,2 @@
 export { listSessions, listAllSessions, truncateContent, loadSessionFromJsonl, loadFullMessageThread, deleteSession, } from "../services/session.js";
 export type { SessionMetadata, SessionData } from "../services/session.js";
-//# sourceMappingURL=session.d.ts.map

package/dist/index.d.ts

@@ -22,7 +22,7 @@ export * from "./utils/tokenCalculation.js";
 export * from "./utils/gitUtils.js";
 export * from "./utils/nameGenerator.js";
 export * from "./utils/worktreeSession.js";
+export { loadMergedWaveConfig } from "./services/configurationService.js";
 export * from "./types/index.js";
 export * from "./tools/buildTool.js";
 export type { ToolPlugin, ToolResult, ToolContext } from "./tools/types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -26,6 +26,7 @@ export * from "./utils/tokenCalculation.js";
 export * from "./utils/gitUtils.js";
 export * from "./utils/nameGenerator.js";
 export * from "./utils/worktreeSession.js";
+export { loadMergedWaveConfig } from "./services/configurationService.js";
 export * from "./types/index.js";
 // Export tool building utilities
 export * from "./tools/buildTool.js";

package/dist/managers/MemoryRuleManager.d.ts

@@ -39,4 +39,3 @@ export declare class MemoryRuleManager {
      */
     reload(): Promise<void>;
 }
-//# sourceMappingURL=MemoryRuleManager.d.ts.map

package/dist/managers/aiManager.d.ts

@@ -21,6 +21,7 @@ export interface AIManagerOptions {
 export declare class AIManager {
     private container;
     isLoading: boolean;
+    private turnGeneration;
     private abortController;
     onLoadingChange?: (loading: boolean) => void;
     private toolAbortController;
@@ -57,6 +58,7 @@ export declare class AIManager {
     getMaxInputTokens(): number;
     getLanguage(): string | undefined;
     getAutoMemoryEnabled(): boolean;
+    getWorktreeBaseRef(): "fresh" | "head";
     getWorkdir(): string;
     getOriginalWorkdir(): string;
     /**
@@ -139,4 +141,3 @@ export declare class AIManager {
      */
     private executePostToolUseHooks;
 }
-//# sourceMappingURL=aiManager.d.ts.map

package/dist/managers/aiManager.js

@@ -53,6 +53,7 @@ export class AIManager {
     constructor(container, options) {
         this.container = container;
         this.isLoading = false;
+        this.turnGeneration = 0; // Guards against concurrent sendAIMessage turns
         this.abortController = null;
         this.toolAbortController = null;
         this.consecutiveCompactionFailures = 0;
@@ -127,6 +128,9 @@ export class AIManager {
     getAutoMemoryEnabled() {
         return this.configurationService.resolveAutoMemoryEnabled();
     }
+    getWorktreeBaseRef() {
+        return this.configurationService.resolveWorktreeBaseRef();
+    }
     getWorkdir() {
         return this.container.get("Workdir") ?? process.cwd();
     }
@@ -241,6 +245,9 @@ export class AIManager {
         options?.callbacks?.onLoadingChange?.(isLoading);
     }
     abortAIMessage() {
+        // 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 {
@@ -560,6 +567,14 @@ export class AIManager {
     async sendAIMessage(options = {}) {
         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;
             // OpenTelemetry: start interaction span for this turn (initial call only)
@@ -577,9 +592,8 @@ export class AIManager {
                     prompt_length: String(userPromptText.length),
                 }).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);
                 }
@@ -976,8 +990,6 @@ export class AIManager {
                 endInteractionSpan();
                 // 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();
                 // Clear abort controllers
@@ -1058,11 +1070,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")
+                const messageQueue = this.container.has("MessageQueue")
+                    ? this.container.get("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) {
@@ -1080,8 +1092,16 @@ export class AIManager {
                     turnOffset = 0;
                 }
             }
-            if (!shouldRestart)
+            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;
+            }
         }
     }
     /**

package/dist/managers/backgroundTaskManager.d.ts

@@ -15,7 +15,6 @@ export declare class BackgroundTaskManager {
     private callbacks;
     private workdir;
     constructor(container: Container, options: BackgroundTaskManagerOptions);
-    private get notificationQueue();
     /**
      * Fire the onBackgroundTasksChange callback so UI consumers refresh.
      * Public so other managers (e.g. WorkflowManager) can trigger a refresh
@@ -43,4 +42,3 @@ export declare class BackgroundTaskManager {
     stopTask(id: string): boolean;
     cleanup(): void;
 }
-//# sourceMappingURL=backgroundTaskManager.d.ts.map

package/dist/managers/backgroundTaskManager.js

@@ -13,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
@@ -141,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>`);
                 }
             }
         };
@@ -167,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);
@@ -278,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>`);
                 }
             }
         });
@@ -301,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/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

@@ -254,4 +254,3 @@ export declare class MessageManager {
      */
     rebuildLoadedRuleIds(): void;
 }
-//# sourceMappingURL=messageManager.d.ts.map

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,6 +19,10 @@ 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[];
@@ -34,5 +38,16 @@ export declare class MessageQueue {
     }): 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