wave-agent-sdk 0.6.1 → 0.6.2

package/src/{constants/prompts.ts → prompts/index.ts}

@@ -1,4 +1,10 @@
+import * as os from "node:os";
 import { ToolPlugin } from "../tools/types.js";
+import { isGitRepository } from "../utils/gitUtils.js";
+import {
+  EXPLORE_SUBAGENT_TYPE,
+  PLAN_SUBAGENT_TYPE,
+} from "../constants/subagents.js";
 import {
   ASK_USER_QUESTION_TOOL_NAME,
   BASH_TOOL_NAME,
@@ -11,7 +17,8 @@ import {
   TASK_UPDATE_TOOL_NAME,
   TASK_LIST_TOOL_NAME,
   WRITE_TOOL_NAME,
-} from "./tools.js";
+  EXIT_PLAN_MODE_TOOL_NAME,
+} from "../constants/tools.js";
 
 export const BASE_SYSTEM_PROMPT = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
 
@@ -39,17 +46,90 @@ It is critical that you mark tasks as completed as soon as you are done with a t
 export function buildPlanModePrompt(
   planFilePath: string,
   planExists: boolean,
+  isSubagent: boolean = false,
 ): 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.`;
 
-  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:
+  if (isSubagent) {
+    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:
+
+## 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, using the ${ASK_USER_QUESTION_TOOL_NAME} tool if you need to ask the user clarifying questions. If you do use the ${ASK_USER_QUESTION_TOOL_NAME}, make sure to ask all clarifying questions you need to fully understand the user's intent before proceeding.`;
+  }
+
+  return `Plan 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.
 
 ## 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.`;
