wave-agent-sdk 0.19.7 → 0.19.9

package/src/services/aiService.ts

@@ -24,7 +24,6 @@ import * as fs from "fs";
 import * as path from "path";
 
 import {
-  COMPACT_MESSAGES_SYSTEM_PROMPT,
   WEB_CONTENT_SYSTEM_PROMPT,
   BTW_SYSTEM_PROMPT,
   type SystemPromptBlock,
@@ -169,6 +168,12 @@ export interface CallAgentOptions {
     | "required"
     | { type: "function"; function: { name: string } }; // Force tool selection
 
+  // Force SSE streaming independent of callback presence. Long-running
+  // non-interactive calls (e.g. the compaction fork) need streaming so a
+  // slow reasoning model isn't killed by a gateway idle timeout before the
+  // first byte arrives.
+  stream?: boolean;
+
   // NEW: Streaming callbacks
   onContentUpdate?: (content: string) => void;
   onToolUpdate?: (toolCall: {
@@ -319,11 +324,9 @@ export async function callAgent(
     });
 
     // Determine if streaming is needed
-    const isStreaming = !!(
-      onContentUpdate ||
-      onToolUpdate ||
-      onReasoningUpdate
-    );
+    const isStreaming =
+      options.stream === true ||
+      !!(onContentUpdate || onToolUpdate || onReasoningUpdate);
 
     // Prepare API call parameters
     createParams = {
@@ -787,128 +790,6 @@ async function processStreamingResponse(
   return result;
 }
 
-export interface CompactMessagesOptions {
-  // Resolved configuration
-  gatewayConfig: GatewayConfig;
-  modelConfig: ModelConfig;
-
-  // Existing parameters
-  messages: ChatCompletionMessageParam[];
-  abortSignal?: AbortSignal;
-  model?: string;
-  customInstructions?: string;
-}
-
-export interface CompactMessagesResult {
-  content: string;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
-
-export async function compactMessages(
-  options: CompactMessagesOptions,
-): Promise<CompactMessagesResult> {
-  const { gatewayConfig, modelConfig, messages, abortSignal } = options;
-
-  // Validate model config at call time
-  validateModelConfig(modelConfig);
-
-  // Apply global 1 QPS rate limit
-  if (
-    process.env.NODE_ENV !== "test" ||
-    modelConfig.model === "rate-limit-test"
-  ) {
-    await acquireSlot(abortSignal);
-  }
-
-  // Strip images from messages before compact API call to reduce token usage
-  const cleanedMessages = messages.map((msg) => {
-    // Handle user/assistant messages with array content
-    if (Array.isArray(msg.content)) {
-      const textParts = msg.content.filter(
-        (part) => part.type === "text",
-      ) as import("openai/resources.js").ChatCompletionContentPartText[];
-      const text = textParts.map((p) => p.text).join("\n");
-      return { ...msg, content: text || "(empty message)" };
-    }
-    return msg;
-  });
-
-  // Create OpenAI client with injected configuration
-  const openai = new OpenAIClient({
-    apiKey: gatewayConfig.apiKey,
-    baseURL: gatewayConfig.baseURL,
-    defaultHeaders: gatewayConfig.defaultHeaders,
-    fetchOptions: gatewayConfig.fetchOptions,
-    fetch: gatewayConfig.fetch,
-  });
-
-  // When a fast model override is provided, use the fast model's options
-  // (if configured); otherwise fall back to the agent model's options.
-  const activeExtraParams = options.model
-    ? modelConfig.fastModelOptions || {}
-    : modelConfig.options || {};
-
-  const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
-    temperature: 0.1,
-    max_tokens: 8192,
-    ...activeExtraParams,
-  });
-
-  try {
-    const response = await openai.chat.completions.create(
-      {
-        ...openaiModelConfig,
-        messages: [
-          {
-            role: "system",
-            content: COMPACT_MESSAGES_SYSTEM_PROMPT,
-          },
-          ...cleanedMessages,
-          {
-            role: "user",
-            content: options.customInstructions
-              ? `Please create a detailed summary of the conversation so far. Pay special attention to these instructions: ${options.customInstructions}`
-              : `Please create a detailed summary of the conversation so far.`,
-          },
-        ],
-      },
-      {
-        signal: abortSignal,
-      },
-    );
-
-    const content = response.choices[0]?.message?.content?.trim();
-    if (!content) {
-      throw new Error(
-        "Failed to compact conversation history: Empty response from AI",
-      );
-    }
-    const usage = response.usage
-      ? {
-          prompt_tokens: response.usage.prompt_tokens,
-          completion_tokens: response.usage.completion_tokens,
-          total_tokens: response.usage.total_tokens,
-        }
-      : undefined;
-
-    return {
-      content,
-      usage,
-    };
-  } catch (error) {
-    if ((error as Error).name === "AbortError") {
-      logger.info("Compaction request was aborted");
-      throw new Error("Compaction request was aborted");
-    }
-    logger.error("Failed to compact messages:", error);
-    throw error;
-  }
-}
-
 export interface ProcessWebContentOptions {
   // Resolved configuration
   gatewayConfig: GatewayConfig;

package/src/services/configurationService.ts

@@ -320,6 +320,23 @@ export class ConfigurationService {
       }
     }
 
+    // Validate worktree if present
+    if (config.worktree !== undefined) {
+      if (typeof config.worktree !== "object" || config.worktree === null) {
+        result.isValid = false;
+        result.errors.push("worktree configuration must be an object");
+      } else if (
+        config.worktree.baseRef !== undefined &&
+        config.worktree.baseRef !== "fresh" &&
+        config.worktree.baseRef !== "head"
+      ) {
+        result.isValid = false;
+        result.errors.push(
+          `Invalid worktree.baseRef: "${config.worktree.baseRef}". Must be "fresh" or "head".`,
+        );
+      }
+    }
+
     return result;
   }
 
@@ -640,6 +657,19 @@ export class ConfigurationService {
     return true;
   }
 
+  /**
+   * Resolves worktree base ref with fallbacks
+   * Resolution priority: settings.json > default ("fresh")
+   * @returns Resolved worktree base ref
+   */
+  resolveWorktreeBaseRef(): "fresh" | "head" {
+    const baseRef = this.currentConfiguration?.worktree?.baseRef;
+    if (baseRef === "head") {
+      return "head";
+    }
+    return "fresh";
+  }
+
   /**
    * Resolves auto-memory extraction frequency with fallbacks
    * Resolution priority: settings.json > WAVE_AUTO_MEMORY_FREQUENCY > default (1)
@@ -1172,6 +1202,7 @@ export function loadWaveConfigFromFile(
           : undefined,
       models: config.models || undefined,
       marketplaces: config.marketplaces || undefined,
+      worktree: config.worktree || undefined,
     };
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -1320,6 +1351,11 @@ export function loadMergedWaveConfig(
       Object.assign(mergedConfig.marketplaces, config.marketplaces);
     }
 
+    // Merge worktree (last one wins)
+    if (config.worktree !== undefined) {
+      mergedConfig.worktree = config.worktree;
+    }
+
     // Merge models
     if (config.models) {
       if (!mergedConfig.models) mergedConfig.models = {};
@@ -1363,5 +1399,6 @@ export function loadMergedWaveConfig(
       mergedConfig.models && Object.keys(mergedConfig.models).length > 0
         ? mergedConfig.models
         : undefined,
+    worktree: mergedConfig.worktree,
   };
 }

package/src/services/remoteSettingsService.ts

@@ -326,6 +326,7 @@ export function mergeRemoteSettings(
     result.autoMemoryEnabled = remote.autoMemoryEnabled;
   if (remote.autoMemoryFrequency !== undefined)
     result.autoMemoryFrequency = remote.autoMemoryFrequency;
+  if (remote.worktree !== undefined) result.worktree = remote.worktree;
   if (remote.models !== undefined) result.models = remote.models;
   if (remote.marketplaces !== undefined)
     result.marketplaces = remote.marketplaces;

package/src/services/session.ts

@@ -825,7 +825,9 @@ export async function handleSessionRestoration(
 /**
  * Load the full message thread for a session.
  * With append-only compaction, all messages are in a single file.
- * Returns the active messages (post-compact boundary).
+ * Unlike loadSessionFromJsonl, this returns every message in the file,
+ * including those before the last compact boundary — rewind needs the
+ * complete history to allow rewinding past compaction points.
  * @param currentSessionId - The ID of the current session
  * @param workdir - Working directory for the session
  * @returns Promise that resolves to an array of all messages in the thread
@@ -834,7 +836,19 @@ export async function loadFullMessageThread(
   currentSessionId: string,
   workdir: string,
 ): Promise<{ messages: Message[]; sessionIds: string[] }> {
-  const sessionData = await loadSessionFromJsonl(currentSessionId, workdir);
-  if (!sessionData) return { messages: [], sessionIds: [] };
-  return { messages: sessionData.messages, sessionIds: [currentSessionId] };
+  const jsonlHandler = new JsonlHandler();
+  const filePath = await generateSessionFilePath(
+    currentSessionId,
+    workdir,
+    "main",
+  );
+
+  try {
+    await fs.access(filePath);
+  } catch {
+    return { messages: [], sessionIds: [] };
+  }
+
+  const messages = await jsonlHandler.read(filePath);
+  return { messages, sessionIds: [currentSessionId] };
 }

package/src/services/taskManager.ts

@@ -71,6 +71,7 @@ export class TaskManager extends EventEmitter {
     let lockHandle;
     const maxRetries = 100;
     const retryDelay = process.env.NODE_ENV === "test" ? 1 : 100;
+    const staleThreshold = 10000;
 
     await this.ensureSessionDir();
 
@@ -79,16 +80,41 @@ export class TaskManager extends EventEmitter {
         lockHandle = await fs.open(lockPath, "wx");
         break;
       } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "EEXIST") {
-          if (i === maxRetries - 1) {
-            throw new Error(
-              `Could not acquire lock for task list ${this.taskListId} after ${maxRetries} retries`,
-            );
+        const code = (error as NodeJS.ErrnoException).code;
+
+        // Only EEXIST (lock held) and EPERM (Windows pending-delete window)
+        // are transient lock-contention errors. EACCES/ENOENT are real failures
+        // and must not be retried as lock competition.
+        if (code !== "EEXIST" && code !== "EPERM") {
+          throw error;
+        }
+
+        if (i === maxRetries - 1) {
+          throw new Error(
+            `Could not acquire lock for task list ${this.taskListId} after ${maxRetries} retries`,
+          );
+        }
+
+        // Stale recovery: if the lock holder crashed without releasing, the
+        // lock file remains forever. Check mtime — if older than the threshold,
+        // remove it. Aligns with proper-lockfile's default 10s stale detection.
+        // The lock file is empty (no PID content), so mtime is the only signal.
+        if (
+          code === "EEXIST" &&
+          (await this.isLockStale(lockPath, staleThreshold))
+        ) {
+          logger.warn(
+            `TaskManager: removing stale lock for task list ${this.taskListId}`,
+          );
+          try {
+            await fs.unlink(lockPath);
+          } catch {
+            // Another waiter may have already removed it — retry anyway
           }
-          await new Promise((resolve) => setTimeout(resolve, retryDelay));
           continue;
         }
-        throw error;
+
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
       }
     }
 
@@ -109,6 +135,19 @@ export class TaskManager extends EventEmitter {
     }
   }
 
+  private async isLockStale(
+    lockPath: string,
+    threshold: number,
+  ): Promise<boolean> {
+    try {
+      const stats = await fs.stat(lockPath);
+      return Date.now() - stats.mtimeMs > threshold;
+    } catch {
+      // Lock was removed between our EEXIST and stat — not stale, just retry
+      return false;
+    }
+  }
+
   private validateTask(task: Task): void {
     if (!task.id || typeof task.id !== "string")
       throw new Error("Invalid task ID");

package/src/tools/editTool.ts

@@ -114,9 +114,14 @@ Usage:
 
     // 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.
+    // of truth, aligned with Claude Code's readFileState approach. Skipped in
+    // plan mode: permissionManager enforces a plan-file-only gate whose denial
+    // message must surface instead of being masked by a read-state rejection.
     const resolvedPath = resolvePath(filePath, context.workdir);
-    if (!context.readFileState?.has(resolvedPath)) {
+    if (
+      context.permissionMode !== "plan" &&
+      !context.readFileState?.has(resolvedPath)
+    ) {
       return {
         success: false,
         content: "",
@@ -137,18 +142,31 @@ Usage:
         };
       }
 
-      // Staleness check: file must not have been modified since last Read
-      if (context.readFileState) {
+      // Staleness check (aligned with Claude Code): only flag when the file got
+      // newer since last read. For full reads, a content-hash fallback avoids
+      // false positives when mtime changed but content didn't (git checkout,
+      // editor round-trip save, cloud sync, antivirus). Partial reads get no
+      // fallback since only a slice was cached. Skipped in plan mode (see
+      // read-before-edit note above) so the plan-file-only denial wins.
+      if (context.permissionMode !== "plan" && context.readFileState) {
         const state = context.readFileState.get(resolvedPath);
         if (state) {
           const currentStats = await stat(resolvedPath);
-          if (currentStats.mtime.getTime() !== state.mtime) {
-            return {
-              success: false,
-              content: "",
-              error:
-                "File has been unexpectedly modified since last read. Read it again before editing it.",
-            };
+          if (currentStats.mtime.getTime() > state.mtime) {
+            const isFullRead =
+              state.offset === undefined && state.limit === undefined;
+            const contentUnchanged =
+              isFullRead &&
+              createHash("sha256").update(originalContent).digest("hex") ===
+                state.hash;
+            if (!contentUnchanged) {
+              return {
+                success: false,
+                content: "",
+                error:
+                  "File has been unexpectedly modified since last read. Read it again before editing it.",
+              };
+            }
           }
         }
       }

package/src/tools/enterWorktreeTool.ts

@@ -102,7 +102,8 @@ export const enterWorktreeTool: ToolPlugin = {
     }
 
     // Create the worktree (captures originalHeadCommit internally)
-    const worktreeInfo = createWorktree(name, mainRepoRoot);
+    const baseRef = context.aiManager?.getWorktreeBaseRef?.();
+    const worktreeInfo = createWorktree(name, mainRepoRoot, { baseRef });
 
     // Build session state
     const session: WorktreeSession = {

package/src/tools/grepTool.ts

@@ -2,6 +2,7 @@ import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { spawn } from "child_process";
 import { rgPath } from "../utils/ripgrep.js";
 import { getDisplayPath } from "../utils/path.js";
+import { logger } from "../utils/globalLogger.js";
 import {
   GREP_TOOL_NAME,
   BASH_TOOL_NAME,
@@ -235,8 +236,10 @@ export const grepTool: ToolPlugin = {
 
       const result = await executeCommand(rgPath, rgArgs, workdir);
 
-      if (result.error && result.exitCode !== 1) {
-        // rg returns 1 for no matches, not an error
+      // Only a process-level spawn failure (exitCode null) is a hard error.
+      // rg exit 2 means some files were unreadable (e.g. device-name files
+      // like "nul" on Windows); stdout still holds usable partial results.
+      if (result.exitCode === null) {
         return {
           success: false,
           content: "",
@@ -244,6 +247,12 @@ export const grepTool: ToolPlugin = {
         };
       }
 
+      if (result.exitCode !== 0 && result.exitCode !== 1) {
+        logger.debug(
+          `ripgrep exited with code ${result.exitCode}, keeping partial results: ${result.stderr.trim()}`,
+        );
+      }
+
       const output = result.stdout.trim();
       if (!output) {
         return {

package/src/tools/writeTool.ts

@@ -86,6 +86,49 @@ Usage:
         isExistingFile = false;
       }
 
+      // Read-before-write + staleness guards (aligned with Claude Code).
+      // Only enforced for existing files when readFileState is available
+      // (production always injects it; new-file creation always bypasses).
+      // Grep does not register a file as read, so Grep-then-Write on an
+      // existing file is still rejected. Staleness uses the same `>` + full-
+      // read content-hash fallback as editTool to avoid false positives from
+      // git checkout / editor round-trip save / cloud sync / antivirus.
+      // Plan mode is excluded: it has its own stricter write gate (plan-file-
+      // only, enforced in permissionManager) whose denial message must surface
+      // instead of being masked by a read-state rejection.
+      if (
+        isExistingFile &&
+        context.readFileState &&
+        context.permissionMode !== "plan"
+      ) {
+        const state = context.readFileState.get(resolvedPath);
+        if (!state) {
+          return {
+            success: false,
+            content: "",
+            error:
+              "File has not been read yet. Read it first before writing to it.",
+          };
+        }
+        const currentStats = await stat(resolvedPath);
+        if (currentStats.mtime.getTime() > state.mtime) {
+          const isFullRead =
+            state.offset === undefined && state.limit === undefined;
+          const contentUnchanged =
+            isFullRead &&
+            createHash("sha256").update(originalContent).digest("hex") ===
+              state.hash;
+          if (!contentUnchanged) {
+            return {
+              success: false,
+              content: "",
+              error:
+                "File has been unexpectedly modified since last read. Read it again before writing to it.",
+            };
+          }
+        }
+      }
+
       // Check if overwriting existing file but content is the same
       if (isExistingFile && originalContent === content) {
         return {

package/src/types/configuration.ts

@@ -54,6 +54,11 @@ export interface WaveConfiguration {
   monitoring?: {
     telemetry?: Partial<TelemetryConfig>;
   };
+  /** Worktree configuration */
+  worktree?: {
+    /** Base ref for new worktrees: "fresh" (origin/<default-branch>, default) | "head" (local HEAD) */
+    baseRef?: "fresh" | "head";
+  };
 }
 
 /**

package/src/types/permissions.ts

@@ -35,8 +35,6 @@ export interface PermissionDecision {
   newPermissionMode?: PermissionMode;
   /** Signal to persist a new allowed rule */
   newPermissionRule?: string;
-  /** Signal to clear the conversation context and proceed with the plan */
-  clearContext?: boolean;
 }
 
 /** Callback function for custom permission logic */

