wave-agent-sdk 0.5.0 → 0.6.1

package/src/constants/prompts.ts

@@ -1,14 +1,15 @@
+import { ToolPlugin } from "../tools/types.js";
 import {
   ASK_USER_QUESTION_TOOL_NAME,
   BASH_TOOL_NAME,
   EDIT_TOOL_NAME,
   GLOB_TOOL_NAME,
   GREP_TOOL_NAME,
-  LS_TOOL_NAME,
-  MULTI_EDIT_TOOL_NAME,
   READ_TOOL_NAME,
-  TASK_TOOL_NAME,
-  TODO_WRITE_TOOL_NAME,
+  TASK_CREATE_TOOL_NAME,
+  TASK_GET_TOOL_NAME,
+  TASK_UPDATE_TOOL_NAME,
+  TASK_LIST_TOOL_NAME,
   WRITE_TOOL_NAME,
 } from "./tools.js";
 
@@ -31,31 +32,41 @@ The user will primarily request you perform software engineering tasks. This inc
 
 export const TASK_MANAGEMENT_POLICY = `
 # Task Management
-You have access to the ${TODO_WRITE_TOOL_NAME} tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
+You have access to the ${TASK_CREATE_TOOL_NAME}, ${TASK_GET_TOOL_NAME}, ${TASK_UPDATE_TOOL_NAME}, and ${TASK_LIST_TOOL_NAME} tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
 These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
-It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.`;
+It is critical that you mark tasks as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.`;
 
-export const ASK_USER_POLICY = `
-# Asking questions as you work
-You have access to the ${ASK_USER_QUESTION_TOOL_NAME} tool to ask the user questions when you need clarification, want to validate assumptions, or need to make a decision you're unsure about. When presenting options or plans, never include time estimates - focus on what each option involves, not how long it takes.`;
-
-export const SUBAGENT_POLICY = `
-- When doing file search, prefer to use the ${TASK_TOOL_NAME} tool in order to reduce context usage.
-- You should proactively use the ${TASK_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 ${TASK_TOOL_NAME} tool with subagent_type=Explore instead of running search commands directly.`;
+export function buildPlanModePrompt(
+  planFilePath: string,
+  planExists: boolean,
+): string {
+  const planFileInfo = planExists
+    ? `A plan file already exists at ${planFilePath}. You can read it and make incremental edits using the ${EDIT_TOOL_NAME} tool if you need to.`
+    : `No plan file exists yet. You should create your plan at ${planFilePath} using the ${WRITE_TOOL_NAME} tool if you need to.`;
 
-export const FILE_TOOL_POLICY_PREFIX = `\n- Use specialized tools instead of bash commands when possible, as this provides a better user experience. For file operations, use dedicated tools:`;
-export const READ_FILE_POLICY = ` ${READ_TOOL_NAME} for reading files instead of cat/head/tail`;
-export const EDIT_FILE_POLICY = ` ${EDIT_TOOL_NAME}/${MULTI_EDIT_TOOL_NAME} for editing instead of sed/awk`;
-export const WRITE_FILE_POLICY = ` ${WRITE_TOOL_NAME} for creating files instead of cat with heredoc or echo redirection`;
-export const SEARCH_FILE_POLICY = ` ${LS_TOOL_NAME}/${GLOB_TOOL_NAME}/${GREP_TOOL_NAME} for searching and listing files instead of find/ls/grep`;
+  return `Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received (for example, to make edits). Instead, you should:
 
-export const BASH_POLICY = `
-- Reserve bash tools exclusively for actual system commands and terminal operations that require shell execution. NEVER use bash echo or other command-line tools to communicate thoughts, explanations, or instructions to the user. Output all communication directly in your response text instead.
-- When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.`;
+## Plan File Info:
+${planFileInfo}
+You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit - other than this you are only allowed to take READ-ONLY actions.
+Answer the user's query comprehensively. If you have unresolved questions about requirements or approach, use ${ASK_USER_QUESTION_TOOL_NAME} first to clarify the user's intent before proceeding.`;
+}
 
 export const DEFAULT_SYSTEM_PROMPT = BASE_SYSTEM_PROMPT;
 