+
+## Plan Workflow
+
+### Phase 1: Initial Understanding
+Goal: Gain a comprehensive understanding of the user's request by reading through code and asking them questions. Critical: In this phase you should only use the Task subagent type with subagent_type=${EXPLORE_SUBAGENT_TYPE}.
+
+1. Focus on understanding the user's request and the code associated with their request. Actively search for existing functions, utilities, and patterns that can be reused — avoid proposing new code when suitable implementations already exist.
+
+2. **Launch up to 3 ${EXPLORE_SUBAGENT_TYPE} agents IN PARALLEL** (single message, multiple tool calls) to efficiently explore the codebase.
+   - Use 1 agent when the task is isolated to known files, the user provided specific file paths, or you're making a small targeted change.
+   - Use multiple agents when: the scope is uncertain, multiple areas of the codebase are involved, or you need to understand existing patterns before planning.
+   - Quality over quantity - 3 agents maximum, but you should try to use the minimum number of agents necessary (usually just 1)
+   - If using multiple agents: Provide each agent with a specific search focus or area to explore. Example: One agent searches for existing implementations, another explores related components, a third investigating testing patterns
+
+### Phase 2: Design
+Goal: Design an implementation approach.
+
+Launch Task agent(s) with subagent_type=${PLAN_SUBAGENT_TYPE} to design the implementation based on the user's intent and your exploration results from Phase 1.
+
+You can launch up to 3 agent(s) in parallel.
+
+**Guidelines:**
+- **Default**: Launch at least 1 Plan agent for most tasks - it helps validate your understanding and consider alternatives
+- **Skip agents**: Only for truly trivial tasks (typo fixes, single-line changes, simple renames)
+- **Multiple agents**: Use up to 3 agents for complex tasks that benefit from different perspectives
+
+Examples of when to use multiple agents:
+- The task touches multiple parts of the codebase
+- It's a large refactor or architectural change
+- There are many edge cases to consider
+- You'd benefit from exploring different approaches
+
+Example perspectives by task type:
+- New feature: simplicity vs performance vs maintainability
+- Bug fix: root cause vs workaround vs prevention
+- Refactoring: minimal change vs clean architecture
+
+In the agent prompt:
+- Provide comprehensive background context from Phase 1 exploration including filenames and code path traces
+- Describe requirements and constraints
+- Request a detailed implementation plan
+
+### Phase 3: Review
+Goal: Review the plan(s) from Phase 2 and ensure alignment with the user's intentions.
+1. Read the critical files identified by agents to deepen your understanding
+2. Ensure that the plans align with the user's original request
+3. Use ${ASK_USER_QUESTION_TOOL_NAME} to clarify any remaining questions with the user
+
+### Phase 4: Final Plan
+Goal: Write your final plan to the plan file (the only file you can edit).
+- Begin with a **Context** section: explain why this change is being made — the problem or need it addresses, what prompted it, and the intended outcome
+- Include only your recommended approach, not all alternatives
+- Ensure that the plan file is concise enough to scan quickly, but detailed enough to execute effectively
+- Include the paths of critical files to be modified
+- Reference existing functions and utilities you found that should be reused, with their file paths
+- Include a verification section describing how to test the changes end-to-end (run the code, use MCP tools, run tests)
+
+### Phase 5: Call ${EXIT_PLAN_MODE_TOOL_NAME}
+At the very end of your turn, once you have asked the user questions and are happy with your final plan file - you should always call ${EXIT_PLAN_MODE_TOOL_NAME} to indicate to the user that you are done planning.
+This is critical - your turn should only end with either using the ${ASK_USER_QUESTION_TOOL_NAME} tool OR calling ${EXIT_PLAN_MODE_TOOL_NAME}. Do not stop unless it's for these 2 reasons
+
+**Important:** Use ${ASK_USER_QUESTION_TOOL_NAME} ONLY to clarify requirements or choose between approaches. Use ${EXIT_PLAN_MODE_TOOL_NAME} to request plan approval. Do NOT ask about plan approval in any other way - no text questions, no AskUserQuestion. Phrases like "Is this plan okay?", "Should I proceed?", "How does this plan look?", "Any changes before we start?", or similar MUST use ${EXIT_PLAN_MODE_TOOL_NAME}.
+
+NOTE: At any point in time through this workflow you should feel free to ask the user questions or clarifications using the ${ASK_USER_QUESTION_TOOL_NAME} tool. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.`;
 }
 
 export const DEFAULT_SYSTEM_PROMPT = BASE_SYSTEM_PROMPT;
@@ -84,6 +164,44 @@ 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 EXPLORE_SUBAGENT_SYSTEM_PROMPT = `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
+	
+	=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
+	This is a READ-ONLY exploration 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 search and analyze existing code. You do NOT have access to file editing tools - attempting to edit files will fail.
+	
+	Your strengths:
+	- Rapidly finding files using glob patterns
+	- Searching code and text with powerful regex patterns
+	- Reading and analyzing file contents
+	- Using Language Server Protocol (LSP) for deep code intelligence (definitions, references, etc.)
+	
+	Guidelines:
+	- Use ${GLOB_TOOL_NAME} for broad file pattern matching
+	- Use ${GREP_TOOL_NAME} for searching file contents with regex
+	- Use ${READ_TOOL_NAME} when you know the specific file path you need to read
+	- Use LSP for code intelligence features like finding definitions, references, implementations, and symbols. This is especially useful for understanding complex code relationships.
+	- 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
+	- Adapt your search approach based on the thoroughness level specified by the caller
+	- Return file paths as absolute paths in your final response
+	- For clear communication, avoid using emojis
+	- Communicate your final report directly as a regular message - do NOT attempt to create files
+	
+	NOTE: You are meant to be a fast agent that returns output as quickly as possible. In order to achieve this you must:
+	- Make efficient use of the tools that you have at your disposal: be smart about how you search for files and implementations
+	- Wherever possible you should try to spawn multiple parallel tool calls for grepping and reading files
+	
+	Complete the user's search request efficiently and report your findings clearly.`;
+
 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 ===