package/src/types/processes.ts

@@ -59,6 +59,35 @@ export type BackgroundTask =
   | BackgroundSubagent
   | BackgroundWorkflow;
 
+/**
+ * Serializable summary of a BackgroundTask, used for notifications where the
+ * full stdout/stderr and non-serializable process/onStop fields must be
+ * stripped to control payload size. Output is fetched on demand via
+ * getBackgroundTaskOutput.
+ */
+export interface BackgroundTaskSummary {
+  id: string;
+  type: BackgroundTaskType;
+  status: BackgroundTaskStatus;
+  startTime: number;
+  endTime?: number;
+  command?: string;
+  description?: string;
+  exitCode?: number;
+  runtime?: number;
+  outputPath?: string;
+}
+
+/** Output snapshot returned by getBackgroundTaskOutput. */
+export interface BackgroundTaskOutput {
+  stdout: string;
+  stderr: string;
+  status: BackgroundTaskStatus;
+  outputPath?: string;
+  type: BackgroundTaskType;
+  exitCode?: number;
+}
+
 export interface ForegroundTask {
   id: string;
   backgroundHandler: () => Promise<void>;

package/src/types/workflow.ts

@@ -2,4 +2,5 @@ export type {
   WorkflowRun,
   WorkflowMeta,
   WorkflowPhaseState,
+  SerializableWorkflowRun,
 } from "../workflow/types.js";