wave-agent-sdk 0.14.4 → 0.15.1

package/src/managers/permissionManager.ts

@@ -131,7 +131,7 @@ export class PermissionManager {
   private planFilePath?: string;
   private worktreeName?: string;
   private mainRepoRoot?: string;
-  private originalWorkdir?: string;
+  private workdir?: string;
   private onConfiguredPermissionModeChange?: (mode: PermissionMode) => void;
   private _logger?: Logger;
 
@@ -153,7 +153,7 @@ export class PermissionManager {
 
     this.worktreeName = this.container.get<string>("WorktreeName");
     this.mainRepoRoot = this.container.get<string>("MainRepoRoot");
-    this.originalWorkdir = this.container.get<string>("Workdir");
+    this.workdir = this.container.get<string>("Workdir");
   }
 
   /**
@@ -277,7 +277,7 @@ export class PermissionManager {
    * Update the additional directories (e.g., when configuration reloads)
    */
   updateAdditionalDirectories(directories: string[]): void {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     this.additionalDirectories = directories.map((dir) => {
       if (workdir && !path.isAbsolute(dir)) {
         return path.resolve(workdir, dir);
@@ -290,7 +290,7 @@ export class PermissionManager {
    * Add a system-level additional directory that is persistent across configuration reloads
    */
   public addSystemAdditionalDirectory(directory: string): void {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     const resolvedPath =
       workdir && !path.isAbsolute(directory)
         ? path.resolve(workdir, directory)
@@ -329,7 +329,7 @@ export class PermissionManager {
     targetPath: string,
     workdir?: string,
   ): { isInside: boolean; resolvedPath: string } {
-    const effectiveWorkdir = this.originalWorkdir || workdir;
+    const effectiveWorkdir = this.workdir || workdir;
 
     // Resolve the target path relative to effectiveWorkdir if it's not absolute
     const absolutePath =
@@ -1068,7 +1068,7 @@ export class PermissionManager {
    * @param rule - The rule to add (e.g., "Bash(ls)")
    */
   public async addPermissionRule(rule: string): Promise<void> {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     if (!workdir) {
       throw new Error("Working directory not set in PermissionManager");
     }

package/src/managers/slashCommandManager.ts

@@ -224,20 +224,39 @@ export class SlashCommandManager {
                       const messages = subagent.messages;
                       const tokens =
                         subagent.messageManager.getLatestTotalTokens();
-                      const lastTools = subagent.lastTools;
+                      const usedTools = subagent.usedTools;
 
                       const toolCount = countToolBlocks(messages);
                       const summary = formatToolTokenSummary(toolCount, tokens);
 
+                      const getDisplayParam = (t: {
+                        name: string;
+                        parameters: string;
+                        compactParams?: string;
+                        stage?: string;
+                      }) => {
+                        if (
+                          (t.stage === "end" || t.stage === "running") &&
+                          t.compactParams
+                        ) {
+                          return t.compactParams;
+                        }
+                        const flat = t.parameters.replace(/\n/g, "\\n");
+                        return flat.length > 30 ? `…${flat.slice(-30)}` : flat;
+                      };
+
                       let shortResult = "";
                       if (toolCount > 2) {
                         shortResult += "... ";
                       }
-                      if (lastTools.length > 0) {
-                        shortResult += `${lastTools.join(", ")} `;
-                      }
-
                       shortResult += summary;
+                      if (usedTools.length > 0) {
+                        shortResult +=
+                          "\n" +
+                          usedTools
+                            .map((t) => `${t.name} ${getDisplayParam(t)}`)
+                            .join("\n");
+                      }
 
                       this.messageManager.updateToolBlock({
                         id: toolBlockId,

package/src/managers/subagentManager.ts

@@ -68,7 +68,12 @@ export interface SubagentInstance {
   toolManager: ToolManager;
   status: "initializing" | "active" | "completed" | "error" | "aborted";
   messages: Message[];
-  lastTools: string[]; // Track last two tool names
+  usedTools: {
+    name: string;
+    parameters: string;
+    compactParams?: string;
+    stage?: string;
+  }[]; // Track tools with display info
   subagentType: string; // Store the subagent type for hook context
   description: string; // Store the AI-generated description
   allowedTools?: string[]; // Optional permission rules (e.g. git:*)
@@ -388,7 +393,7 @@ export class SubagentManager {
       toolManager,
       status: "initializing",
       messages: [],
-      lastTools: [], // Initialize lastTools
+      usedTools: [], // Initialize usedTools
       subagentType: parameters.subagent_type, // Store the subagent type
       description: parameters.description, // Store the AI-generated description
       allowedTools: parameters.allowedTools, // Store optional permission rules
@@ -790,27 +795,16 @@ export class SubagentManager {
       },
 
       onToolBlockUpdated: (params: AgentToolBlockUpdateParams) => {
-        // Track last two tool names when a tool starts running
-        if (params.stage === "running" && params.name) {
-          const instance = this.instances.get(subagentId);
-          if (instance) {
-            // Add to lastTools if it's different from the last one or we want to show duplicates
-            // Based on "ToolA, ToolB" requirement, we'll just keep the last two
-            instance.lastTools.push(params.name);
-            if (instance.lastTools.length > 2) {
-              instance.lastTools.shift();
-            }
-            instance.onUpdate?.();
-
-            // Log tool execution to file
-            if (instance.logStream) {
-              const displayParams =
-                params.compactParams ||
-                (params.parameters || "{}").substring(0, 100);
-              instance.logStream.write(
-                `[${new Date().toISOString()}] ${params.name}${displayParams ? ` ${displayParams}` : ""}\n`,
-              );
-            }
+        const instance = this.instances.get(subagentId);
+        if (instance) {
+          // Log tool execution to file only when finalized
+          if (instance.logStream && params.stage === "end") {
+            const displayParams =
+              params.compactParams ||
+              (params.parameters || "").substring(0, 100);
+            instance.logStream.write(
+              `[${new Date().toISOString()}] ${params.name}${displayParams ? ` ${displayParams}` : ""}\n`,
+            );
           }
         }
 
@@ -825,6 +819,17 @@ export class SubagentManager {
         const instance = this.instances.get(subagentId);
         if (instance) {
           instance.messages = messages;
+          // Compute usedTools from messages (last 2 tool blocks)
+          const toolBlocks = messages.flatMap(
+            (m) => m.blocks?.filter((b) => b.type === "tool") ?? [],
+          );
+          const last2 = toolBlocks.slice(-2);
+          instance.usedTools = last2.map((tb) => ({
+            name: tb.name ?? "",
+            parameters: tb.parameters ?? "",
+            compactParams: tb.compactParams,
+            stage: tb.stage,
+          }));
           // Trigger the onUpdate callback if provided
           instance.onUpdate?.();
           // Forward subagent message changes to parent via callbacks

package/src/prompts/index.ts

@@ -19,8 +19,6 @@ import {
   GREP_TOOL_NAME,
 } from "../constants/tools.js";
 
-export const MAX_PARALLEL_TOOL_CALLS = 3;
-
 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.`;
 
 export const DOING_TASKS_PROMPT = `# Doing tasks
@@ -60,7 +58,6 @@ export const TOOL_POLICY = `# Using your tools
   - To search the content of files, use ${GREP_TOOL_NAME} instead of grep or rg
   - Reserve using the ${BASH_TOOL_NAME} exclusively for system commands and terminal operations that require shell execution. If you are unsure and there is a relevant dedicated tool, default to using the dedicated tool and only fallback on using the ${BASH_TOOL_NAME} tool for these if it is absolutely necessary.
 - You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency.
-- **Limit**: You MUST NOT call more than ${MAX_PARALLEL_TOOL_CALLS} tools in parallel in a single response.
 - However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead. Never use placeholders or guess missing parameters in tool calls.
 - If the user specifies that they want you to run tools "in parallel", you MUST send a single message with multiple tool use content blocks.`;
 
@@ -238,7 +235,6 @@ export function buildSystemPrompt(
   tools: ToolPlugin[],
   options: {
     workdir?: string;
-    originalWorkdir?: string;
     memory?: string;
     language?: string;
     isSubagent?: boolean;
@@ -276,9 +272,8 @@ export function buildSystemPrompt(
     prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists, options.isSubagent)}`;
   }
 
-  const workdirForPrompt = options.originalWorkdir || options.workdir;
-  if (workdirForPrompt) {
-    const isGitRepo = isGitRepository(workdirForPrompt);
+  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];
@@ -293,7 +288,7 @@ export function buildSystemPrompt(
 
 Here is useful information about the environment you are running in:
 <env>
-Working directory: ${workdirForPrompt}
+Working directory: ${options.workdir}
 Is directory a git repo: ${isGitRepo}
 Platform: ${platform}
 Shell: ${shellName}

package/src/services/aiService.ts

@@ -377,10 +377,7 @@ export async function callAgent(
           result.content = finalContent;
         }
 
-        if (
-          typeof finalReasoningContent === "string" &&
-          finalReasoningContent.length > 0
-        ) {
+        if (typeof finalReasoningContent === "string") {
           result.reasoning_content = finalReasoningContent;
         }
 
@@ -544,6 +541,7 @@ async function processStreamingResponse(
 ): Promise<CallAgentResult> {
   let accumulatedContent = "";
   let accumulatedReasoningContent = "";
+  let hasReasoningContent = false;
   const toolCalls: {
     id: string;
     type: "function";
@@ -618,13 +616,13 @@ async function processStreamingResponse(
         }
       }
 
-      if (
-        typeof reasoning_content === "string" &&
-        reasoning_content.length > 0
-      ) {
-        accumulatedReasoningContent += reasoning_content;
-        if (onReasoningUpdate) {
-          onReasoningUpdate(accumulatedReasoningContent);
+      if (typeof reasoning_content === "string") {
+        hasReasoningContent = true;
+        if (reasoning_content.length > 0) {
+          accumulatedReasoningContent += reasoning_content;
+          if (onReasoningUpdate) {
+            onReasoningUpdate(accumulatedReasoningContent);
+          }
         }
       }
 
@@ -716,7 +714,7 @@ async function processStreamingResponse(
     result.content = accumulatedContent.trim();
   }
 
-  if (accumulatedReasoningContent) {
+  if (hasReasoningContent) {
     result.reasoning_content = accumulatedReasoningContent.trim();
   }
 

package/src/services/hook.ts

@@ -277,21 +277,6 @@ export async function executeCommands(
   return results;
 }
 
-/**
- * Execute a CwdChanged hook
- */
-export async function executeCwdChangedHooks(
-  oldCwd: string,
-  newCwd: string,
-  context: ExtendedHookExecutionContext,
-): Promise<HookExecutionResult[]> {
-  // CwdChanged hooks are executed through HookManager.executeCwdChangedHooks()
-  void context;
-  void oldCwd;
-  void newCwd;
-  return [];
-}
-
 /**
  * Validate command safety (basic checks)
  */

package/src/services/jsonlHandler.ts

@@ -8,7 +8,7 @@ import { dirname } from "path";
 import { getLastLine } from "../utils/fileUtils.js";
 
 import type { Message } from "../types/index.js";
-import type { SessionMessage, SessionFilename } from "../types/session.js";
+import type { SessionFilename } from "../types/session.js";
 
 /**
  * JSONL write options
@@ -56,13 +56,7 @@ export class JsonlHandler {
       return;
     }
 
-    // Convert to SessionMessage format with timestamps
-    const sessionMessages: SessionMessage[] = messages.map((message) => ({
-      ...message,
-      timestamp: new Date().toISOString(),
-    }));
-
-    return this.append(filePath, sessionMessages);
+    return this.append(filePath, messages);
   }
 
   /**
@@ -70,7 +64,7 @@ export class JsonlHandler {
    */
   async append(
     filePath: string,
-    messages: SessionMessage[],
+    messages: Message[],
     options?: JsonlWriteOptions,
   ): Promise<void> {
     if (messages.length === 0) {
@@ -85,16 +79,10 @@ export class JsonlHandler {
     // Ensure directory exists
     await this.ensureDirectory(dirname(filePath));
 
-    // Convert messages to JSONL lines (always compact JSON)
+    // Convert messages to JSONL lines (compact JSON, timestamp first)
     const lines = messages.map((message) => {
-      const { timestamp: existingTimestamp, ...messageWithoutTimestamp } =
-        message;
-      const messageWithTimestamp = {
-        timestamp: existingTimestamp || new Date().toISOString(),
-        ...messageWithoutTimestamp,
-      };
-
-      return JSON.stringify(messageWithTimestamp);
+      const { timestamp, ...rest } = message;
+      return JSON.stringify({ timestamp, ...rest });
     });
 
     const content = lines.join("\n") + "\n";
@@ -116,7 +104,7 @@ export class JsonlHandler {
   /**
    * Read all messages from JSONL file (simplified - no metadata handling)
    */
-  async read(filePath: string): Promise<SessionMessage[]> {
+  async read(filePath: string): Promise<Message[]> {
     try {
       const content = await readFile(filePath, "utf8");
       const lines = content
@@ -128,14 +116,14 @@ export class JsonlHandler {
         return [];
       }
 
-      const allMessages: SessionMessage[] = [];
+      const allMessages: Message[] = [];
 
       // Parse all messages (no metadata line to skip)
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
 
         try {
-          const message = JSON.parse(line) as SessionMessage;
+          const message = JSON.parse(line) as Message;
           if (message.timestamp) allMessages.push(message);
         } catch (error) {
           // Throw error for invalid JSON lines with line number
@@ -155,7 +143,7 @@ export class JsonlHandler {
   /**
    * Get the last message from JSONL file using efficient file reading (simplified)
    */
-  async getLastMessage(filePath: string): Promise<SessionMessage | null> {
+  async getLastMessage(filePath: string): Promise<Message | null> {
     try {
       // First check if file exists
       try {
@@ -176,7 +164,7 @@ export class JsonlHandler {
 
       try {
         const parsed = JSON.parse(lastLine);
-        return parsed as SessionMessage;
+        return parsed as Message;
       } catch (error) {
         throw new Error(`Invalid JSON in last line of "${filePath}": ${error}`);
       }
@@ -190,7 +178,7 @@ export class JsonlHandler {
   /**
    * Validate messages before writing
    */
-  private validateMessages(messages: SessionMessage[]): void {
+  private validateMessages(messages: Message[]): void {
     for (let i = 0; i < messages.length; i++) {
       const message = messages[i];
 

package/src/services/session.ts

@@ -20,7 +20,6 @@ import { join } from "path";
 import { homedir } from "os";
 import { randomUUID } from "crypto";
 import type { Message } from "../types/index.js";
-import type { SessionMessage } from "../types/session.js";
 import { PathEncoder } from "../utils/pathEncoder.js";
 import { JsonlHandler } from "../services/jsonlHandler.js";
 import { extractLatestTotalTokens } from "../utils/tokenCalculation.js";
@@ -228,19 +227,14 @@ export async function appendMessages(
     );
   }
 
-  const messagesWithTimestamp: SessionMessage[] = newMessages.map((msg) => ({
-    timestamp: new Date().toISOString(),
-    ...msg,
-  }));
-
-  await jsonlHandler.append(filePath, messagesWithTimestamp, {
+  await jsonlHandler.append(filePath, newMessages, {
     atomic: false,
   });
 
   // Update index
   const encoder = new PathEncoder();
   const projectDir = await encoder.getProjectDirectory(workdir, SESSION_DIR);
-  const lastMessage = messagesWithTimestamp[messagesWithTimestamp.length - 1];
+  const lastMessage = newMessages[newMessages.length - 1];
 
   // Get first message content if it's a new session or we don't have it
   let firstMessage: string | undefined;
@@ -333,12 +327,7 @@ export async function loadSessionFromJsonl(
       id: sessionId,
       rootSessionId: rootSessionId || sessionId,
       parentSessionId,
-      messages: messages.map((msg) => {
-        // Remove timestamp property for backward compatibility
-        const { timestamp: _ignored, ...messageWithoutTimestamp } = msg;
-        void _ignored; // Use the variable to avoid eslint error
-        return messageWithoutTimestamp;
-      }),
+      messages,
       metadata: {
         workdir,
         lastActiveAt: lastMessage
@@ -953,7 +942,12 @@ export async function handleSessionRestoration(
       // Use only JSONL format - no legacy support
       sessionToRestore = await loadSessionFromJsonl(restoreSessionId, workdir);
       if (!sessionToRestore) {
-        throw new Error(`Session not found: ${restoreSessionId}`);
+        // Session doesn't exist on disk (e.g. new project with no messages saved yet).
+        // Gracefully fall back to starting fresh instead of throwing.
+        logger?.warn(
+          `Session ${restoreSessionId} not found on disk, starting fresh session`,
+        );
+        return;
       }
     } else if (continueLastSession) {
       // Use only JSONL format - no legacy support

package/src/tools/agentTool.ts

@@ -159,20 +159,39 @@ When using the Agent tool, you must specify a subagent_type parameter to select
 
           const messages = instance.messageManager.getMessages();
           const tokens = instance.messageManager.getLatestTotalTokens();
-          const lastTools = instance.lastTools;
+          const usedTools = instance.usedTools;
 
           const toolCount = countToolBlocks(messages);
           const summary = formatToolTokenSummary(toolCount, tokens);
 
+          const getDisplayParam = (t: {
+            name: string;
+            parameters: string;
+            compactParams?: string;
+            stage?: string;
+          }) => {
+            if (
+              (t.stage === "end" || t.stage === "running") &&
+              t.compactParams
+            ) {
+              return t.compactParams;
+            }
+            const flat = t.parameters.replace(/\n/g, "\\n");
+            return flat.length > 30 ? `…${flat.slice(-30)}` : flat;
+          };
+
           let shortResult = "";
           if (toolCount > 2) {
             shortResult += "... ";
           }
-          if (lastTools.length > 0) {
-            shortResult += `${lastTools.join(", ")} `;
-          }
-
           shortResult += summary;
+          if (usedTools.length > 0) {
+            shortResult +=
+              "\n" +
+              usedTools
+                .map((t) => `${t.name} ${getDisplayParam(t)}`)
+                .join("\n");
+          }
 
           context.onShortResultUpdate?.(shortResult);
         },

package/src/tools/bashTool.ts

@@ -80,7 +80,7 @@ export const bashTool: ToolPlugin = {
     },
   },
   prompt: () => `
-Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.
+Executes a given bash command with optional timeout, ensuring proper handling and security measures. Each invocation runs in a fresh shell process starting from the project root.
 
 IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file operations (reading, writing, editing, searching, finding files) - use the specialized tools for this instead.
 
@@ -139,10 +139,7 @@ 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.
-
-# 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.`,
+- If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.`,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,
@@ -240,14 +237,7 @@ Try to maintain your current working directory throughout the session by using a
 
     // Foreground execution (original behavior)
     return new Promise((resolve) => {
-      // Create a temporary file to store the CWD
-      const tempCwdFile = path.join(
-        os.tmpdir(),
-        `wave_cwd_${Date.now()}_${Math.random().toString(36).substring(2, 11)}.tmp`,
-      );
-      const wrappedCommand = `${command} && pwd -P >| ${tempCwdFile}`;
-
-      const child: ChildProcess = spawn(wrappedCommand, {
+      const child: ChildProcess = spawn(command, {
         shell: true,
         stdio: "pipe",
         cwd: context.workdir,
@@ -431,55 +421,13 @@ Try to maintain your current working directory throughout the session by using a
             clearTimeout(timeoutHandle);
           }
 
-          // Read the new CWD from the temporary file
-          let newCwd: string | undefined;
-          try {
-            if (fs.existsSync(tempCwdFile)) {
-              newCwd = fs.readFileSync(tempCwdFile, "utf8").trim();
-              // Validate the path exists before calling the callback
-              fs.accessSync(newCwd, fs.constants.F_OK);
-            }
-          } catch (fileError) {
-            logger.warn(
-              `Could not read or validate new CWD from temp file ${tempCwdFile}:`,
-              fileError,
-            );
-            newCwd = undefined;
-          } finally {
-            // Ensure temp file is cleaned up even if reading fails
-            try {
-              if (fs.existsSync(tempCwdFile)) {
-                fs.unlinkSync(tempCwdFile);
-              }
-            } catch (fileError) {
-              logger.error("Failed to clean up temp CWD file:", fileError);
-            }
-          }
-
-          // If CWD changed, call the onCwdChange callback and add notification
-          let cwdChangedNotification = "";
-          if (newCwd && newCwd !== context.workdir && context.onCwdChange) {
-            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;
           const combinedOutput =
             outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
 
           // Handle large output by truncation and persistence if needed
           const finalOutput =
-            cwdChangedNotification +
-            (combinedOutput || `Command executed with exit code: ${exitCode}`);
+            combinedOutput || `Command executed with exit code: ${exitCode}`;
           const content = processOutput(finalOutput);
 
           const lines = combinedOutput.trim().split("\n");

package/src/tools/editTool.ts

@@ -136,7 +136,7 @@ Usage:
         return {
           success: false,
           content: "",
-          error: analyzeEditMismatch(originalContent, oldString),
+          error: analyzeEditMismatch(),
         };
       }
 

package/src/tools/skillTool.ts

@@ -148,19 +148,39 @@ export const skillTool: ToolPlugin = {
             // Update shortResult
             const messages = instance.messageManager.getMessages();
             const tokens = instance.messageManager.getLatestTotalTokens();
-            const lastTools = instance.lastTools;
+            const usedTools = instance.usedTools;
 
             const toolCount = countToolBlocks(messages);
             const summary = formatToolTokenSummary(toolCount, tokens);
 
+            const getDisplayParam = (t: {
+              name: string;
+              parameters: string;
+              compactParams?: string;
+              stage?: string;
+            }) => {
+              if (
+                (t.stage === "end" || t.stage === "running") &&
+                t.compactParams
+              ) {
+                return t.compactParams;
+              }
+              const flat = t.parameters.replace(/\n/g, "\\n");
+              return flat.length > 30 ? `…${flat.slice(-30)}` : flat;
+            };
+
             let shortResult = "";
             if (toolCount > 2) {
               shortResult += "... ";
             }
-            if (lastTools.length > 0) {
-              shortResult += `${lastTools.join(", ")} `;
-            }
             shortResult += summary;
+            if (usedTools.length > 0) {
+              shortResult +=
+                "\n" +
+                usedTools
+                  .map((t) => `${t.name} ${getDisplayParam(t)}`)
+                  .join("\n");
+            }
 
             context.onShortResultUpdate?.(shortResult);
           },

package/src/tools/types.ts

@@ -58,7 +58,6 @@ 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 */
@@ -104,6 +103,4 @@ export interface ToolContext {
   };
   /** State of files read in the current session for deduplication */
   readFileState?: Map<string, { mtime: number; hash: string }>;
-  /** Callback to notify when the current working directory changes */
-  onCwdChange?: (newCwd: string) => void;
 }