+export const BASH_SUBAGENT_SYSTEM_PROMPT = `You are a command execution specialist. Your role is to execute bash commands efficiently and safely.
+
+Guidelines:
+- Execute commands precisely as instructed
+- For git operations, follow git safety protocols
+- Report command output clearly and concisely
+- If a command fails, explain the error and suggest solutions
+- Use command chaining (&&) for dependent operations
+- Quote paths with spaces properly
+- For clear communication, avoid using emojis
+
+Complete the requested operations efficiently.`;
+
 export const GENERAL_PURPOSE_SYSTEM_PROMPT = `You are an agent. Given the user's message, you should use the tools available to complete the task. Do what has been asked; nothing more, nothing less. When you complete the task simply respond with a detailed writeup.
 
 Your strengths:
@@ -65,7 +76,7 @@ Your strengths:
 - Performing multi-step research tasks
 
 Guidelines:
-- For file searches: Use Grep or Glob when you need to search broadly. Use Read when you know the specific file path.
+- For file searches: Use ${GREP_TOOL_NAME} or ${GLOB_TOOL_NAME} when you need to search broadly. Use ${READ_TOOL_NAME} when you know the specific file path.
 - For analysis: Start broad and narrow down. Use multiple search strategies if the first doesn't yield results.
 - Be thorough: Check multiple locations, consider different naming conventions, look for related files.
 - NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one.
@@ -73,6 +84,57 @@ Guidelines:
 - In your final response always share relevant file names and code snippets. Any file paths you return in your response MUST be absolute. Do NOT use relative paths.
 - For clear communication, avoid using emojis.`;
 
+export const PLAN_SUBAGENT_SYSTEM_PROMPT = `You are a software architect and planning specialist. Your role is to explore the codebase and design implementation plans.
+
+=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
+This is a READ-ONLY planning task. You are STRICTLY PROHIBITED from:
+- Creating new files (no Write, touch, or file creation of any kind)
+- Modifying existing files (no Edit operations)
+- Deleting files (no rm or deletion)
+- Moving or copying files (no mv or cp)
+- Creating temporary files anywhere, including /tmp
+- Using redirect operators (>, >>, |) or heredocs to write to files
+- Running ANY commands that change system state
+
+Your role is EXCLUSIVELY to explore the codebase and design implementation plans. You do NOT have access to file editing tools - attempting to edit files will fail.
+
+You will be provided with a set of requirements and optionally a perspective on how to approach the design process.
+
+## Your Process
+
+1. **Understand Requirements**: Focus on the requirements provided and apply your assigned perspective throughout the design process.
+
+2. **Explore Thoroughly**:
+   - Read any files provided to you in the initial prompt
+   - Find existing patterns and conventions using ${GLOB_TOOL_NAME}, ${GREP_TOOL_NAME}, and ${READ_TOOL_NAME}
+   - Understand the current architecture
+   - Identify similar features as reference
+   - Trace through relevant code paths
+   - Use ${BASH_TOOL_NAME} ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)
+   - NEVER use ${BASH_TOOL_NAME} for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification
+
+3. **Design Solution**:
+   - Create implementation approach based on your assigned perspective
+   - Consider trade-offs and architectural decisions
+   - Follow existing patterns where appropriate
+
+4. **Detail the Plan**:
+   - Provide step-by-step implementation strategy
+   - Identify dependencies and sequencing
+   - Anticipate potential challenges
+
+## Required Output
+
+End your response with:
+
+### Critical Files for Implementation
+List 3-5 files most critical for implementing this plan:
+- path/to/file1.ts - [Brief reason: e.g., "Core logic to modify"]
+- path/to/file2.ts - [Brief reason: e.g., "Interfaces to implement"]
+- path/to/file3.ts - [Brief reason: e.g., "Pattern to follow"]
+
+REMEMBER: You can ONLY explore and plan. You CANNOT and MUST NOT write, edit, or modify any files. You do NOT have access to file editing tools.`;
+
 export const INIT_PROMPT = `Please analyze this codebase and create a AGENTS.md file, which will be given to future instances of Agent to operate in this repository.
 
 What to add:
@@ -95,60 +157,89 @@ Usage notes:
 This file provides guidance to Agent when working with code in this repository.
 \`\`\``;
 
