wave-agent-sdk 1.0.10 → 1.1.1

package/dist/managers/backgroundTaskManager.js

@@ -61,6 +61,13 @@ export class BackgroundTaskManager {
         // Create log file
         const logPath = path.join(os.tmpdir(), `wave-task-${id}.log`);
         const logStream = fs.createWriteStream(logPath, { flags: "w" });
+        // A failed open/write of the log file (e.g. EBUSY on Windows when a stale
+        // handle from a previous run still locks the temp file) must not surface as
+        // an uncaught stream error — the log is best-effort side output and the
+        // task itself keeps running regardless.
+        logStream.on("error", (error) => {
+            logger.warn(`Failed to write background task log ${logPath}:`, error);
+        });
         const shell = {
             id,
             type: "shell",
@@ -232,6 +239,11 @@ export class BackgroundTaskManager {
         // Create log file
         const logPath = path.join(os.tmpdir(), `wave-task-${id}.log`);
         const logStream = fs.createWriteStream(logPath, { flags: "w" });
+        // Same best-effort handling as startShell: a locked temp file (EBUSY on
+        // Windows) must not become an uncaught stream error.
+        logStream.on("error", (error) => {
+            logger.warn(`Failed to write background task log ${logPath}:`, error);
+        });
         // Write initial output to log file
         if (initialStdout) {
             logStream.write(stripAnsiColors(initialStdout));

package/dist/managers/pluginScopeManager.js

@@ -32,15 +32,23 @@ export class PluginScopeManager {
      * Priority: local > project > user
      */
     findPluginScope(pluginId) {
-        const projectPaths = this.configurationService.getConfigurationPaths(this.workdir).projectPaths; // [local, json]
-        const userPaths = this.configurationService.getConfigurationPaths(this.workdir).userPaths; // [local, json]
+        const { projectPaths, userPaths } = this.configurationService.getConfigurationPaths(this.workdir);
+        const userPathSet = new Set(userPaths);
+        // When the workdir is the user's home directory, projectPaths overlaps
+        // userPaths (both point at ~/.wave/settings.json). Treat such a file as the
+        // user config, otherwise user-scope plugins would be mislabeled "project".
         const checkPaths = [
             { path: projectPaths[0], scope: "local" },
-            { path: projectPaths[1], scope: "project" },
-            { path: userPaths[0], scope: "user" }, // user local is still user scope
-            { path: userPaths[1], scope: "user" },
+            ...(userPathSet.has(projectPaths[1])
+                ? []
+                : [{ path: projectPaths[1], scope: "project" }]),
+            ...userPaths.map((path) => ({ path, scope: "user" })),
         ];
+        const seen = new Set();
         for (const { path, scope } of checkPaths) {
+            if (!path || seen.has(path))
+                continue;
+            seen.add(path);
             const config = this.configurationService.loadWaveConfigFromFile(path);
             if (config?.enabledPlugins && pluginId in config.enabledPlugins) {
                 return scope;

package/dist/managers/subagentManager.d.ts

@@ -75,6 +75,7 @@ export declare class SubagentManager {
     private stream;
     constructor(container: Container, options: SubagentManagerOptions);
     private get configurationService();
+    private get asyncWorkRegistry();
     /**
      * Initialize the SubagentManager by loading and caching configurations
      */

package/dist/managers/subagentManager.js

@@ -23,6 +23,9 @@ export class SubagentManager {
     get configurationService() {
         return this.container.get("ConfigurationService");
     }
+    get asyncWorkRegistry() {
+        return this.container.get("AsyncWorkRegistry");
+    }
     /**
      * Initialize the SubagentManager by loading and caching configurations
      */
@@ -331,7 +334,7 @@ export class SubagentManager {
                 instance.backgroundTaskId = taskId;
                 // Execute in background
                 // Note: notification enqueueing is handled by internalExecute when instance.backgroundTaskId is set
-                (async () => {
+                const backgroundPromise = (async () => {
                     try {
                         const result = await this.internalExecute(instance, prompt, abortSignal);
                         const task = backgroundTaskManager?.getTask(taskId);
@@ -360,6 +363,7 @@ export class SubagentManager {
                         this.releaseInstance(instance.subagentId);
                     }
                 })();
+                this.asyncWorkRegistry?.track(backgroundPromise);
                 return taskId;
             }
             const result = await this.internalExecute(instance, prompt, abortSignal);

package/dist/services/GitService.js

@@ -1,6 +1,6 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 export class GitService {
     getTimeout() {
         const envTimeout = process.env.WAVE_PLUGIN_GIT_TIMEOUT_MS;
@@ -17,7 +17,7 @@ export class GitService {
      */
     async isGitAvailable() {
         try {
-            await execAsync("git --version");
+            await execFileAsync("git", ["--version"]);
             return true;
         }
         catch {
@@ -43,8 +43,8 @@ export class GitService {
             url = `https://github.com/${urlOrRepo}.git`;
         }
         try {
-            const refArgs = ref ? `-b "${ref}"` : "--depth 1";
-            await execAsync(`git clone ${refArgs} "${url}" "${targetPath}"`, {
+            const refArgs = ref ? ["-b", ref] : ["--depth", "1"];
+            await execFileAsync("git", ["clone", ...refArgs, url, targetPath], {
                 env: { ...process.env, LC_ALL: "C" },
                 timeout: this.getTimeout(),
             });
@@ -64,7 +64,7 @@ export class GitService {
             throw new Error("Git is not installed or not found in PATH. Please install Git to use Git/GitHub marketplaces.");
         }
         try {
-            await execAsync(`git -C "${targetPath}" pull`, {
+            await execFileAsync("git", ["-C", targetPath, "pull"], {
                 env: { ...process.env, LC_ALL: "C" },
                 timeout: this.getTimeout(),
             });

package/dist/services/aiService.js

@@ -4,6 +4,7 @@ import { addOnceAbortListener } from "../utils/abortUtils.js";
 import { ConfigurationError, CONFIG_ERRORS } from "../types/index.js";
 import { transformMessagesForExplicitCache, extendUsageWithCacheMetrics, } from "../utils/cacheControlUtils.js";
 import { supportsPromptCaching } from "../utils/modelCapabilities.js";
+import { DEFAULT_WAVE_MAX_OUTPUT_TOKENS } from "../utils/constants.js";
 import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
@@ -110,8 +111,11 @@ export async function callAgent(options) {
             fetchOptions: gatewayConfig.fetchOptions,
             fetch: gatewayConfig.fetch,
         });
-        // Determine model early (needed for system prompt construction)
-        const resolvedMaxTokens = options.maxTokens ?? modelConfig.maxTokens;
+        // Determine model early (needed for system prompt construction).
+        // Per-model overrides come from modelConfig.options.max_tokens (spread
+        // after this default below); callers pass the resolved global value
+        // (AgentOptions.maxTokens / WAVE_MAX_OUTPUT_TOKENS) via options.maxTokens.
+        const resolvedMaxTokens = options.maxTokens ?? DEFAULT_WAVE_MAX_OUTPUT_TOKENS;
         // Build system message content
         let systemMessage;
         if (Array.isArray(systemPrompt)) {

package/dist/services/configurationService.d.ts

@@ -79,19 +79,19 @@ export declare class ConfigurationService {
      * Resolution priority: override > options > env (from settings.json) > process.env > default
      * @param model - Agent model override (optional)
      * @param fastModel - Fast model override (optional)
-     * @param maxTokens - Max output tokens override (optional)
      * @param permissionMode - Permission mode override (optional)
      * @param visionModel - Vision model override (optional)
      * @returns Resolved model configuration with defaults
      */
-    resolveModelConfig(model?: string, fastModel?: string, maxTokens?: number, permissionMode?: PermissionMode, visionModel?: string): ModelConfig;
+    resolveModelConfig(model?: string, fastModel?: string, permissionMode?: PermissionMode, visionModel?: string): ModelConfig;
     /**
      * Resolves token limit with fallbacks
-     * Resolution priority: override > options > env (from settings.json) > process.env > default
+     * Resolution priority: override > options > models[model].maxInputTokens > env (from settings.json) > process.env > default
      * @param constructorLimit - Token limit override (optional)
+     * @param model - Model to resolve per-model maxInputTokens for (optional; falls back to the resolved agent model chain)
      * @returns Resolved token limit
      */
-    resolveMaxInputTokens(constructorLimit?: number): number;
+    resolveMaxInputTokens(constructorLimit?: number, model?: string): number;
     /**
      * Resolves preferred language with fallbacks
      * Resolution priority: override > options > settings.json > undefined

package/dist/services/configurationService.js

@@ -457,12 +457,11 @@ export class ConfigurationService {
      * Resolution priority: override > options > env (from settings.json) > process.env > default
      * @param model - Agent model override (optional)
      * @param fastModel - Fast model override (optional)
-     * @param maxTokens - Max output tokens override (optional)
      * @param permissionMode - Permission mode override (optional)
      * @param visionModel - Vision model override (optional)
      * @returns Resolved model configuration with defaults
      */
-    resolveModelConfig(model, fastModel, maxTokens, permissionMode, visionModel) {
+    resolveModelConfig(model, fastModel, permissionMode, visionModel) {
         // Resolve agent model: override > options > currentConfiguration (settings.json model, possibly remote-merged) > process.env
         // Priority: user's explicit model field > admin's env.WAVE_MODEL default.
         // If admin wants hard enforcement, they set the `model` scalar field (overwrites local in mergeRemoteSettings).
@@ -478,13 +477,10 @@ export class ConfigurationService {
         const resolvedVisionModel = visionModel ||
             this.options.visionModel ||
             (this.envSnapshot.WAVE_VISION_MODEL ?? process.env.WAVE_VISION_MODEL);
-        // Resolve max output tokens
-        const resolvedMaxTokens = this.resolveMaxOutputTokens(maxTokens);
         const baseConfig = {
             model: resolvedAgentModel,
             fastModel: resolvedFastModel,
             visionModel: resolvedVisionModel,
-            maxTokens: resolvedMaxTokens,
             permissionMode: permissionMode ?? this.options.permissionMode,
         };
         // Resolve fast model generation params from models[fastModel].options.
@@ -520,11 +516,12 @@ export class ConfigurationService {
     }
     /**
      * Resolves token limit with fallbacks
-     * Resolution priority: override > options > env (from settings.json) > process.env > default
+     * Resolution priority: override > options > models[model].maxInputTokens > env (from settings.json) > process.env > default
      * @param constructorLimit - Token limit override (optional)
+     * @param model - Model to resolve per-model maxInputTokens for (optional; falls back to the resolved agent model chain)
      * @returns Resolved token limit
      */
-    resolveMaxInputTokens(constructorLimit) {
+    resolveMaxInputTokens(constructorLimit, model) {
         // If override value provided, use it
         if (constructorLimit !== undefined) {
             return constructorLimit;
@@ -533,6 +530,16 @@ export class ConfigurationService {
         if (this.options.maxInputTokens !== undefined) {
             return this.options.maxInputTokens;
         }
+        // Per-model config (models[X].maxInputTokens). Resolve the model with the
+        // same chain as resolveModelConfig: caller > options > currentConfiguration > env.
+        const resolvedModel = model ||
+            this.options.model ||
+            this.currentConfiguration?.model ||
+            (this.envSnapshot.WAVE_MODEL ?? process.env.WAVE_MODEL);
+        const modelConfig = resolvedModel && this.currentConfiguration?.models?.[resolvedModel];
+        if (modelConfig && modelConfig.maxInputTokens !== undefined) {
+            return modelConfig.maxInputTokens;
+        }
         // Try env (settings.json snapshot) first, then process.env
         const envMaxInputTokens = this.envSnapshot.WAVE_MAX_INPUT_TOKENS ??
             process.env.WAVE_MAX_INPUT_TOKENS;

package/dist/services/hook.js

@@ -7,6 +7,8 @@
  */
 import { spawn } from "child_process";
 import { generateSessionFilePath } from "./session.js";
+import { resolveShellPath } from "../utils/shellResolver.js";
+import { toPosixCommand } from "../utils/windowsPaths.js";
 // =============================================================================
 // Hook Execution Functions
 // =============================================================================
@@ -56,10 +58,10 @@ async function buildHookJsonInput(context) {
     if (context.subagentType !== undefined) {
         jsonInput.subagent_type = context.subagentType;
     }
-    // Add name field for WorktreeCreate events
+    // Add name field for WorktreeCreate events (aligned with Claude Code)
     if (context.event === "WorktreeCreate") {
-        if (context.worktreeName !== undefined) {
-            jsonInput.name = context.worktreeName;
+        if (context.name !== undefined) {
+            jsonInput.name = context.name;
         }
     }
     // Add worktree_path field for WorktreeRemove events
@@ -133,11 +135,43 @@ export async function executeCommand(command, context, options) {
         let stdout = "";
         let stderr = "";
         let timedOut = false;
-        // Parse command for shell execution
+        // Parse command for shell execution.
+        //
+        // Windows uses Git Bash (POSIX shell) instead of cmd.exe: cmd.exe's `/c`
+        // does not strip quotes from arguments after the first token, so commands
+        // like `node "C:\path\script.js"` silently fail (issue #1773). Git Bash
+        // parses quotes correctly, and Windows paths in the command are converted
+        // to POSIX form first (Git Bash resolves `/c/Users/...` and translates it
+        // back to a Windows path when spawning native executables like node.exe).
+        // Falls back to cmd.exe when no Git Bash is installed.
         const isWindows = process.platform === "win32";
-        const shell = isWindows ? "cmd.exe" : "/bin/sh";
-        const shellFlag = isWindows ? "/c" : "-c";
-        const childProcess = spawn(shell, [shellFlag, command], {
+        const bashPath = isWindows ? resolveShellPath() : undefined;
+        let shell;
+        let shellFlag;
+        let finalCommand;
+        if (bashPath) {
+            shell = bashPath;
+            shellFlag = "-c";
+            finalCommand = toPosixCommand(command);
+            // Windows .sh scripts aren't directly executable — run them via bash
+            // when the command itself is a .sh file (e.g. `${WAVE_PLUGIN_ROOT}/x.sh`).
+            const trimmed = finalCommand.trim();
+            const firstToken = trimmed.match(/^("([^"]*)"|'([^']*)'|\S+)/)?.[0] ?? "";
+            if (firstToken.endsWith(".sh") && !trimmed.startsWith("bash ")) {
+                finalCommand = `bash ${finalCommand}`;
+            }
+        }
+        else if (isWindows) {
+            shell = "cmd.exe";
+            shellFlag = "/c";
+            finalCommand = command;
+        }
+        else {
+            shell = "/bin/sh";
+            shellFlag = "-c";
+            finalCommand = command;
+        }
+        const childProcess = spawn(shell, [shellFlag, finalCommand], {
             stdio: ["pipe", "pipe", "pipe"],
             cwd: context.projectDir,
             env: {

package/dist/services/initializationService.js

@@ -127,27 +127,6 @@ export class InitializationService {
         catch (error) {
             logger?.warn("SessionStart hooks execution failed:", error);
         }
-        // Trigger WorktreeCreate hook if this is a new worktree
-        if (agentOptions.isNewWorktree && hookManager) {
-            try {
-                logger?.info(`Triggering WorktreeCreate hook for ${agentOptions.worktreeName}...`);
-                const hookResults = await hookManager.executeHooks("WorktreeCreate", {
-                    event: "WorktreeCreate",
-                    projectDir: workdir,
-                    timestamp: new Date(),
-                    sessionId: messageManager.getSessionId(),
-                    transcriptPath: messageManager.getTranscriptPath(),
-                    cwd: workdir,
-                    worktreeName: agentOptions.worktreeName,
-                    env: Object.fromEntries(Object.entries(configurationService.getMergedEnv()).filter((e) => e[1] !== undefined)),
-                });
-                // Process hook results
-                hookManager.processHookResults("WorktreeCreate", hookResults, messageManager);
-            }
-            catch (error) {
-                logger?.warn("WorktreeCreate hooks execution failed:", error);
-            }
-        }
         // Resolve and validate configuration after loading settings.json
         resolveAndValidateConfig();
         // Initialize auto-memory directory

package/dist/services/jsonlHandler.d.ts

@@ -10,6 +10,20 @@ import type { SessionFilename } from "../types/session.js";
 export interface JsonlWriteOptions {
     atomic?: boolean;
 }
+/**
+ * Creation-time metadata persisted in the session file's header line
+ * (`{"type":"metadata",...}`). The header is append-only — written once on
+ * session creation and never rewritten — so only fields that are fixed at
+ * creation time belong here.
+ */
+export interface SessionMetadataHeader {
+    /** Real working directory (the encoded project dir name is lossy for paths containing "-"). */
+    workdir?: string;
+    /** ISO 8601 creation timestamp. */
+    createdAt?: string;
+    /** Git branch at creation time (`git branch --show-current`), when the directory is a git repo. */
+    gitBranch?: string;
+}
 /**
  * JSONL handler class for message persistence operations
  */
@@ -17,9 +31,20 @@ export declare class JsonlHandler {
     private readonly defaultWriteOptions;
     constructor();
     /**
-     * Create a new session file (simplified - no metadata header)
+     * Create a new session file.
+     *
+     * When `metadata` is provided, the first line is a metadata header
+     * recording creation-time facts about the session:
+     * `{"type":"metadata","workdir":...,"createdAt":...,"gitBranch":...}`. The
+     * encoded project dir name is lossy for paths containing "-", so persisting
+     * the real path lets session listing show it without decoding; `createdAt`
+     * and `gitBranch` similarly avoid lossy/fabricated reconstruction later.
+     * The header carries no `timestamp`, so message readers filter it out
+     * naturally.
+     *
+     * Legacy callers that omit `metadata` still get an empty file.
      */
-    createSession(filePath: string): Promise<void>;
+    createSession(filePath: string, metadata?: SessionMetadataHeader): Promise<void>;
     /**
      * Append a single message to JSONL file
      */
@@ -40,6 +65,16 @@ export declare class JsonlHandler {
      * Get the last message from JSONL file using efficient file reading (simplified)
      */
     getLastMessage(filePath: string): Promise<Message | null>;
+    /**
+     * Read the creation-time metadata from the session file's header line.
+     *
+     * Newer session files start with a `{"type":"metadata",...}` line (see
+     * `createSession`). Legacy files have no header.
+     *
+     * @param filePath - Path to the session JSONL file
+     * @returns The persisted metadata, or null when the file has no header
+     */
+    readMetadata(filePath: string): Promise<SessionMetadataHeader | null>;
     /**
      * Validate messages before writing
      */

package/dist/services/jsonlHandler.js

@@ -4,7 +4,7 @@
  */
 import { appendFile, readFile, writeFile, stat, mkdir } from "fs/promises";
 import { dirname } from "path";
-import { getLastLine } from "../utils/fileUtils.js";
+import { getLastLine, readFirstNLines } from "../utils/fileUtils.js";
 /**
  * JSONL handler class for message persistence operations
  */
@@ -15,13 +15,26 @@ export class JsonlHandler {
         };
     }
     /**
-     * Create a new session file (simplified - no metadata header)
+     * Create a new session file.
+     *
+     * When `metadata` is provided, the first line is a metadata header
+     * recording creation-time facts about the session:
+     * `{"type":"metadata","workdir":...,"createdAt":...,"gitBranch":...}`. The
+     * encoded project dir name is lossy for paths containing "-", so persisting
+     * the real path lets session listing show it without decoding; `createdAt`
+     * and `gitBranch` similarly avoid lossy/fabricated reconstruction later.
+     * The header carries no `timestamp`, so message readers filter it out
+     * naturally.
+     *
+     * Legacy callers that omit `metadata` still get an empty file.
      */
-    async createSession(filePath) {
+    async createSession(filePath, metadata) {
         // Ensure directory exists
         await this.ensureDirectory(dirname(filePath));
-        // Create empty file (no metadata line needed)
-        await writeFile(filePath, "", "utf8");
+        const content = metadata && Object.keys(metadata).length > 0
+            ? `${JSON.stringify({ type: "metadata", ...metadata })}\n`
+            : "";
+        await writeFile(filePath, content, "utf8");
     }
     /**
      * Append a single message to JSONL file
@@ -83,11 +96,14 @@ export class JsonlHandler {
                 return [];
             }
             const allMessages = [];
-            // Parse all messages (no metadata line to skip)
+            // Parse all messages, skipping the metadata header line (if any)
             for (let i = 0; i < lines.length; i++) {
                 const line = lines[i];
                 try {
                     const message = JSON.parse(line);
+                    // Metadata header line: not a message, skip
+                    if (message.type === "metadata")
+                        continue;
                     if (message.timestamp)
                         allMessages.push(message);
                 }
@@ -127,6 +143,10 @@ export class JsonlHandler {
             }
             try {
                 const parsed = JSON.parse(lastLine);
+                // A file whose only line is the metadata header has no messages yet
+                if (parsed.type === "metadata") {
+                    return null;
+                }
                 return parsed;
             }
             catch (error) {
@@ -137,6 +157,35 @@ export class JsonlHandler {
             throw new Error(`Failed to get last message from "${filePath}": ${error}`);
         }
     }
+    /**
+     * Read the creation-time metadata from the session file's header line.
+     *
+     * Newer session files start with a `{"type":"metadata",...}` line (see
+     * `createSession`). Legacy files have no header.
+     *
+     * @param filePath - Path to the session JSONL file
+     * @returns The persisted metadata, or null when the file has no header
+     */
+    async readMetadata(filePath) {
+        try {
+            const lines = await readFirstNLines(filePath, 1);
+            if (lines.length === 0) {
+                return null;
+            }
+            const header = JSON.parse(lines[0]);
+            if (header?.type === "metadata") {
+                return {
+                    workdir: header.workdir,
+                    createdAt: header.createdAt,
+                    gitBranch: header.gitBranch,
+                };
+            }
+        }
+        catch {
+            // Unreadable or invalid first line — treat as a legacy file
+        }
+        return null;
+    }
     /**
      * Validate messages before writing
      */

package/dist/services/session.d.ts

@@ -33,6 +33,8 @@ export interface SessionMetadata {
     lastActiveAt: Date;
     latestTotalTokens: number;
     firstMessage?: string;
+    /** Git branch at session creation time (from the metadata header). */
+    branch?: string;
 }
 /**
  * Generate a new session ID using Node.js native crypto.randomUUID()
@@ -123,11 +125,31 @@ export declare function listSessions(workdir: string): Promise<SessionMetadata[]
  */
 export declare function listSessionsFromJsonl(workdir: string): Promise<SessionMetadata[]>;
 /**
- * List all sessions across all project directories
+ * List all sessions across all project directories.
  *
- * @returns Promise that resolves to array of session metadata objects
- */
-export declare function listAllSessions(): Promise<SessionMetadata[]>;
+ * When `worktreePaths` is provided, only project directories that match a
+ * same-repo git worktree (plus the current working directory's own project
+ * dir) are scanned — used by the `wave -r` picker's worktree aggregation
+ * (`Ctrl+W`). When omitted, every project directory under the sessions dir
+ * is scanned (all-projects mode, `Ctrl+A`).
+ *
+ * No time-based filtering is applied — all sessions whose files still exist
+ * are listed, regardless of how long ago they were last active.
+ *
+ * @param options.worktreePaths - Absolute paths of same-repo worktrees
+ *   (from `git worktree list`). When provided, scanning is limited to
+ *   matching project directories.
+ * @param options.workdir - Current working directory. Its own project dir is
+ *   always included in worktree mode so sessions created from a subdirectory
+ *   inside a worktree are not missed.
+ * @returns Promise that resolves to array of session metadata objects,
+ *   deduplicated by sessionId (newest lastActiveAt wins), sorted by
+ *   lastActiveAt descending.
+ */
+export declare function listAllSessions(options?: {
+    worktreePaths?: string[];
+    workdir?: string;
+}): Promise<SessionMetadata[]>;
 /**
  * Clean up expired sessions older than 14 days based on file modification time
  *
@@ -161,6 +183,15 @@ export declare function cleanupMetaOnlySessions(): Promise<number>;
  * @returns Promise that resolves to true if session exists, false otherwise
  */
 export declare function sessionExistsInJsonl(sessionId: string, workdir: string, sessionType?: "main" | "subagent"): Promise<boolean>;
+/**
+ * Get the content of the first non-meta message in a session file
+ * For user role: get text block content
+ * For assistant role: get compact block content
+ * Skips meta messages (isMeta: true) to find the first meaningful message
+ * @param filePath - Path to the session JSONL file
+ * @returns Promise that resolves to the first non-meta message content or null if not found
+ */
+export declare function getFirstMessageContentFromFile(filePath: string): Promise<string | null>;
 /**
  * Get the content of the first non-meta message in a session
  * For user role: get text block content