@@ -186,12 +304,9 @@ export function buildSystemPrompt(
   tools: ToolPlugin[],
   options: {
     workdir?: string;
-    isGitRepo?: string;
-    platform?: string;
-    osVersion?: string;
-    today?: string;
     memory?: string;
     language?: string;
+    isSubagent?: boolean;
     planMode?: {
       planFilePath: string;
       planExists: boolean;
@@ -221,19 +336,24 @@ export function buildSystemPrompt(
   }
 
   if (options.planMode) {
-    prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists)}`;
+    prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists, options.isSubagent)}`;
   }
 
   if (options.workdir) {
+    const isGitRepo = isGitRepository(options.workdir);
+    const platform = os.platform();
+    const osVersion = `${os.type()} ${os.release()}`;
+    const today = new Date().toISOString().split("T")[0];
+
     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]}
+Is directory a git repo: ${isGitRepo}
+Platform: ${platform}
+OS Version: ${osVersion}
+Today's date: ${today}
 </env>
 `;
   }

package/src/services/aiService.ts

@@ -21,7 +21,7 @@ import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
 
-import { COMPRESS_MESSAGES_SYSTEM_PROMPT } from "../constants/prompts.js";
+import { COMPRESS_MESSAGES_SYSTEM_PROMPT } from "../prompts/index.js";
 
 /**
  * Interface for debug data saved during 400 errors

package/src/services/taskManager.ts

@@ -27,7 +27,7 @@ export class TaskManager extends EventEmitter {
     return join(this.baseDir, this.taskListId);
   }
 
-  private getTaskPath(taskId: string): string {
+  public getTaskPath(taskId: string): string {
     return join(this.getSessionDir(), `${taskId}.json`);
   }
 
@@ -185,4 +185,11 @@ export class TaskManager extends EventEmitter {
 
     return (Math.max(...ids) + 1).toString();
   }
+
+  /**
+   * Refreshes the task list by re-reading tasks from disk and emitting a change event.
+   */
+  public async refreshTasks(): Promise<void> {
+    this.emit("tasksChange", this.taskListId);
+  }
 }

package/src/tools/bashTool.ts

@@ -306,13 +306,17 @@ Usage notes:
 
       child.stdout?.on("data", (data) => {
         if (!isAborted && !isBackgrounded) {
-          outputBuffer += stripAnsiColors(data.toString());
+          const chunk = stripAnsiColors(data.toString());
+          outputBuffer += chunk;
+          context.onShortResultUpdate?.(chunk.trim().split("\n").pop() || "");
         }
       });
 
       child.stderr?.on("data", (data) => {
         if (!isAborted && !isBackgrounded) {
-          errorBuffer += stripAnsiColors(data.toString());
+          const chunk = stripAnsiColors(data.toString());
+          errorBuffer += chunk;
+          context.onShortResultUpdate?.(chunk.trim().split("\n").pop() || "");
         }
       });
 

package/src/tools/exitPlanMode.ts

@@ -93,7 +93,7 @@ Ensure your plan is complete and unambiguous:
       if (permissionResult.behavior === "deny") {
         return {
           success: false,
-          content: permissionResult.message || "Plan rejected by user",
+          content: `User feedback: ${permissionResult.message || "Plan rejected by user"}. Please update your proposal accordingly.`,
           error: permissionResult.message ? undefined : "Plan rejected by user",
         };
       }

package/src/tools/taskManagementTools.ts

@@ -114,6 +114,15 @@ NOTE that you should not use this tool if there is only one trivial task to do.
 
     const taskId = await taskManager.createTask(task);
 
+    if (context.reversionManager && context.messageId) {
+      const taskPath = taskManager.getTaskPath(taskId);
+      await context.reversionManager.recordSnapshot(
+        context.messageId,
+        taskPath,
+        "create",
+      );
+    }
+
     return {
       success: true,
       content: `Task created with ID: ${taskId}`,
@@ -324,6 +333,15 @@ Set up task dependencies:
       };
     }
 
+    if (context.reversionManager && context.messageId) {
+      const taskPath = taskManager.getTaskPath(taskId);
+      await context.reversionManager.recordSnapshot(
+        context.messageId,
+        taskPath,
+        "modify",
+      );
+    }
+
     const updatedFields: string[] = [];
 
     const updatedTask: Task = {

package/src/tools/taskTool.ts

@@ -1,5 +1,6 @@
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import type { SubagentManager } from "../managers/subagentManager.js";
+import { EXPLORE_SUBAGENT_TYPE } from "../constants/subagents.js";
 import { TASK_TOOL_NAME } from "../constants/tools.js";
 
 /**
@@ -61,7 +62,7 @@ export function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
     prompt: () => `
 - 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.`,
+- 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_SUBAGENT_TYPE} instead of running search commands directly.`,
 
     execute: async (
       args: Record<string, unknown>,
@@ -120,6 +121,36 @@ export function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
               });
             }
 