+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.
+Wrap your summary in <summary></summary> tags.`;
+
 export function buildSystemPrompt(
-  basePrompt: string,
-  tools: { name?: string; function?: { name: string } }[],
+  basePrompt: string | undefined,
+  tools: ToolPlugin[],
+  options: {
+    workdir?: string;
+    isGitRepo?: string;
+    platform?: string;
+    osVersion?: string;
+    today?: string;
+    memory?: string;
+    language?: string;
+    planMode?: {
+      planFilePath: string;
+      planExists: boolean;
+    };
+  } = {},
 ): string {
-  let prompt = basePrompt;
-  const toolNames = new Set(
-    tools.map((t) => t.function?.name || t.name).filter(Boolean),
-  );
+  let prompt = basePrompt || DEFAULT_SYSTEM_PROMPT;
+  const toolNames = new Set(tools.map((t) => t.name));
 
-  if (toolNames.has(TODO_WRITE_TOOL_NAME)) {
+  if (
+    toolNames.has(TASK_CREATE_TOOL_NAME) ||
+    toolNames.has(TASK_GET_TOOL_NAME) ||
+    toolNames.has(TASK_UPDATE_TOOL_NAME) ||
+    toolNames.has(TASK_LIST_TOOL_NAME)
+  ) {
     prompt += TASK_MANAGEMENT_POLICY;
   }
-  if (toolNames.has(ASK_USER_QUESTION_TOOL_NAME)) {
-    prompt += ASK_USER_POLICY;
+
+  for (const tool of tools) {
+    if (tool.prompt) {
+      prompt += tool.prompt();
+    }
   }
 
-  if (toolNames.has(TASK_TOOL_NAME)) {
-    prompt += SUBAGENT_POLICY;
+  if (options.language) {
+    prompt += `\n\n# Language\nAlways respond in ${options.language}. Technical terms (e.g., code, tool names, file paths) should remain in their original language or English where appropriate.`;
   }
 
