wave-agent-sdk 0.19.5 → 0.19.7

package/dist/agent.d.ts

@@ -1,6 +1,7 @@
 import { type QueuedMessage } from "./managers/messageQueue.js";
 import { SlashCommand, CustomSlashCommand, AgentOptions } from "./types/index.js";
 import type { Message, McpServerStatus, GatewayConfig, ModelConfig, Usage, PermissionMode, ForegroundTask } from "./types/index.js";
+import type { WorktreeSession } from "./utils/worktreeSession.js";
 export declare class Agent {
     private messageManager;
     private aiManager;
@@ -21,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;
@@ -71,6 +71,12 @@ export declare class Agent {
      * @param newCwd - The new working directory
      */
     setWorkdir(newCwd: string): void;
+    /**
+     * Set this session's worktree session state (used by CLI -w startup to inject the
+     * session created before the agent existed). Delegates to AIManager so the state is
+     * stored in this agent's own DI container.
+     */
+    setWorktreeSession(session: WorktreeSession | null): void;
     /** Get project memory content */
     get projectMemory(): string;
     /** Get user memory content */
@@ -83,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;
@@ -107,13 +113,29 @@ export declare class Agent {
      */
     removeQueuedMessageById(id: string): boolean;
     /**
-     * Unified dequeue trigger — checks state machine before processing.
-     * Called from onMessageEnqueued, onLoadingChange(false), and
-     * onCommandRunningChange(false).
+     * Update a queued message's content by its ID (does not change queue order)
+     * @param id - The ID of the message to update
+     * @param patch - The fields to update
+     * @returns true if the message was updated, false if not found
+     */
+    updateQueuedMessageById(id: string, patch: {
+        content?: string;
+        images?: Array<{
+            path: string;
+            mimeType: string;
+        }>;
+        type?: "message" | "bang";
+    }): boolean;
+    /**
+     * 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 */
@@ -200,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>;
@@ -374,4 +391,3 @@ export declare class Agent {
      */
     get hasRunningBackgroundWork(): 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) {
@@ -184,6 +175,14 @@ export class Agent {
         this.container.register("Workdir", newCwd);
         this.options.callbacks?.onWorkdirChange?.(newCwd);
     }
+    /**
+     * Set this session's worktree session state (used by CLI -w startup to inject the
+     * session created before the agent existed). Delegates to AIManager so the state is
+     * stored in this agent's own DI container.
+     */
+    setWorktreeSession(session) {
+        this.aiManager.setWorktreeSession(session);
+    }
     /** Get project memory content */
     get projectMemory() {
         const memoryService = this.container.get("MemoryService");
@@ -210,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() {
@@ -258,11 +259,25 @@ export class Agent {
         return removed;
     }
     /**
-     * Unified dequeue trigger — checks state machine before processing.
-     * Called from onMessageEnqueued, onLoadingChange(false), and
-     * onCommandRunningChange(false).
+     * Update a queued message's content by its ID (does not change queue order)
+     * @param id - The ID of the message to update
+     * @param patch - The fields to update
+     * @returns true if the message was updated, false if not found
+     */
+    updateQueuedMessageById(id, patch) {
+        const updated = this.messageQueue.updateById(id, patch);
+        if (updated) {
+            this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
+        }
+        return updated;
+    }
+    /**
+     * Unified dispatch trigger — checks state machine before processing.
+     * Handles user messages, bang commands, and background task notifications
+     * through a single serialized path. Called from onMessageEnqueued,
+     * onLoadingChange(false), and onCommandRunningChange(false).
      */
-    tryDequeue() {
+    tryDispatch() {
         if (this.messageQueue.state !== "idle")
             return;
         if (!this.messageQueue.hasPending())
@@ -270,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();
@@ -292,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);
         }
@@ -468,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
@@ -619,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);
         }
@@ -694,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 {

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

@@ -25,4 +25,3 @@ export * from "./utils/worktreeSession.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/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

@@ -1,5 +1,6 @@
 import type { GatewayConfig, ModelConfig, Usage } from "../types/index.js";
 import { Container } from "../utils/container.js";
+import type { WorktreeSession } from "../utils/worktreeSession.js";
 export interface AIManagerCallbacks {
     onCompactionStateChange?: (isCompacting: boolean) => void;
     onUsageAdded?: (usage: Usage) => void;
@@ -20,6 +21,7 @@ export interface AIManagerOptions {
 export declare class AIManager {
     private container;
     isLoading: boolean;
+    private turnGeneration;
     private abortController;
     onLoadingChange?: (loading: boolean) => void;
     private toolAbortController;
@@ -60,9 +62,21 @@ export declare class AIManager {
     getOriginalWorkdir(): string;
     /**
      * 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).
      */
     setWorkdir(newWorkdir: string): void;
+    /**
+     * Get this session's worktree session state (null if not in a worktree).
+     */
+    getWorktreeSession(): WorktreeSession | null;
+    /**
+     * Set this session's worktree session state.
+     */
+    setWorktreeSession(session: WorktreeSession | null): void;
     setOnCwdChange(callback: (newCwd: string) => void): void;
     private isCompacting;
     private callbacks;
@@ -126,4 +140,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;
@@ -135,11 +136,27 @@ 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).
      */
     setWorkdir(newWorkdir) {
         this.container.register("Workdir", newWorkdir);
-        process.chdir(newWorkdir);
+        this._onCwdChange?.(newWorkdir);
+    }
+    /**
+     * Get this session's worktree session state (null if not in a worktree).
+     */
+    getWorktreeSession() {
+        return (this.container.get("WorktreeSession") ?? null);
+    }
+    /**
+     * Set this session's worktree session state.
+     */
+    setWorktreeSession(session) {
+        this.container.register("WorktreeSession", session);
     }
     setOnCwdChange(callback) {
         this._onCwdChange = callback;
@@ -225,6 +242,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 {
@@ -544,6 +564,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)
@@ -561,9 +589,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);
                 }
@@ -657,6 +684,7 @@ export class AIManager {
                             originalWorkdir: this.getOriginalWorkdir(),
                             language: this.getLanguage(),
                             isSubagent: !!this.subagentType,
+                            worktreeSession: this.getWorktreeSession(),
                             autoMemory: autoMemoryOptions,
                         }), // Pass custom system prompt
                         maxTokens: maxTokens, // Pass max tokens override
@@ -941,6 +969,12 @@ export class AIManager {
                         error_type: error instanceof Error ? error.constructor.name : "Unknown",
                         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");
                     // Exit inner loop on error
                     break inner;
@@ -953,8 +987,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
@@ -1035,11 +1067,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) {
@@ -1057,8 +1089,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;
+            }
         }
     }
     /**
@@ -1088,6 +1128,19 @@ export class AIManager {
                     prompt: j.prompt,
                 }))
                 : 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 = {
                 event: hookName,
                 projectDir: this.getWorkdir(),
@@ -1098,6 +1151,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)), // Include environment variables
             };

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
@@ -26,7 +25,7 @@ export declare class BackgroundTaskManager {
     addTask(task: BackgroundTask): void;
     getTask(id: string): BackgroundTask | undefined;
     getAllTasks(): BackgroundTask[];
-    startShell(command: string, timeout?: number): {
+    startShell(command: string, timeout?: number, cwd?: string): {
         id: string;
         child: ChildProcess;
         detach: () => void;
@@ -43,4 +42,3 @@ export declare class BackgroundTaskManager {
     stopTask(id: string): boolean;
     cleanup(): void;
 }
-//# sourceMappingURL=backgroundTaskManager.d.ts.map