wave-agent-sdk 0.5.0 → 0.6.2

package/src/tools/taskOutputTool.ts

@@ -10,38 +10,47 @@ export const taskOutputTool: ToolPlugin = {
     type: "function",
     function: {
       name: TASK_OUTPUT_TOOL_NAME,
-      description:
-        "Retrieves output from a running or completed background task",
+      description: "Retrieves output from a running or completed task",
       parameters: {
         type: "object",
         properties: {
           task_id: {
             type: "string",
-            description:
-              "The ID of the background task to retrieve output from",
-          },
-          filter: {
-            type: "string",
-            description:
-              "Optional regular expression to filter the output lines.",
+            description: "The task ID to get output from",
           },
           block: {
             type: "boolean",
-            description:
-              "If true, wait for the task to complete before returning output. If false, return current output immediately.",
+            default: true,
+            description: "Whether to wait for completion",
+          },
+          timeout: {
+            type: "number",
+            minimum: 0,
+            maximum: 600000,
+            default: 30000,
+            description: "Max wait time in ms",
           },
         },
         required: ["task_id"],
       },
     },
   },
+  prompt:
+    () => `- Retrieves output from a running or completed task (background shell, agent, or remote session)
+- Takes a task_id parameter identifying the task
+- Returns the task output along with status information
+- Use block=true (default) to wait for task completion
+- Use block=false for non-blocking check of current status
+- Task IDs can be found using the /tasks command
+- Works with all task types: background shells, async agents, and remote sessions`,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,
   ): Promise<ToolResult> => {
     const taskId = args.task_id as string;
     const filter = args.filter as string | undefined;
-    const block = args.block as boolean | undefined;
+    const block = (args.block as boolean | undefined) ?? true;
+    const timeout = (args.timeout as number | undefined) ?? 30000;
 
     if (!taskId || typeof taskId !== "string") {
       return {
@@ -91,6 +100,7 @@ export const taskOutputTool: ToolPlugin = {
       return new Promise((resolve) => {
         let timeoutHandle: NodeJS.Timeout | null = null;
         let isAborted = false;
+        const startTime = Date.now();
 
         const cleanup = () => {
           if (timeoutHandle) {
@@ -122,6 +132,18 @@ export const taskOutputTool: ToolPlugin = {
         const check = () => {
           if (isAborted) return;
 
+          if (Date.now() - startTime > timeout) {
+            if (context.abortSignal) {
+              context.abortSignal.removeEventListener("abort", onAbort);
+            }
+            resolve({
+              success: true,
+              content: "Retrieval timed out",
+              shortResult: `${taskId}: timeout`,
+            });
+            return;
+          }
+
           const task = backgroundTaskManager.getTask(taskId);
           if (!task) {
             if (context.abortSignal) {

package/src/tools/taskStopTool.ts

@@ -7,7 +7,7 @@ export const taskStopTool: ToolPlugin = {
     type: "function",
     function: {
       name: TASK_STOP_TOOL_NAME,
-      description: "Stops a running background task",
+      description: "Stop a running background task by ID",
       parameters: {
         type: "object",
         properties: {
@@ -20,6 +20,12 @@ export const taskStopTool: ToolPlugin = {
       },
     },
   },
+  prompt: () => `
+- Stops a running background task by its ID
+- Takes a task_id parameter identifying the task to stop
+- Returns a success or failure status
+- Use this tool when you need to terminate a long-running task
+`,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,

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";
 
 /**
@@ -58,6 +59,11 @@ 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_SUBAGENT_TYPE} instead of running search commands directly.`,
+
     execute: async (
       args: Record<string, unknown>,
       context: ToolContext,
@@ -115,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,
@@ -124,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
@@ -140,8 +180,9 @@ export function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
                   // Resolve the tool execution early so the main agent can continue
                   resolve({
                     success: true,
-                    content: `Task moved to background with ID: ${taskId}. Use TaskOutput to monitor progress.`,
+                    content: `Task moved to background with ID: ${taskId}.`,
                     shortResult: "Task backgrounded",
+                    isManuallyBackgrounded: true,
                   });
                 },
               });
@@ -165,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

@@ -19,6 +19,10 @@ export interface ToolPlugin {
     params: Record<string, unknown>,
     context: ToolContext,
   ) => string;
+  /**
+   * Optional function to provide a prompt to be added to the system prompt
+   */
+  prompt?: () => string;
 }
 
 export interface ToolResult {
@@ -34,6 +38,8 @@ export interface ToolResult {
     data: string; // base64 encoded image data
     mediaType?: string; // Image media type, such as "image/png"
   }>;
+  // Whether the tool was manually backgrounded by the user (e.g. via Ctrl-B)
+  isManuallyBackgrounded?: boolean;
 }
 
 export interface ToolContext {
@@ -57,4 +63,10 @@ export interface ToolContext {
   messageId?: string;
   /** Foreground task manager for backgrounding tasks */
   foregroundTaskManager?: import("../types/processes.js").IForegroundTaskManager;
+  /** Task manager instance for task management */
+  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/tools/writeTool.ts

@@ -13,8 +13,7 @@ export const writeTool: ToolPlugin = {
     type: "function",
     function: {
       name: "Write",
-      description:
-        "Writes a file to the local filesystem.\n\nUsage:\n- This tool will overwrite the existing file if there is one at the provided path.\n- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.\n- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.\n- IMPORTANT: Always provide file_path parameter before content parameter when calling this tool.",
+      description: "Writes a file to the local filesystem.",
       parameters: {
         type: "object",
         properties: {
@@ -33,6 +32,14 @@ export const writeTool: ToolPlugin = {
       },
     },
   },
+  prompt: () => `
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.
+- IMPORTANT: Always provide file_path parameter before content parameter when calling this tool.`,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,

package/src/types/index.ts

@@ -33,3 +33,4 @@ export * from "./plugins.js";
 export * from "./marketplace.js";
 export * from "./memoryRule.js";
 export * from "./history.js";
+export * from "./tasks.js";

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,8 +25,6 @@ export type MessageBlock =
   | ImageBlock
   | CommandOutputBlock
   | CompressBlock
-  | MemoryBlock
-  | SubagentBlock
   | ReasoningBlock
   | FileHistoryBlock;
 
@@ -67,6 +64,7 @@ export interface ToolBlock {
   error?: string | Error;
   compactParams?: string; // Compact parameter display
   parametersChunk?: string; // Incremental parameter updates for streaming
+  isManuallyBackgrounded?: boolean; // Whether the tool was manually backgrounded by the user
 }
 
 export interface ImageBlock {
@@ -88,24 +86,6 @@ export interface CompressBlock {
   sessionId: string;
 }
 
-export interface MemoryBlock {
-  type: "memory";
-  content: string;
-  isSuccess: boolean;
-  memoryType?: "project" | "user"; // Memory type
-  storagePath?: string; // Storage path text
-}
-
-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

@@ -12,7 +12,7 @@ export type BackgroundTaskStatus =
   | "killed";
 export type BackgroundTaskType = "shell" | "subagent";
 
-export interface BackgroundTask {
+export interface BackgroundTaskBase {
   id: string;
   type: BackgroundTaskType;
   status: BackgroundTaskStatus;
@@ -24,13 +24,29 @@ export interface BackgroundTask {
   stderr: string;
   exitCode?: number;
   runtime?: number;
+  /**
+   * Optional callback to be executed when the task is stopped.
+   * 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 BackgroundTask {
+export interface BackgroundShell extends BackgroundTaskBase {
   type: "shell";
   process: ChildProcess;
 }
 
+export interface BackgroundSubagent extends BackgroundTaskBase {
+  type: "subagent";
+}
+
+export type BackgroundTask = BackgroundShell | BackgroundSubagent;
+
 export interface ForegroundTask {
   id: string;
   backgroundHandler: () => Promise<void>;
@@ -40,8 +56,3 @@ export interface IForegroundTaskManager {
   registerForegroundTask(task: ForegroundTask): void;
   unregisterForegroundTask(id: string): void;
 }
-
-export interface IForegroundTaskManager {
-  registerForegroundTask(task: ForegroundTask): void;
-  unregisterForegroundTask(id: string): void;
-}

package/src/types/tasks.ts

@@ -0,0 +1,13 @@
+export type TaskStatus = "pending" | "in_progress" | "completed" | "deleted";
+
+export interface Task {
+  id: string;
+  subject: string;
+  description: string;
+  status: TaskStatus;
+  activeForm?: string;
+  owner?: string;
+  blocks: string[];
+  blockedBy: string[];
+  metadata: Record<string, unknown>;
+}

package/src/types/tools.ts

@@ -8,7 +8,6 @@
 export interface AskUserQuestionOption {
   label: string;
   description?: string;
-  isRecommended?: boolean;
 }
 
 export interface AskUserQuestion {
@@ -20,6 +19,10 @@ export interface AskUserQuestion {
 
 export interface AskUserQuestionInput {
   questions: AskUserQuestion[];
+  answers?: Record<string, string>;
+  metadata?: {
+    source?: string;
+  };
 }
 
 /**

package/src/utils/builtinSubagents.ts

@@ -1,4 +1,23 @@
-import { GENERAL_PURPOSE_SYSTEM_PROMPT } from "../constants/prompts.js";
+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,
+  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";
 
 /**
@@ -7,23 +26,43 @@ import type { SubagentConfiguration } from "./subagentParser.js";
  */
 export function getBuiltinSubagents(): SubagentConfiguration[] {
   return [
+    createBashSubagent(),
     createExploreSubagent(),
     createGeneralPurposeSubagent(),
+    createPlanSubagent(),
     // Add more built-in subagents here as needed
   ];
 }
 
+/**
+ * Create the Bash built-in subagent configuration
+ * Specialized for executing bash commands and git operations
+ */
+function createBashSubagent(): SubagentConfiguration {
+  return {
+    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_SUBAGENT_TYPE}>`,
+    scope: "builtin",
+    priority: 3,
+  };
+}
+
 /**
  * Create the General-Purpose built-in subagent configuration
  * Specialized for multi-step research and implementation tasks
  */
 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,
   };
@@ -34,55 +73,52 @@ 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
+  };
+}
+
+/**
+ * Create the Plan built-in subagent configuration
+ * Specialized for designing implementation plans and exploring codebases in read-only mode
+ */
+function createPlanSubagent(): SubagentConfiguration {
+  // Define allowed tools for read-only operations
+  const allowedTools = [
+    GLOB_TOOL_NAME,
+    GREP_TOOL_NAME,
+    READ_TOOL_NAME,
+    BASH_TOOL_NAME,
+    LS_TOOL_NAME,
+    LSP_TOOL_NAME,
+  ];
+
+  return {
+    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_SUBAGENT_TYPE}>`,
     scope: "builtin",
     priority: 3, // Lowest priority - can be overridden by user configs
   };

package/src/utils/cacheControlUtils.ts

@@ -316,14 +316,8 @@ export function transformMessagesForClaudeCache(
   // Find the latest interval message index (20th, 40th, 60th, etc.)
   const intervalMessageIndex = findIntervalMessageIndex(messages);
 
-  // Find last system message index
-  let lastSystemIndex = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "system") {
-      lastSystemIndex = i;
-      break;
-    }
-  }
+  // Find first system message index
+  const firstSystemIndex = messages.findIndex((m) => m.role === "system");
 
   const result = messages.map((message, index) => {
     // Validate message structure
@@ -332,14 +326,27 @@ export function transformMessagesForClaudeCache(
       return message; // Return as-is to avoid breaking the flow
     }
 
-    // Last system message: always cached (hardcoded)
-    if (message.role === "system" && index === lastSystemIndex) {
+    // First system message: always cached (hardcoded)
+    if (message.role === "system" && index === firstSystemIndex) {
+      const content =
+        (message.content as string | ChatCompletionContentPart[]) || "";
+      // If content is already an array, check if it already has cache control
+      if (Array.isArray(content)) {
+        const hasCacheControl = content.some(
+          (part) =>
+            part.type === "text" &&
+            (part as ClaudeChatCompletionContentPartText).cache_control,
+        );
+        if (hasCacheControl) {
+          return message;
+        }
+      }
+
+      const transformedContent = addCacheControlToContent(content, true);
+
       return {
         ...message,
-        content: addCacheControlToContent(
-          (message.content as string | ChatCompletionContentPart[]) || "",
-          true,
-        ),
+        content: transformedContent,
       } as ChatCompletionMessageParam;
     }
 
@@ -364,12 +371,13 @@ export function transformMessagesForClaudeCache(
         } as ChatCompletionMessageParam;
       } else {
         // For other message types without tool calls, cache the content
+        const content =
+          (message.content as string | ChatCompletionContentPart[]) || "";
+        const transformedContent = addCacheControlToContent(content, true);
+
         return {
           ...message,
-          content: addCacheControlToContent(
-            (message.content as string | ChatCompletionContentPart[]) || "",
-            true,
-          ),
+          content: transformedContent,
         } as ChatCompletionMessageParam;
       }
     }

package/src/utils/constants.ts

@@ -31,8 +31,3 @@ export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
  */
 export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 96000; // Default token limit
 export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 8192; // Default output token limit
-
-/**
- * Default number of messages to keep uncompressed
- */
-export const DEFAULT_KEEP_LAST_MESSAGES_COUNT = 7;

package/src/utils/convertMessagesForAPI.ts

@@ -57,8 +57,8 @@ export function convertMessagesForAPI(
       );
       if (compressBlock && compressBlock.type === "compress") {
         recentMessages.unshift({
-          role: "system",
-          content: `[Compressed Message Summary] ${compressBlock.content}`,
+          role: "assistant",
+          content: compressBlock.content,
         });
       }
       break;

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}`);
     }
   }