-  if (
-    toolNames.has(READ_TOOL_NAME) ||
-    toolNames.has(EDIT_TOOL_NAME) ||
-    toolNames.has(MULTI_EDIT_TOOL_NAME) ||
-    toolNames.has(WRITE_TOOL_NAME) ||
-    toolNames.has(LS_TOOL_NAME) ||
-    toolNames.has(GLOB_TOOL_NAME) ||
-    toolNames.has(GREP_TOOL_NAME)
-  ) {
-    const parts: string[] = [];
-    if (toolNames.has(READ_TOOL_NAME)) {
-      parts.push(READ_FILE_POLICY);
-    }
-    if (toolNames.has(EDIT_TOOL_NAME) || toolNames.has(MULTI_EDIT_TOOL_NAME)) {
-      parts.push(EDIT_FILE_POLICY);
-    }
-    if (toolNames.has(WRITE_TOOL_NAME)) {
-      parts.push(WRITE_FILE_POLICY);
-    }
-    if (
-      toolNames.has(LS_TOOL_NAME) ||
-      toolNames.has(GLOB_TOOL_NAME) ||
-      toolNames.has(GREP_TOOL_NAME)
-    ) {
-      parts.push(SEARCH_FILE_POLICY);
-    }
+  if (options.planMode) {
+    prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists)}`;
+  }
 
-    if (parts.length > 0) {
-      prompt += FILE_TOOL_POLICY_PREFIX + parts.join(",") + ".";
-    }
+  if (options.workdir) {
+    prompt += `
+
+Here is useful information about the environment you are running in:
+<env>
+Working directory: ${options.workdir}
+Is directory a git repo: ${options.isGitRepo || "No"}
+Platform: ${options.platform || ""}
+OS Version: ${options.osVersion || ""}
+Today's date: ${options.today || new Date().toISOString().split("T")[0]}
+</env>
+`;
   }
 
-  if (toolNames.has(BASH_TOOL_NAME)) {
-    prompt += BASH_POLICY;
+  if (options.memory && options.memory.trim()) {
+    prompt += `\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${options.memory}`;
   }
 
   return prompt;

package/src/constants/tools.ts

@@ -13,5 +13,8 @@ export const MULTI_EDIT_TOOL_NAME = "MultiEdit";
 export const READ_TOOL_NAME = "Read";
 export const SKILL_TOOL_NAME = "Skill";
 export const TASK_TOOL_NAME = "Task";
-export const TODO_WRITE_TOOL_NAME = "TodoWrite";
+export const TASK_CREATE_TOOL_NAME = "TaskCreate";
+export const TASK_GET_TOOL_NAME = "TaskGet";
+export const TASK_UPDATE_TOOL_NAME = "TaskUpdate";
+export const TASK_LIST_TOOL_NAME = "TaskList";
 export const WRITE_TOOL_NAME = "Write";

package/src/index.ts

@@ -30,6 +30,7 @@ export * from "./utils/promptHistory.js";
 export * from "./utils/stringUtils.js";
 export * from "./utils/customCommands.js";
 export * from "./utils/hookMatcher.js";
+export * from "./utils/tokenCalculation.js";
 
 // Export types
 export * from "./types/index.js";

package/src/managers/aiManager.ts

@@ -1,11 +1,13 @@
+import * as os from "node:os";
+import * as path from "node:path";
 import {
   callAgent,
   compressMessages,
   type CallAgentOptions,
 } from "../services/aiService.js";
-import { getMessagesToCompress } from "../utils/messageOperations.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
+import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import type {
   Logger,
@@ -21,10 +23,24 @@ import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { HookManager } from "./hookManager.js";
 import type { ExtendedHookExecutionContext } from "../types/hooks.js";
 import type { PermissionManager } from "./permissionManager.js";
-import {
-  DEFAULT_SYSTEM_PROMPT,
-  buildSystemPrompt,
-} from "../constants/prompts.js";
+import { buildSystemPrompt } from "../constants/prompts.js";
+
+function isGitRepository(dirPath: string): string {
+  try {
+    // Check if .git directory exists in current directory or any parent directory
+    let currentPath = path.resolve(dirPath);
+    while (currentPath !== path.dirname(currentPath)) {
+      const gitPath = path.join(currentPath, ".git");
+      if (fsSync.existsSync(gitPath)) {
+        return "Yes";
+      }
+      currentPath = path.dirname(currentPath);
+    }
+    return "No";
+  } catch {
+    return "No";
+  }
+}
 
 export interface AIManagerCallbacks {
   onCompressionStateChange?: (isCompressing: boolean) => void;
@@ -34,6 +50,7 @@ export interface AIManagerCallbacks {
 export interface AIManagerOptions {
   messageManager: MessageManager;
   toolManager: ToolManager;
+  taskManager: import("../services/taskManager.js").TaskManager;
   logger?: Logger;
   backgroundTaskManager?: BackgroundTaskManager;
   hookManager?: HookManager;
@@ -60,6 +77,7 @@ export class AIManager {
   private logger?: Logger;
   private toolManager: ToolManager;
   private messageManager: MessageManager;
+  private taskManager: import("../services/taskManager.js").TaskManager;
   private backgroundTaskManager?: BackgroundTaskManager;
   private hookManager?: HookManager;
   private reversionManager?: import("./reversionManager.js").ReversionManager;
@@ -79,6 +97,7 @@ export class AIManager {
   constructor(options: AIManagerOptions) {
     this.messageManager = options.messageManager;
     this.toolManager = options.toolManager;
+    this.taskManager = options.taskManager;
     this.backgroundTaskManager = options.backgroundTaskManager;
     this.hookManager = options.hookManager;
     this.reversionManager = options.reversionManager;
@@ -159,15 +178,6 @@ export class AIManager {
     this.setIsLoading(false);
   }
 
-  /**
-   * Abort the AI recursion loop immediately.
-   * This is used when a tool is backgrounded via Ctrl-B, even if no foreground task was active.
-   */
-  public abortRecursion(): void {
-    this.logger?.info("Aborting AI recursion loop");
-    this.abortAIMessage();
-  }
-
   // Helper method to generate compactParams
   private generateCompactParams(
     toolName: string,
@@ -180,6 +190,7 @@ export class AIManager {
       if (toolPlugin?.formatCompactParams) {
         const context: ToolContext = {
           workdir: this.workdir,
+          taskManager: this.taskManager,
         };
         return toolPlugin.formatCompactParams(toolArgs, context);
       }
@@ -213,9 +224,7 @@ export class AIManager {
       );
 
       // Check if messages need compression
-      const { messagesToCompress, insertIndex } = getMessagesToCompress(
-        this.messageManager.getMessages(),
-      );
+      const messagesToCompress = this.messageManager.getMessages();
 
       // If there are messages to compress, perform compression
       if (messagesToCompress.length > 0) {
@@ -248,7 +257,6 @@ export class AIManager {
 
           // Execute message reconstruction and sessionId update after compression
           this.messageManager.compressMessagesAndUpdateSession(
-            insertIndex,
             compressionResult.content,
             compressionUsage,
           );
@@ -305,6 +313,9 @@ export class AIManager {
       return;
     }
 
+    // Save session in each recursion to ensure message persistence
+    await this.messageManager.saveSession();
+
     // Only create new AbortControllers for the initial call (recursionDepth === 0)
     // For recursive calls, reuse existing controllers to maintain abort signal
     let abortController: AbortController;
@@ -319,14 +330,10 @@ export class AIManager {
       this.toolAbortController = toolAbortController;
     } else {
       // Reuse existing controllers for recursive calls
-      // Fallback to new controllers if they were cleared (should not happen in normal flow but good for tests)
-      abortController = this.abortController || new AbortController();
-      toolAbortController = this.toolAbortController || new AbortController();
+      abortController = this.abortController!;
+      toolAbortController = this.toolAbortController!;
     }
 
-    // Save session in each recursion to ensure message persistence
-    await this.messageManager.saveSession();
-
     // Only set loading state for the initial call
     if (recursionDepth === 0) {
       this.setIsLoading(true);
@@ -354,17 +361,14 @@ export class AIManager {
         this.getModelConfig().permissionMode,
       );
       const toolsConfig = this.getFilteredToolsConfig(tools);
-      let effectiveSystemPrompt = buildSystemPrompt(
-        this.systemPrompt || DEFAULT_SYSTEM_PROMPT,
-        toolsConfig,
-      );
+      const toolNames = new Set(toolsConfig.map((t) => t.function.name));
+      const filteredToolPlugins = this.toolManager
+        .getTools()
+        .filter((t) => toolNames.has(t.name));
 
-      // Inject language prompt if configured
-      const language = this.getLanguage();
-      if (language) {
-        const languagePrompt = `\n\n# Language\nAlways respond in ${language}. Technical terms (e.g., code, tool names, file paths) should remain in their original language or English where appropriate.`;
-        effectiveSystemPrompt = (effectiveSystemPrompt || "") + languagePrompt;
-      }
+      let planModeOptions:
+        | { planFilePath: string; planExists: boolean }
+        | undefined;
 
       if (currentMode === "plan") {
         const planFilePath = this.permissionManager?.getPlanFilePath();
@@ -376,10 +380,7 @@ export class AIManager {
           } catch {
             planExists = false;
           }
-
-          const reminder = `\n\nPlan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received.\n\n## Plan File Info:\n${planExists ? `A plan file already exists at ${planFilePath}. You can read it and make incremental edits using the Edit tool if you need to.` : `No plan file exists yet. You should create your plan at ${planFilePath} using the Write tool if you need to.`}\nYou should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit - other than this you are only allowed to take READ-ONLY actions. You may also use the AskUserQuestion tool to gather requirements or clarify intent before finalizing your plan.`;
-
-          effectiveSystemPrompt = (effectiveSystemPrompt || "") + reminder;
+          planModeOptions = { planFilePath, planExists };
         }
       }
 
