wave-agent-sdk 0.13.6 → 0.14.0

package/src/managers/subagentManager.ts

@@ -567,23 +567,25 @@ export class SubagentManager {
         instance.logStream?.end();
         const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
         if (task) {
+          const wasAlreadyKilled = task.status === "killed";
           task.status = "completed";
           task.stdout = response || "Agent completed with no text response";
           task.endTime = Date.now();
           if (task.startTime) {
             task.runtime = task.endTime - task.startTime;
           }
-        }
-
-        // Enqueue completion notification
-        const notificationQueue = this.container.has("NotificationQueue")
-          ? this.container.get<NotificationQueue>("NotificationQueue")
-          : undefined;
-        if (notificationQueue) {
-          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>`,
-          );
+          // 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")
+              : undefined;
+            if (notificationQueue) {
+              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>`,
+              );
+            }
+          }
         }
       }
 
@@ -602,25 +604,27 @@ export class SubagentManager {
         instance.logStream?.end();
         const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
         if (task) {
+          const wasAlreadyKilled = task.status === "killed";
           task.status = "failed";
           task.stderr = error instanceof Error ? error.message : String(error);
           task.endTime = Date.now();
           if (task.startTime) {
             task.runtime = task.endTime - task.startTime;
           }
-        }
-
-        // Enqueue error notification
-        const notificationQueue = this.container.has("NotificationQueue")
-          ? this.container.get<NotificationQueue>("NotificationQueue")
-          : undefined;
-        if (notificationQueue) {
-          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>`,
-          );
+          // 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")
+              : undefined;
+            if (notificationQueue) {
+              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>`,
+              );
+            }
+          }
         }
       }
       throw error;

package/src/prompts/index.ts

@@ -179,28 +179,52 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 
 export const DEFAULT_SYSTEM_PROMPT = BASE_SYSTEM_PROMPT;
 
-export const COMPRESS_MESSAGES_SYSTEM_PROMPT = `You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:
-1. Task Overview
-The user's core request and success criteria
-Any clarifications or constraints they specified
-2. Current State
-What has been completed so far
-Files created, modified, or analyzed (with paths if relevant)
-Key outputs or artifacts produced
-3. Important Discoveries
-Technical constraints or requirements uncovered
-Decisions made and their rationale
-Errors encountered and how they were resolved
-What approaches were tried that didn't work (and why)
-4. Next Steps
-Specific actions needed to complete the task
-Any blockers or open questions to resolve
-Priority order if multiple steps remain
-5. Context to Preserve
-User preferences or style requirements
-Domain-specific details that aren't obvious
-Any promises made to the user
-Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.
+export const COMPRESS_MESSAGES_SYSTEM_PROMPT = `You are continuing work on a software engineering task. Write a detailed continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary.
+
+First, write your analysis in <analysis> tags as a thinking scratchpad:
+- Chronologically review the conversation
+- Identify user intents and goals
+- Note files read/modified, approaches tried, decisions made
+- Check for accuracy and completeness — ensure nothing critical is missing
+
+Then produce a structured summary in <summary> tags with these sections:
+
+## Primary Request and Intent
+- The user's core request and success criteria
+- Clarifications, constraints, or scope changes
+
+## Key Technical Concepts
+- Frameworks, libraries, patterns, architectural decisions
+
+## Files and Code Sections
+- Files read, modified, created (with full paths)
+- Critical code snippets (function signatures, bug fixes, key logic)
+- Focus on recent messages — include full code for important sections
+
+## Errors and Fixes
+- Errors encountered, root causes, how they were resolved
+- Approaches tried that didn't work and why
+
+## Problem Solving
+- Approach evolution, trade-offs considered, decisions made
+
+## All User Messages
+- Complete list of all user messages (non-tool content)
+- Preserve exact wording where load-bearing
+
+## Pending Tasks
+- Outstanding work, TODOs, unresolved questions
+
+## Current Work
+- What was being worked on at the time of summarization
+- Exact state of in-progress changes
+
+## Optional Next Step
+- Immediate next action needed
+- Include verbatim quotes from recent conversation if relevant
+
+Be concise but complete — include information that prevents duplicate work or repeated mistakes.
+Respond with text only. Do NOT call any tools.
 Wrap your summary in <summary></summary> tags.`;
 
 export const WEB_CONTENT_SYSTEM_PROMPT = `You are a helpful assistant that extracts information from web content. The content is provided in Markdown format.`;
@@ -214,6 +238,7 @@ export function buildSystemPrompt(
   tools: ToolPlugin[],
   options: {
     workdir?: string;
+    originalWorkdir?: string;
     memory?: string;
     language?: string;
     isSubagent?: boolean;
@@ -251,8 +276,9 @@ export function buildSystemPrompt(
     prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists, options.isSubagent)}`;
   }
 