+            // Set up callback to update shortResult with tool names, tool count and tokens
+            const updateShortResult = () => {
+              const messages = instance.messageManager.getMessages();
+              const tokens = instance.messageManager.getlatestTotalTokens();
+              const lastTools = instance.lastTools;
+
+              // Count tool blocks in messages
+              let toolCount = 0;
+              messages.forEach((msg) => {
+                msg.blocks.forEach((block) => {
+                  if (block.type === "tool") {
+                    toolCount++;
+                  }
+                });
+              });
+
+              let shortResult = "";
+              if (lastTools.length > 0) {
+                shortResult += `${lastTools.join(", ")} `;
+              }
+
+              shortResult += `(${toolCount} tools`;
+              if (tokens > 0) {
+                shortResult += ` | ${tokens.toLocaleString()} tokens`;
+              }
+              shortResult += ")";
+
+              context.onShortResultUpdate?.(shortResult);
+            };
+
             // Create subagent instance and execute task
             const instance = await subagentManager.createInstance(
               configuration,
@@ -129,8 +160,12 @@ export function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
                 subagent_type,
               },
               run_in_background,
+              updateShortResult,
             );
 
+            // Initial update
+            updateShortResult();
+
             let isBackgrounded = false;
 
             // Register for backgrounding if not already in background
@@ -171,6 +206,9 @@ export function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
                 });
               }
 