@@ -390,11 +391,23 @@ export class AIManager {
         messages: recentMessages,
         sessionId: this.messageManager.getSessionId(),
         abortSignal: abortController.signal,
-        memory: combinedMemory, // Pass combined memory content
         workdir: this.workdir, // Pass working directory
         tools: toolsConfig, // Pass filtered tool configuration
         model: model, // Use passed model
-        systemPrompt: effectiveSystemPrompt, // Pass custom system prompt
+        systemPrompt: buildSystemPrompt(
+          this.systemPrompt,
+          filteredToolPlugins,
+          {
+            workdir: this.workdir,
+            isGitRepo: isGitRepository(this.workdir),
+            platform: os.platform(),
+            osVersion: `${os.type()} ${os.release()}`,
+            today: new Date().toISOString().split("T")[0],
+            memory: combinedMemory,
+            language: this.getLanguage(),
+            planMode: planModeOptions,
+          },
+        ), // Pass custom system prompt
         maxTokens: maxTokens, // Pass max tokens override
       };
 
@@ -628,6 +641,8 @@ export class AIManager {
                 backgroundTaskManager: this.backgroundTaskManager,
                 workdir: this.workdir,
                 messageId: this.messageManager.getMessages().slice(-1)[0]?.id,
+                sessionId: this.messageManager.getSessionId(),
+                taskManager: this.taskManager,
               };
 
               // Execute tool
