wave-agent-sdk 0.18.4 → 0.18.6

package/dist/utils/worktreeUtils.js

@@ -2,7 +2,7 @@
  * Git worktree creation and removal utilities for the SDK.
  * Used by EnterWorktree and ExitWorktree tools.
  */
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { getGitMainRepoRoot, getDefaultRemoteBranch } from "./gitUtils.js";
@@ -61,7 +61,7 @@ export function generateWorktreeName() {
  * Get the current HEAD commit SHA.
  */
 export function getHeadCommit(cwd) {
-    return execSync(`git -C "${cwd}" rev-parse HEAD`, {
+    return execFileSync("git", ["-C", cwd, "rev-parse", "HEAD"], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
     }).trim();
@@ -97,7 +97,7 @@ export function createWorktree(name, cwd) {
     }
     try {
         // Create worktree and branch
-        execSync(`git worktree add -b ${branchName} "${worktreePath}" ${baseBranch}`, {
+        execFileSync("git", ["worktree", "add", "-b", branchName, worktreePath, baseBranch], {
             cwd: repoRoot,
             stdio: ["ignore", "pipe", "pipe"],
             env: {
@@ -120,7 +120,7 @@ export function createWorktree(name, cwd) {
         if (stderr.includes("already exists")) {
             // Branch exists but worktree doesn't — attach to existing branch
             try {
-                execSync(`git worktree add "${worktreePath}" ${branchName}`, {
+                execFileSync("git", ["worktree", "add", worktreePath, branchName], {
                     cwd: repoRoot,
                     stdio: ["ignore", "pipe", "pipe"],
                     env: {
@@ -147,7 +147,7 @@ export function createWorktree(name, cwd) {
             // Base branch not fetched yet — try fetching then retrying
             const branchNameOnly = baseBranch.split("/").pop();
             try {
-                execSync(`git fetch origin ${branchNameOnly}`, {
+                execFileSync("git", ["fetch", "origin", branchNameOnly], {
                     cwd: repoRoot,
                     stdio: ["ignore", "pipe", "pipe"],
                     env: {
@@ -156,7 +156,7 @@ export function createWorktree(name, cwd) {
                         GIT_ASKPASS: "",
                     },
                 });
-                execSync(`git worktree add -b ${branchName} "${worktreePath}" ${baseBranch}`, {
+                execFileSync("git", ["worktree", "add", "-b", branchName, worktreePath, baseBranch], {
                     cwd: repoRoot,
                     stdio: ["ignore", "pipe", "pipe"],
                     env: {
@@ -177,7 +177,7 @@ export function createWorktree(name, cwd) {
             catch {
                 // Fetch or retry failed — fall back to HEAD
                 try {
-                    execSync(`git worktree add -b ${branchName} "${worktreePath}" HEAD`, {
+                    execFileSync("git", ["worktree", "add", "-b", branchName, worktreePath, "HEAD"], {
                         cwd: repoRoot,
                         stdio: ["ignore", "pipe", "pipe"],
                         env: {
@@ -212,7 +212,7 @@ export function removeWorktree(info) {
         // Get current branch in worktree before removing
         let currentBranch;
         try {
-            currentBranch = execSync(`git rev-parse --abbrev-ref HEAD`, {
+            currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
                 cwd: info.path,
                 encoding: "utf8",
                 stdio: ["ignore", "pipe", "ignore"],
@@ -222,13 +222,13 @@ export function removeWorktree(info) {
             // Ignore errors
         }
         // Remove worktree
-        execSync(`git worktree remove --force "${info.path}"`, {
+        execFileSync("git", ["worktree", "remove", "--force", info.path], {
             cwd: repoRoot,
             stdio: ["ignore", "pipe", "pipe"],
         });
         // Delete worktree branch
         try {
-            execSync(`git branch -D ${info.branch}`, {
+            execFileSync("git", ["branch", "-D", info.branch], {
                 cwd: repoRoot,
                 stdio: ["ignore", "pipe", "pipe"],
             });
@@ -246,7 +246,7 @@ export function removeWorktree(info) {
                 currentBranch !== "main" &&
                 currentBranch !== "master") {
                 try {
-                    execSync(`git branch -D ${currentBranch}`, {
+                    execFileSync("git", ["branch", "-D", currentBranch], {
                         cwd: repoRoot,
                         stdio: ["ignore", "pipe", "pipe"],
                     });
@@ -271,7 +271,7 @@ export function removeWorktree(info) {
  */
 export function countWorktreeChanges(worktreePath, originalHeadCommit) {
     try {
-        const statusOutput = execSync(`git -C "${worktreePath}" status --porcelain`, {
+        const statusOutput = execFileSync("git", ["-C", worktreePath, "status", "--porcelain"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         });
@@ -281,7 +281,13 @@ export function countWorktreeChanges(worktreePath, originalHeadCommit) {
         if (!originalHeadCommit) {
             return null;
         }
-        const revListOutput = execSync(`git -C "${worktreePath}" rev-list --count ${originalHeadCommit}..HEAD`, {
+        const revListOutput = execFileSync("git", [
+            "-C",
+            worktreePath,
+            "rev-list",
+            "--count",
+            `${originalHeadCommit}..HEAD`,
+        ], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.18.4",
+  "version": "0.18.6",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/scripts/install_ripgrep.js

@@ -9,18 +9,6 @@ const __dirname = path.dirname(__filename);
 const MANIFEST_PATH = path.resolve(__dirname, "../bin/rg");
 const VENDOR_DIR = path.resolve(__dirname, "../vendor/ripgrep");
 
-function getCurrentPlatform() {
-  const platform = process.platform;
-  const arch = process.arch;
-  if (platform === "darwin")
-    return `macos-${arch === "arm64" ? "aarch64" : "x86_64"}`;
-  if (platform === "linux")
-    return `linux-${arch === "arm64" ? "aarch64" : "x86_64"}`;
-  if (platform === "win32")
-    return `windows-${arch === "arm64" ? "aarch64" : "x86_64"}`;
-  return null;
-}
-
 async function main() {
   if (!fs.existsSync(MANIFEST_PATH)) {
     console.error(`Manifest not found: ${MANIFEST_PATH}`);
@@ -30,15 +18,7 @@ async function main() {
   const manifestContent = fs.readFileSync(MANIFEST_PATH, "utf-8");
   const jsonContent = manifestContent.replace(/^#!.*\n/, "");
   const manifest = JSON.parse(jsonContent);
-  const allPlatforms = manifest.platforms;
-
-  // In CI, only download for the current platform
-  const isCI = process.env.CI === "true";
-  const currentPlatform = isCI ? getCurrentPlatform() : null;
-  const platforms =
-    currentPlatform && currentPlatform in allPlatforms
-      ? { [currentPlatform]: allPlatforms[currentPlatform] }
-      : allPlatforms;
+  const platforms = manifest.platforms;
 
   if (!fs.existsSync(VENDOR_DIR)) {
     fs.mkdirSync(VENDOR_DIR, { recursive: true });

package/src/managers/aiManager.ts

@@ -1271,7 +1271,103 @@ export class AIManager {
         // Set loading to false first
         this.setIsLoading(false);
 
-        // Inject pending notifications from background tasks
+        // Clear temporary rules
+        this.permissionManager?.clearTemporaryRules();
+
+        // Clear abort controllers
+        this.abortController = null;
+        this.toolAbortController = null;
+
+        // Execute Stop/SubagentStop hooks only if the operation was not aborted
+        const isCurrentlyAborted =
+          abortController.signal.aborted || toolAbortController.signal.aborted;
+
+        if (!isCurrentlyAborted) {
+          // Record committed snapshots to message history for the final turn
+          if (this.reversionManager) {
+            const snapshots =
+              this.reversionManager.getAndClearCommittedSnapshots();
+            if (snapshots.length > 0) {
+              this.messageManager.addFileHistoryBlock(snapshots);
+            }
+          }
+
+          // Goal evaluation — supersedes Stop hooks when active
+          const goalManager = this.container.has("GoalManager")
+            ? this.container.get<import("./goalManager.js").GoalManager>(
+                "GoalManager",
+              )
+            : undefined;
+
+          let goalContinuing = false;
+
+          if (goalManager?.isGoalActive() && !this.subagentType) {
+            // 1. Increment turn count and check circuit breakers
+            goalManager.incrementTurnCount();
+            const circuitBreaker = goalManager.checkCircuitBreakers();
+
+            if (circuitBreaker) {
+              goalManager.clearGoal();
+              logger?.info(`[Goal] ${circuitBreaker}`);
+              this.messageManager.addUserMessage({
+                content: `<system-reminder>${circuitBreaker}</system-reminder>`,
+                isMeta: true,
+              });
+              // Fall through to normal Stop hooks on the final turn
+            } else {
+              // 2. Evaluate goal
+              const evaluation = await goalManager.evaluateGoal(
+                abortController.signal,
+              );
+
+              if (evaluation.isMet) {
+                goalManager.clearGoal();
+                logger?.info(`[Goal] Goal achieved: ${evaluation.reason}`);
+                this.messageManager.addUserMessage({
+                  content: `<system-reminder>Goal achieved: ${evaluation.reason}</system-reminder>`,
+                  isMeta: true,
+                });
+                // Fall through to normal Stop hooks on the final turn
+              } else {
+                const goal = goalManager.getGoal()!;
+                goal.lastReason = evaluation.reason;
+                logger?.info(`[Goal] Not yet met: ${evaluation.reason}`);
+                this.messageManager.addUserMessage({
+                  content: `<system-reminder>Goal not yet met: ${evaluation.reason}. Continue working toward: ${goal.condition}</system-reminder>`,
+                  isMeta: true,
+                });
+                // Keep loading state active to prevent UI flicker
+                this.setIsLoading(true);
+                goalContinuing = true;
+                // Restart outer loop to continue goal pursuit
+                shouldRestart = true;
+                turnOffset = 0;
+              }
+            }
+          }
+
+          // Skip Stop hooks when goal evaluator is continuing the conversation
+          if (goalContinuing) {
+            // Goal evaluator supersedes Stop hooks
+          } else {
+            const shouldContinue = await this.executeStopHooks();
+
+            // If Stop/SubagentStop hooks indicate we should continue (due to blocking errors),
+            // restart the AI conversation cycle
+            if (shouldContinue) {
+              logger?.info(
+                `${this.subagentType ? "SubagentStop" : "Stop"} hooks indicate issues need fixing, continuing conversation...`,
+              );
+
+              // Restart the conversation to let AI fix the issues
+              shouldRestart = true;
+              turnOffset = 0;
+            }
+          }
+        }
+
+        // Inject pending notifications from background tasks (after Stop hooks,
+        // aligned with Claude Code which fires Stop hooks unconditionally)
         const notificationQueue = this.container.has("NotificationQueue")
           ? this.container.get<NotificationQueue>("NotificationQueue")
           : undefined;
@@ -1292,102 +1388,6 @@ export class AIManager {
           // Restart outer loop to process the notifications
           shouldRestart = true;
           turnOffset = 0;
-        } else {
-          // Clear temporary rules
-          this.permissionManager?.clearTemporaryRules();
-
-          // Clear abort controllers
-          this.abortController = null;
-          this.toolAbortController = null;
-
-          // Execute Stop/SubagentStop hooks only if the operation was not aborted
-          const isCurrentlyAborted =
-            abortController.signal.aborted ||
-            toolAbortController.signal.aborted;
-
-          if (!isCurrentlyAborted) {
-            // Record committed snapshots to message history for the final turn
-            if (this.reversionManager) {
-              const snapshots =
-                this.reversionManager.getAndClearCommittedSnapshots();
-              if (snapshots.length > 0) {
-                this.messageManager.addFileHistoryBlock(snapshots);
-              }
-            }
-
-            // Goal evaluation — supersedes Stop hooks when active
-            const goalManager = this.container.has("GoalManager")
-              ? this.container.get<import("./goalManager.js").GoalManager>(
-                  "GoalManager",
-                )
-              : undefined;
-
-            let goalContinuing = false;
-
-            if (goalManager?.isGoalActive() && !this.subagentType) {
-              // 1. Increment turn count and check circuit breakers
-              goalManager.incrementTurnCount();
-              const circuitBreaker = goalManager.checkCircuitBreakers();
-
-              if (circuitBreaker) {
-                goalManager.clearGoal();
-                logger?.info(`[Goal] ${circuitBreaker}`);
-                this.messageManager.addUserMessage({
-                  content: `<system-reminder>${circuitBreaker}</system-reminder>`,
-                  isMeta: true,
-                });
-                // Fall through to normal Stop hooks on the final turn
-              } else {
-                // 2. Evaluate goal
-                const evaluation = await goalManager.evaluateGoal(
-                  abortController.signal,
-                );
-
-                if (evaluation.isMet) {
-                  goalManager.clearGoal();
-                  logger?.info(`[Goal] Goal achieved: ${evaluation.reason}`);
-                  this.messageManager.addUserMessage({
-                    content: `<system-reminder>Goal achieved: ${evaluation.reason}</system-reminder>`,
-                    isMeta: true,
-                  });
-                  // Fall through to normal Stop hooks on the final turn
-                } else {
-                  const goal = goalManager.getGoal()!;
-                  goal.lastReason = evaluation.reason;
-                  logger?.info(`[Goal] Not yet met: ${evaluation.reason}`);
-                  this.messageManager.addUserMessage({
-                    content: `<system-reminder>Goal not yet met: ${evaluation.reason}. Continue working toward: ${goal.condition}</system-reminder>`,
-                    isMeta: true,
-                  });
-                  // Keep loading state active to prevent UI flicker
-                  this.setIsLoading(true);
-                  goalContinuing = true;
-                  // Restart outer loop to continue goal pursuit
-                  shouldRestart = true;
-                  turnOffset = 0;
-                }
-              }
-            }
-
-            // Skip Stop hooks when goal evaluator is continuing the conversation
-            if (goalContinuing) {
-              // Goal evaluator supersedes Stop hooks
-            } else {
-              const shouldContinue = await this.executeStopHooks();
-
-              // If Stop/SubagentStop hooks indicate we should continue (due to blocking errors),
-              // restart the AI conversation cycle
-              if (shouldContinue) {
-                logger?.info(
-                  `${this.subagentType ? "SubagentStop" : "Stop"} hooks indicate issues need fixing, continuing conversation...`,
-                );
-
-                // Restart the conversation to let AI fix the issues
-                shouldRestart = true;
-                turnOffset = 0;
-              }
-            }
-          }
         }
       }
 

package/src/managers/mcpManager.ts

@@ -484,29 +484,40 @@ export class McpManager {
           stderr: "pipe", // Pipe stderr to capture it
         });
 
-        // Handle stderr output for StdioClientTransport
+        // Buffer stderr silently (MCP servers use stderr for all logging;
+        // stdout is reserved for JSON-RPC). Only dump it on connection
+        // success (once) or failure — not line-by-line in real time.
+        // Aligns with Claude Code's approach to avoid noise from [INFO],
+        // [DEBUG], Warning: lines that are not actual errors.
         const stderr = (transport as StdioClientTransport).stderr;
+        let stderrOutput = "";
         if (stderr) {
-          let buffer = "";
           stderr.on("data", (chunk: Buffer) => {
-            buffer += chunk.toString();
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            for (const line of lines) {
-              if (line.trim()) {
-                logger?.error(`[MCP Server ${name}] ${line}`);
-              }
-            }
-          });
-          stderr.on("end", () => {
-            if (buffer.trim()) {
-              logger?.error(`[MCP Server ${name}] ${buffer}`);
+            if (stderrOutput.length < 64 * 1024 * 1024) {
+              stderrOutput += chunk.toString();
             }
           });
         }
 
         client = createClient();
-        await client.connect(transport);
+        try {
+          await client.connect(transport);
+        } catch (error) {
+          if (stderrOutput.trim()) {
+            logger?.error(
+              `[MCP Server ${name}] Server stderr: ${stderrOutput.trim()}`,
+            );
+          }
+          throw error;
+        }
+
+        // Dump accumulated stderr once after successful connection
+        if (stderrOutput.trim()) {
+          logger?.debug(
+            `[MCP Server ${name}] Server stderr: ${stderrOutput.trim()}`,
+          );
+          stderrOutput = "";
+        }
 
         const toolsResponse = await client.listTools();
         tools =

package/src/tools/bashTool.ts

@@ -4,6 +4,7 @@ import * as path from "path";
 import * as os from "os";
 import { logger } from "../utils/globalLogger.js";
 import { resolveShellPath } from "../utils/shellResolver.js";
+import { toPosixPath } from "../utils/path.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import { processToolResult } from "../utils/toolResultStorage.js";
 import { BASH_MAX_OUTPUT_CHARS } from "../constants/toolLimits.js";
@@ -246,7 +247,8 @@ The working directory persists between commands. Try to maintain your current wo
         os.tmpdir(),
         `wave_cwd_${Date.now()}_${Math.random().toString(36).substring(2, 11)}.tmp`,
       );
-      const wrappedCommand = `${command} && pwd -P >| ${tempCwdFile}`;
+      const tempCwdFileForBash = toPosixPath(tempCwdFile);
+      const wrappedCommand = `${command} && pwd -P >| ${tempCwdFileForBash}`;
 
       const child: ChildProcess = spawn(wrappedCommand, {
         shell: shellPath || true,
@@ -264,6 +266,17 @@ The working directory persists between commands. Try to maintain your current wo
       let isBackgrounded = false;
       let isFinished = false;
 
+      // Best-effort cleanup of the temp CWD file — used by abort/error/exit paths
+      const cleanupTempFile = () => {
+        try {
+          if (fs.existsSync(tempCwdFile)) {
+            fs.unlinkSync(tempCwdFile);
+          }
+        } catch {
+          // ignore — best-effort cleanup
+        }
+      };
+
       const updateRealtimeResults = () => {
         if (isAborted || isBackgrounded || isFinished) return;
 
@@ -420,6 +433,8 @@ The working directory persists between commands. Try to maintain your current wo
             }
           }
 
+          cleanupTempFile();
+
           const processedOutput = processToolResult(
             outputBuffer + (errorBuffer ? "\n" + errorBuffer : ""),
             BASH_MAX_OUTPUT_CHARS,
@@ -491,14 +506,7 @@ The working directory persists between commands. Try to maintain your current wo
             );
             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);
-            }
+            cleanupTempFile();
           }
 
           // If CWD changed, call the onCwdChange callback and add notification
@@ -560,6 +568,7 @@ The working directory persists between commands. Try to maintain your current wo
           if (timeoutHandle) {
             clearTimeout(timeoutHandle);
           }
+          cleanupTempFile();
           resolve({
             success: false,
             content: "",

package/src/tools/editTool.ts

@@ -112,11 +112,11 @@ Usage:
     // Trigger conditional rule loading for this file
     context.messageManager?.triggerFileRead(filePath);
 
-    // Enforce read-before-edit: the file must have been read first
-    if (
-      context.messageManager &&
-      !context.messageManager.hasFileBeenRead(filePath)
-    ) {
+    // Enforce read-before-edit: the file must have been read or written first.
+    // readFileState is populated by Read, Write, and Edit tools — single source
+    // of truth, aligned with Claude Code's readFileState approach.
+    const resolvedPath = resolvePath(filePath, context.workdir);
+    if (!context.readFileState?.has(resolvedPath)) {
       return {
         success: false,
         content: "",
@@ -125,8 +125,6 @@ Usage:
     }
 
     try {
-      const resolvedPath = resolvePath(filePath, context.workdir);
-
       // Read file content
       let originalContent: string;
       try {

package/src/utils/constants.ts

@@ -30,4 +30,4 @@ export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
  * AI related constants
  */
 export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 200000; // Default token limit
-export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 16384; // Default output token limit
+export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 32000; // Default output token limit (aligned with Claude Code)

package/src/utils/gitUtils.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import * as fsSync from "node:fs";
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 
 /**
  * Check if a directory is a git repository
@@ -31,7 +31,7 @@ export function isGitRepository(dirPath: string): string {
  */
 export function getGitRepoRoot(cwd: string): string {
   try {
-    return execSync("git rev-parse --show-toplevel", {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -48,7 +48,7 @@ export function getGitRepoRoot(cwd: string): string {
  */
 export function getGitCommonDir(cwd: string): string {
   try {
-    const commonDir = execSync("git rev-parse --git-common-dir", {
+    const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -66,7 +66,7 @@ export function getGitCommonDir(cwd: string): string {
  */
 export function getGitMainRepoRoot(cwd: string): string {
   try {
-    const output = execSync("git worktree list --porcelain", {
+    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -229,7 +229,7 @@ export function getDefaultRemoteBranch(cwd: string): string {
  */
 export function hasUncommittedChanges(cwd: string): boolean {
   try {
-    const status = execSync("git status --porcelain", {
+    const status = execFileSync("git", ["status", "--porcelain"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -249,7 +249,7 @@ export function hasUncommittedChanges(cwd: string): boolean {
 export function hasNewCommits(cwd: string, baseBranch?: string): boolean {
   try {
     const range = baseBranch ? `${baseBranch}..HEAD` : "@{u}..HEAD";
-    const log = execSync(`git log ${range} --oneline`, {
+    const log = execFileSync("git", ["log", range, "--oneline"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],

package/src/utils/openaiClient.ts

@@ -133,6 +133,7 @@ export class OpenAIClient {
         }
         if (attempt < MAX_RETRIES) {
           logger.warn("OpenAI API network error, retrying...", {
+            model: params.model,
             attempt: attempt + 1,
             error: e,
           });
@@ -166,37 +167,18 @@ export class OpenAIClient {
         }
       }
 
-      let errorBody: unknown;
+      let responseText = "";
       try {
-        const text = await response.text();
-        try {
-          errorBody = JSON.parse(text);
-        } catch (e) {
-          logger.error("Failed to parse error response body as JSON", {
-            error: e,
-            text,
-          });
-          errorBody = text;
-        }
+        responseText = await response.text();
       } catch (e) {
         logger.error("Failed to read error response text", { error: e });
-        errorBody = {};
       }
 
       const error = new Error(
-        typeof errorBody === "object" &&
-        errorBody !== null &&
-        "error" in errorBody &&
-        typeof (errorBody as { error: unknown }).error === "object" &&
-        (errorBody as { error: object }).error !== null &&
-        "message" in (errorBody as { error: { message: unknown } }).error
-          ? String((errorBody as { error: { message: string } }).error.message)
-          : typeof errorBody === "string"
-            ? errorBody
-            : response.statusText,
+        `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}: ${responseText}`,
       ) as Error & { status?: number; body?: unknown };
       error.status = response.status;
-      error.body = errorBody;
+      error.body = responseText;
 
       const retryableStatus =
         response.status === 429 ||
@@ -204,6 +186,7 @@ export class OpenAIClient {
       if (retryableStatus && attempt < MAX_RETRIES) {
         lastRetryAfter = response.headers.get("retry-after");
         logger.warn("OpenAI API error, retrying...", {
+          model: params.model,
           attempt: attempt + 1,
           status: response.status,
           retryAfter: lastRetryAfter,
@@ -215,7 +198,7 @@ export class OpenAIClient {
       logger.error("OpenAI API Error:", {
         status: response.status,
         statusText: response.statusText,
-        errorBody,
+        body: responseText,
       });
       throw error;
     }

package/src/utils/path.ts

@@ -54,3 +54,13 @@ export function getDisplayPath(filePath: string, workdir: string): string {
   }
   return filePath;
 }
+
+/**
+ * Convert backslashes to forward slashes for shell compatibility on Windows.
+ * On Windows, os.tmpdir() returns paths with backslashes (e.g., C:\Users\foo\Temp),
+ * which are treated as escape characters when interpolated into shell command strings.
+ * Returns the path as-is on non-Windows platforms.
+ */
+export function toPosixPath(p: string): string {
+  return process.platform === "win32" ? p.replace(/\\/g, "/") : p;
+}