+              // Cleanup subagent instance after task completion
+              subagentManager.cleanupInstance(instance.subagentId);
+
               return resolve({
                 success: true,
                 content: result,

package/src/tools/types.ts

@@ -67,4 +67,6 @@ export interface ToolContext {
   taskManager: import("../services/taskManager.js").TaskManager;
   /** Current session ID */
   sessionId?: string;
+  /** Callback to update the short result of the current tool block */
+  onShortResultUpdate?: (shortResult: string) => void;
 }

package/src/types/messaging.ts

@@ -4,7 +4,6 @@
  */
 
 import type { Usage } from "./core.js";
-import type { SubagentConfiguration } from "../utils/subagentParser.js";
 
 export enum MessageSource {
   USER = "user",
@@ -26,7 +25,6 @@ export type MessageBlock =
   | ImageBlock
   | CommandOutputBlock
   | CompressBlock
-  | SubagentBlock
   | ReasoningBlock
   | FileHistoryBlock;
 
@@ -88,16 +86,6 @@ export interface CompressBlock {
   sessionId: string;
 }
 
-export interface SubagentBlock {
-  type: "subagent";
-  subagentId: string;
-  subagentName: string;
-  status: "active" | "completed" | "error" | "aborted";
-  sessionId: string;
-  configuration: SubagentConfiguration;
-  runInBackground?: boolean;
-}
-
 export interface ReasoningBlock {
   type: "reasoning";
   content: string;

package/src/types/processes.ts

@@ -29,6 +29,11 @@ export interface BackgroundTaskBase {
    * This allows tasks to define their own cleanup/abortion logic.
    */
   onStop?: () => void | Promise<void>;
+  /**
+   * Optional subagent ID associated with this task.
+   * Used for cleanup when the task is stopped.
+   */
+  subagentId?: string;
 }
 
 export interface BackgroundShell extends BackgroundTaskBase {

package/src/utils/builtinSubagents.ts

@@ -1,9 +1,23 @@
+import {
+  BASH_SUBAGENT_TYPE,
+  EXPLORE_SUBAGENT_TYPE,
+  PLAN_SUBAGENT_TYPE,
+  GENERAL_PURPOSE_SUBAGENT_TYPE,
+} from "../constants/subagents.js";
 import {
   BASH_SUBAGENT_SYSTEM_PROMPT,
   GENERAL_PURPOSE_SYSTEM_PROMPT,
   PLAN_SUBAGENT_SYSTEM_PROMPT,
-} from "../constants/prompts.js";
-import { BASH_TOOL_NAME } from "../constants/tools.js";
+  EXPLORE_SUBAGENT_SYSTEM_PROMPT,
+} from "../prompts/index.js";
+import {
+  BASH_TOOL_NAME,
+  GLOB_TOOL_NAME,
+  GREP_TOOL_NAME,
+  READ_TOOL_NAME,
+  LS_TOOL_NAME,
+  LSP_TOOL_NAME,
+} from "../constants/tools.js";
 import type { SubagentConfiguration } from "./subagentParser.js";
 
 /**
@@ -26,13 +40,13 @@ export function getBuiltinSubagents(): SubagentConfiguration[] {
  */
 function createBashSubagent(): SubagentConfiguration {
   return {
-    name: "Bash",
+    name: BASH_SUBAGENT_TYPE,
     description:
       "Command execution specialist for running bash commands. Use this for git operations, command execution, and other terminal tasks.",
     systemPrompt: BASH_SUBAGENT_SYSTEM_PROMPT,
     tools: [BASH_TOOL_NAME],
     model: "inherit",
-    filePath: "<builtin:Bash>",
+    filePath: `<builtin:${BASH_SUBAGENT_TYPE}>`,
     scope: "builtin",
     priority: 3,
   };
@@ -44,11 +58,11 @@ function createBashSubagent(): SubagentConfiguration {
  */
 function createGeneralPurposeSubagent(): SubagentConfiguration {
   return {
-    name: "general-purpose",
+    name: GENERAL_PURPOSE_SUBAGENT_TYPE,
     description:
       "General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you.",
     systemPrompt: GENERAL_PURPOSE_SYSTEM_PROMPT,
-    filePath: "<builtin:general-purpose>",
+    filePath: `<builtin:${GENERAL_PURPOSE_SUBAGENT_TYPE}>`,
     scope: "builtin",
     priority: 3,
   };
@@ -59,55 +73,24 @@ function createGeneralPurposeSubagent(): SubagentConfiguration {
  * Specialized for codebase exploration and file search tasks
  */
 function createExploreSubagent(): SubagentConfiguration {
-  const systemPrompt = `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
-
-=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
-This is a READ-ONLY exploration 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 search and analyze existing code. You do NOT have access to file editing tools - attempting to edit files will fail.
-
-Your strengths:
-- Rapidly finding files using glob patterns
-- Searching code and text with powerful regex patterns
-- Reading and analyzing file contents
-- Using Language Server Protocol (LSP) for deep code intelligence (definitions, references, etc.)
-
-Guidelines:
-- Use Glob for broad file pattern matching
-- Use Grep for searching file contents with regex
-- Use Read when you know the specific file path you need to read
-- Use LSP for code intelligence features like finding definitions, references, implementations, and symbols. This is especially useful for understanding complex code relationships.
-- Use Bash ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)
-- NEVER use Bash for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification
-- Adapt your search approach based on the thoroughness level specified by the caller
-- Return file paths as absolute paths in your final response
-- For clear communication, avoid using emojis
-- Communicate your final report directly as a regular message - do NOT attempt to create files
-
-NOTE: You are meant to be a fast agent that returns output as quickly as possible. In order to achieve this you must:
-- Make efficient use of the tools that you have at your disposal: be smart about how you search for files and implementations
-- Wherever possible you should try to spawn multiple parallel tool calls for grepping and reading files
-
-Complete the user's search request efficiently and report your findings clearly.`;
-
   // Define allowed tools for read-only operations
-  const allowedTools = ["Glob", "Grep", "Read", "Bash", "LS", "LSP"];
+  const allowedTools = [
+    GLOB_TOOL_NAME,
+    GREP_TOOL_NAME,
+    READ_TOOL_NAME,
+    BASH_TOOL_NAME,
+    LS_TOOL_NAME,
+    LSP_TOOL_NAME,
+  ];
 
   return {
-    name: "Explore",
+    name: EXPLORE_SUBAGENT_TYPE,
     description:
       'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.',
-    systemPrompt,
+    systemPrompt: EXPLORE_SUBAGENT_SYSTEM_PROMPT,
     tools: allowedTools,
     model: "fastModel", // Special value that will use parent's fastModel
-    filePath: "<builtin:Explore>",
+    filePath: `<builtin:${EXPLORE_SUBAGENT_TYPE}>`,
     scope: "builtin",
     priority: 3, // Lowest priority - can be overridden by user configs
   };
@@ -119,16 +102,23 @@ Complete the user's search request efficiently and report your findings clearly.
  */
 function createPlanSubagent(): SubagentConfiguration {
   // Define allowed tools for read-only operations
-  const allowedTools = ["Glob", "Grep", "Read", "Bash", "LS", "LSP"];
+  const allowedTools = [
+    GLOB_TOOL_NAME,
+    GREP_TOOL_NAME,
+    READ_TOOL_NAME,
+    BASH_TOOL_NAME,
+    LS_TOOL_NAME,
+    LSP_TOOL_NAME,
+  ];
 
   return {
-    name: "Plan",
+    name: PLAN_SUBAGENT_TYPE,
     description:
       "Software architect agent for designing implementation plans. Use this when you need to plan the implementation strategy for a task. Returns step-by-step plans, identifies critical files, and considers architectural trade-offs.",
     systemPrompt: PLAN_SUBAGENT_SYSTEM_PROMPT,
     tools: allowedTools,
     model: "inherit", // Uses parent agent's model
-    filePath: "<builtin:Plan>",
+    filePath: `<builtin:${PLAN_SUBAGENT_TYPE}>`,
     scope: "builtin",
     priority: 3, // Lowest priority - can be overridden by user configs
   };

package/src/utils/editUtils.ts

@@ -77,12 +77,8 @@ export function analyzeEditMismatch(
     if (actualLine === expectedLine) {
       reportLines.push(`${lineNum.toString().padStart(4)} | ${actualLine}`);
     } else {
-      reportLines.push(
-        `${lineNum.toString().padStart(4)} | - ${expectedLine} (expected)`,
-      );
-      reportLines.push(
-        `${lineNum.toString().padStart(4)} | + ${actualLine} (actual)`,
-      );
+      reportLines.push(`${lineNum.toString().padStart(4)} | - ${expectedLine}`);
+      reportLines.push(`${lineNum.toString().padStart(4)} | + ${actualLine}`);
     }
   }
 

package/src/utils/gitUtils.ts

@@ -0,0 +1,24 @@
+import * as path from "node:path";
+import * as fsSync from "node:fs";
+
+/**
+ * Check if a directory is a git repository
+ * @param dirPath Directory path
+ * @returns "Yes" if it's a git repository, "No" otherwise
+ */
+export 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";
+  }
+}