-  if (options.workdir) {
-    const isGitRepo = isGitRepository(options.workdir);
+  const workdirForPrompt = options.originalWorkdir || options.workdir;
+  if (workdirForPrompt) {
+    const isGitRepo = isGitRepository(workdirForPrompt);
     const platform = os.platform();
     const osVersion = `${os.type()} ${os.release()}`;
     const today = new Date().toISOString().split("T")[0];
@@ -267,7 +293,7 @@ export function buildSystemPrompt(
 
 Here is useful information about the environment you are running in:
 <env>
-Working directory: ${options.workdir}
+Working directory: ${workdirForPrompt}
 Is directory a git repo: ${isGitRepo}
 Platform: ${platform}
 Shell: ${shellName}

package/src/services/aiService.ts

@@ -784,6 +784,19 @@ export async function compressMessages(
     await acquireSlot(abortSignal);
   }
 
+  // Strip images from messages before compact API call to reduce token usage
+  const cleanedMessages = messages.map((msg) => {
+    // Handle user/assistant messages with array content
+    if (Array.isArray(msg.content)) {
+      const textParts = msg.content.filter(
+        (part) => part.type === "text",
+      ) as import("openai/resources.js").ChatCompletionContentPartText[];
+      const text = textParts.map((p) => p.text).join("\n");
+      return { ...msg, content: text || "(empty message)" };
+    }
+    return msg;
+  });
+
   // Create OpenAI client with injected configuration
   const openai = new OpenAIClient({
     apiKey: gatewayConfig.apiKey,
@@ -821,7 +834,7 @@ export async function compressMessages(
             role: "system",
             content: COMPRESS_MESSAGES_SYSTEM_PROMPT,
           },
-          ...messages,
+          ...cleanedMessages,
           {
             role: "user",
             content: `Please create a detailed summary of the conversation so far.`,

package/src/tools/agentTool.ts

@@ -71,7 +71,11 @@ When using the Agent tool, you must specify a subagent_type parameter to select
 
 - When doing file search, prefer to use the ${AGENT_TOOL_NAME} tool in order to reduce context usage.
 - You should proactively use the ${AGENT_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${AGENT_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`;
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${AGENT_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.
+- You can optionally run agents in the background using the run_in_background parameter. When an agent runs in the background, you will be automatically notified when it completes — do NOT sleep, poll, or proactively check on its progress. Continue with other work or respond to the user instead.
+- **Foreground vs background**: Use foreground (default) when you need the agent's results before you can proceed — e.g., research agents whose findings inform your next steps. Use background when you have genuinely independent work to do in parallel.
+- **Don't peek.** The tool result includes an output file path — do not Read or tail it unless the user explicitly asks for a progress check. You get a completion notification; trust it. Reading the transcript mid-flight pulls the agent's tool noise into your context, which defeats the point of backgrounding.
+- **Don't race.** After launching, you know nothing about what the agent found. Never fabricate or predict agent results in any format — not as prose, summary, or structured output. The notification arrives as a user-role message in a later turn; it is never something you write yourself. If the user asks a follow-up before the notification lands, tell them the agent is still running — give status, not a guess.`;
   },
 
   execute: async (
@@ -212,9 +216,17 @@ When using the Agent tool, you must specify a subagent_type parameter to select
             if (run_in_background) {
               const task = context.backgroundTaskManager?.getTask(result);
               const outputPath = task?.outputPath;
+              const backgroundMsg = [
+                `Agent started in background with ID: ${result}.`,
+                `The agent is working in the background. You will be notified automatically when it completes.`,
+                `Do not duplicate this agent's work — avoid working with the same files or topics it is using.`,
+                outputPath
+                  ? `output_file: ${outputPath}`
+                  : `Briefly tell the user what you launched and end your response.`,
+              ].join("\n");
               resolve({
                 success: true,
-                content: `Agent started in background with ID: ${result}.${outputPath ? ` Real-time output: ${outputPath}` : ""}`,
+                content: backgroundMsg,
                 shortResult: `Agent started in background: ${result}`,
               });
               return;

package/src/tools/bashTool.ts

@@ -139,7 +139,10 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
 - Do not retry failing commands in a sleep loop — diagnose the root cause.
 - If waiting for a background task you started with \`run_in_background\`, you will be notified when it completes — do not poll.
 - If you must poll an external process, use a check command (e.g. \`gh run view\`) rather than sleeping first.
-- If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.`,
+- If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.
+
+# CWD management
+Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it. When you use \`cd\`, the shell working directory will be reset to the original working directory after the command completes.`,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,
@@ -221,9 +224,16 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
       const { id: taskId } = backgroundTaskManager.startShell(command, timeout);
       const task = backgroundTaskManager.getTask(taskId);
       const outputPath = task?.outputPath;
+      const backgroundMsg = [
+        `Command started in background with ID: ${taskId}.`,
+        `You will be notified automatically when it completes.`,
+        outputPath
+          ? `output_file: ${outputPath}`
+          : `Use ${READ_TOOL_NAME} tool with task_id="${taskId}" to read the output.`,
+      ].join("\n");
       return {
         success: true,
-        content: `Command started in background with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ` Use ${READ_TOOL_NAME} tool with task_id="${taskId}" to monitor output.`}`,
+        content: backgroundMsg,
         shortResult: `Background process ${taskId} started`,
       };
     }
@@ -446,9 +456,20 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
             }
           }
 
-          // If CWD changed, call the onCwdChange callback
+          // If CWD changed, call the onCwdChange callback and add notification
+          let cwdChangedNotification = "";
           if (newCwd && newCwd !== context.workdir && context.onCwdChange) {
-            context.onCwdChange(newCwd);
+            const isInSafeZone =
+              context.permissionManager?.isPathInSafeZone?.(newCwd) ?? true;
+
+            if (isInSafeZone) {
+              context.onCwdChange(newCwd);
+            } else if (context.originalWorkdir) {
+              context.onCwdChange(context.originalWorkdir);
+              cwdChangedNotification = `Shell cwd was reset to ${context.originalWorkdir}\n`;
+            } else {
+              context.onCwdChange(newCwd);
+            }
           }
 
           const exitCode = code ?? 0;
@@ -457,7 +478,8 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
 
           // Handle large output by truncation and persistence if needed
           const finalOutput =
-            combinedOutput || `Command executed with exit code: ${exitCode}`;
+            cwdChangedNotification +
+            (combinedOutput || `Command executed with exit code: ${exitCode}`);
           const content = processOutput(finalOutput);
 
           const lines = combinedOutput.trim().split("\n");

package/src/tools/types.ts

@@ -58,6 +58,7 @@ export interface ToolContext {
   abortSignal?: AbortSignal;
   backgroundTaskManager?: import("../managers/backgroundTaskManager.js").BackgroundTaskManager;
   workdir: string;
+  originalWorkdir?: string;
   /** Permission mode for this tool execution */
   permissionMode?: PermissionMode;
   /** Custom permission callback */