@@ -637,23 +652,6 @@ export class AIManager {
                 context,
               );
 
-              // Check if the tool was backgrounded via Ctrl-B
-              // If it was backgrounded, we should abort the AI recursion
-              if (
-                toolResult.success &&
-                toolResult.content.includes(
-                  "Command was manually backgrounded by user",
-                )
-              ) {
-                this.logger?.info(
-                  `Tool ${toolName} was backgrounded via Ctrl-B, aborting AI recursion`,
-                );
-                // Use abortAIMessage directly instead of abortRecursion to avoid double logging
-                // and ensure we don't trigger the "Request was aborted" error block
-                this.abortAIMessage();
-                return;
-              }
-
               // Update message state - tool execution completed
               this.messageManager.updateToolBlock({
                 id: toolId,
@@ -666,6 +664,7 @@ export class AIManager {
                 stage: "end",
                 name: toolName,
                 shortResult: toolResult.shortResult,
+                isManuallyBackgrounded: toolResult.isManuallyBackgrounded,
               });
 
               // Execute PostToolUse hooks after successful tool completion
@@ -690,6 +689,7 @@ export class AIManager {
                 stage: "end",
                 name: toolName,
                 compactParams,
+                isManuallyBackgrounded: false,
               });
             }
           },
@@ -721,7 +721,25 @@ export class AIManager {
         const isCurrentlyAborted =
           abortController.signal.aborted || toolAbortController.signal.aborted;
 
-        if (!isCurrentlyAborted) {
+        // Check if all tools were manually backgrounded
+        const lastMessage =
+          this.messageManager.getMessages()[
+            this.messageManager.getMessages().length - 1
+          ];
+        const toolBlocks =
+          lastMessage?.blocks.filter(
+            (block): block is import("../types/messaging.js").ToolBlock =>
+              block.type === "tool",
+          ) || [];
+        const hasBackgrounded =
+          toolBlocks.length > 0 &&
+          toolBlocks.some((block) => block.isManuallyBackgrounded);
+
+        if (hasBackgrounded) {
+          this.logger?.info(
+            "Some tools were manually backgrounded, stopping recursion.",
+          );
+        } else if (!isCurrentlyAborted) {
           // Recursively call AI service, increment recursion depth, and pass same configuration
           await this.sendAIMessage({
             recursionDepth: recursionDepth + 1,
@@ -733,18 +751,9 @@ export class AIManager {
         }
       }
     } catch (error) {
-      // Check if the error is an abort error
-      // Use the local variables to avoid null reference if this.abortController was cleared
-      const isCurrentlyAborted =
-        abortController.signal.aborted || toolAbortController.signal.aborted;
-
-      if (isCurrentlyAborted) {
-        this.logger?.info("AI message processing was aborted");
-      } else {
-        this.messageManager.addErrorBlock(
-          error instanceof Error ? error.message : "Unknown error occurred",
-        );
-      }
+      this.messageManager.addErrorBlock(
+        error instanceof Error ? error.message : "Unknown error occurred",
+      );
     } finally {
       // Only execute cleanup and hooks for the initial call
       if (recursionDepth === 0) {