wave-agent-sdk 1.1.0 → 1.1.2

package/dist/agent.d.ts

@@ -1,6 +1,6 @@
 import { type QueuedMessage } from "./managers/messageQueue.js";
 import { SlashCommand, CustomSlashCommand, AgentOptions } from "./types/index.js";
-import type { Message, McpServerStatus, GatewayConfig, ModelConfig, Usage, PermissionMode, ForegroundTask } from "./types/index.js";
+import type { Message, McpServerStatus, GatewayConfig, ModelConfig, Usage, PermissionMode, ForegroundTask, SkillMetadata } from "./types/index.js";
 import type { WorktreeSession } from "./utils/worktreeSession.js";
 export declare class Agent {
     private messageManager;
@@ -422,6 +422,12 @@ export declare class Agent {
      * @returns The list of subagent configurations
      */
     getSubagentConfigurations(): import("./utils/subagentParser.js").SubagentConfiguration[];
+    /**
+     * Get all skill metadata visible in this session (builtin, personal,
+     * project, and plugin skills).
+     * @returns The list of skill metadata
+     */
+    getSkillMetadata(): SkillMetadata[];
     /**
      * Get currently active subagent instances (status active/initializing).
      * @returns The list of active subagent instances

package/dist/agent.js

@@ -18,7 +18,7 @@ export class Agent {
         };
     }
     getModelConfig() {
-        return this.configurationService.resolveModelConfig(undefined, undefined, undefined, this.getPermissionMode());
+        return this.configurationService.resolveModelConfig(undefined, undefined, this.getPermissionMode());
     }
     getMaxInputTokens() {
         return this.configurationService.resolveMaxInputTokens();
@@ -983,6 +983,14 @@ export class Agent {
     getSubagentConfigurations() {
         return this.subagentManager.getConfigurations();
     }
+    /**
+     * Get all skill metadata visible in this session (builtin, personal,
+     * project, and plugin skills).
+     * @returns The list of skill metadata
+     */
+    getSkillMetadata() {
+        return this.skillManager.getAvailableSkills();
+    }
     /**
      * Get currently active subagent instances (status active/initializing).
      * @returns The list of active subagent instances

package/dist/builtin/skills/settings.js

@@ -29,7 +29,7 @@ Wave uses several environment variables to control its core functionality. Varia
 | \`WAVE_MODEL\` | The primary AI model to use for the agent. | \`gemini-3-flash\` |
 | \`WAVE_FAST_MODEL\` | The fast AI model to use for quick tasks. | \`gemini-2.5-flash\` |
 | \`WAVE_VISION_MODEL\` | Vision-capable model used by the built-in \`vision\` subagent for image recognition. When set, the built-in \`vision\` subagent is registered (its frontmatter \`model: visionModel\` resolves to this value); when unset, the subagent is not loaded. Useful when the main model is fast but non-vision (e.g. DeepSeek). | - (not registered) |
-| \`WAVE_MAX_INPUT_TOKENS\` | Maximum number of input tokens allowed. | \`200000\` |
+| \`WAVE_MAX_INPUT_TOKENS\` | Maximum number of input tokens allowed. Overridden per-model by \`models[<model>].maxInputTokens\`. | \`200000\` |
 | \`WAVE_MAX_OUTPUT_TOKENS\` | Maximum number of output tokens allowed. | \`32000\` |
 | \`WAVE_DISABLE_AUTO_MEMORY\` | Set to \`1\` or \`true\` to disable the auto-memory feature. | \`false\` |
 | \`WAVE_AUTO_MEMORY_FREQUENCY\` | Auto memory update frequency. \`1\` = every turn, \`2\` = every 2 turns, etc. | \`1\` |
@@ -585,12 +585,27 @@ You can define overrides for specific models in the \`models\` field. The key sh
 Generation parameters are nested under the \`options\` field within each model's configuration. Wave supports passing arbitrary parameters to the underlying AI provider. Common parameters include:
 
 - \`temperature\`: Controls randomness (0.0 to 2.0).
-- \`maxTokens\`: Maximum number of tokens to generate in the response.
+- \`max_tokens\`: Maximum number of tokens to generate in the response.
 - \`reasoning_effort\`: (OpenAI specific) Controls the reasoning effort for models like \`o1\` and \`o3-mini\`. Values: \`low\`, \`medium\`, \`high\`.
 - \`thinking\`: (Claude specific) Configures the thinking/reasoning capabilities for Claude 3.7+ models.
   - \`type\`: \`"enabled"\` or \`"disabled"\`.
   - \`budget_tokens\`: Maximum tokens to use for thinking.
 
+## Per-Model Input Context Window
+
+Set \`maxInputTokens\` at the top level of a model entry (not inside \`options\`) to define that model's input context window. It overrides the global \`WAVE_MAX_INPUT_TOKENS\`, so compaction thresholds and usage display follow each model's own value:
+
+\`\`\`json
+{
+  "models": {
+    "deepseek-v4-flash": { "maxInputTokens": 200000 },
+    "kimi-k3": { "maxInputTokens": 131072 }
+  }
+}
+\`\`\`
+
+Resolution priority: constructor > \`options\` > \`models[<model>].maxInputTokens\` > \`WAVE_MAX_INPUT_TOKENS\` > default. Subagents (\`fastModel\`/\`visionModel\`) resolve against the model they actually use.
+
 ## Model Capabilities
 
 Wave needs to know whether a model supports certain features. Instead of guessing from the model name, you declare these explicitly via the \`capabilities\` field. Note that \`capabilities\` is set at the top level of the model configuration, **not** inside the \`options\` field — \`options\` is reserved for generation parameters only.

package/dist/managers/aiManager.d.ts

@@ -133,7 +133,19 @@ export declare class AIManager {
     setIsLoading(isLoading: boolean): void;
     abortAIMessage(): void;
     private generateCompactParams;
-    private handleTokenUsageAndCompaction;
+    private updateLatestTotalTokens;
+    /**
+     * Pre-request auto-compaction check (aligned with Claude Code's
+     * autoCompactIfNeeded). Runs before every API request is issued: estimates
+     * the context that is about to be sent (last response's total_tokens plus
+     * character estimates for newer messages) and compacts first when it
+     * exceeds maxInputTokens, so over-limit requests are never sent. Only
+     * total_tokens is used — under OpenAI-compatible usage it already includes
+     * cache hits; adding cache fields would double-count and fire early.
+     * Fork paths (compaction / auto-memory) never reach here: they run in
+     * runForkLoop, not sendAIMessage.
+     */
+    private maybeAutoCompactBeforeRequest;
     /**
      * Manually compact the conversation history.
      * Called by /compact slash command or auto-compaction trigger.

package/dist/managers/aiManager.js

@@ -3,7 +3,7 @@ import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { supportsVision } from "../utils/modelCapabilities.js";
 import { persistToolImages } from "../utils/toolImagePersistence.js";
 import { parseTaskNotificationXml, taskNotificationToXml, } from "../utils/notificationXml.js";
-import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
+import { calculateComprehensiveTotalTokens, estimateContextTokens, } from "../utils/tokenCalculation.js";
 import { estimateTokens } from "../utils/tokenEstimate.js";
 import { getTaskReminderTurnCounts, maybeInjectTaskReminder, TASK_REMINDER_CONFIG, } from "../utils/taskReminder.js";
 import { createWriteStream, existsSync } from "node:fs";
@@ -144,7 +144,7 @@ export class AIManager {
         const permissionMode = this.container.has("PermissionMode")
             ? this.container.get("PermissionMode")
             : undefined;
-        const parentModelConfig = this.configurationService.resolveModelConfig(undefined, undefined, undefined, permissionMode);
+        const parentModelConfig = this.configurationService.resolveModelConfig(undefined, undefined, permissionMode);
         let modelToUse;
         if (this.modelOverride) {
             if (this.modelOverride === "fastModel") {
@@ -157,10 +157,13 @@ export class AIManager {
                 modelToUse = this.modelOverride;
             }
         }
-        return this.configurationService.resolveModelConfig(modelToUse, undefined, undefined, permissionMode);
+        return this.configurationService.resolveModelConfig(modelToUse, undefined, permissionMode);
     }
     getMaxInputTokens() {
-        return this.configurationService.resolveMaxInputTokens();
+        // Pass the resolved model (including fastModel/visionModel/override
+        // resolution) so subagents using a different model get that model's
+        // per-model maxInputTokens instead of the main model's value.
+        return this.configurationService.resolveMaxInputTokens(undefined, this.getModelConfig().model);
     }
     getLanguage() {
         return this.configurationService.resolveLanguage();
@@ -366,30 +369,43 @@ export class AIManager {
         }
         return "";
     }
-    // Private method to handle token statistics and message compaction
-    async handleTokenUsageAndCompaction(usage, abortController) {
+    // Private method to update the displayed token statistics from a response.
+    // The comprehensive value (including cache tokens) is intentionally kept:
+    // it drives cost/usage display. Auto-compaction is NOT decided here — it
+    // happens pre-request via maybeAutoCompactBeforeRequest so that over-limit
+    // requests never go out (aligned with Claude Code's proactive autocompact).
+    updateLatestTotalTokens(usage) {
         if (!usage)
             return;
         // Update token statistics - display comprehensive token usage including cache tokens
         const comprehensiveTotalTokens = calculateComprehensiveTotalTokens(usage);
         this.messageManager.setlatestTotalTokens(comprehensiveTotalTokens);
-        // Check if token limit exceeded - use injected configuration
-        if (usage.total_tokens +
-            (usage.cache_read_input_tokens || 0) +
-            (usage.cache_creation_input_tokens || 0) >
-            this.getMaxInputTokens()) {
-            logger?.debug(`Token usage exceeded ${this.getMaxInputTokens()}, compacting messages...`);
-            const messagesToCompact = this.messageManager.getMessages();
-            if (messagesToCompact.length === 0)
-                return;
-            // Circuit breaker: skip compaction after 3 consecutive failures
-            if (this.consecutiveCompactionFailures >= 3) {
-                logger?.warn(`Skipping compaction: ${this.consecutiveCompactionFailures} consecutive failures`);
-                return;
-            }
-            await this.compactConversation({
-                abortSignal: abortController.signal,
-            });
+    }
+    /**
+     * Pre-request auto-compaction check (aligned with Claude Code's
+     * autoCompactIfNeeded). Runs before every API request is issued: estimates
+     * the context that is about to be sent (last response's total_tokens plus
+     * character estimates for newer messages) and compacts first when it
+     * exceeds maxInputTokens, so over-limit requests are never sent. Only
+     * total_tokens is used — under OpenAI-compatible usage it already includes
+     * cache hits; adding cache fields would double-count and fire early.
+     * Fork paths (compaction / auto-memory) never reach here: they run in
+     * runForkLoop, not sendAIMessage.
+     */
+    async maybeAutoCompactBeforeRequest(abortController) {
+        // Circuit breaker: skip compaction after 3 consecutive failures
+        if (this.consecutiveCompactionFailures >= 3) {
+            logger?.warn(`Skipping compaction: ${this.consecutiveCompactionFailures} consecutive failures`);
+            return;
+        }
+        const messages = this.messageManager.getMessages();
+        if (messages.length === 0)
+            return;
+        const maxTokens = this.getMaxInputTokens();
+        const estimatedTokens = estimateContextTokens(messages);
+        if (estimatedTokens > maxTokens) {
+            logger?.debug(`Estimated context tokens ${estimatedTokens} exceeded ${maxTokens}, compacting before request...`);
+            await this.compactConversation({ abortSignal: abortController.signal });
         }
     }
     /**
@@ -598,6 +614,7 @@ export class AIManager {
                 workdir,
                 tools: toolsConfig,
                 systemPrompt,
+                maxTokens: this.configurationService.resolveMaxOutputTokens(),
                 toolChoice: this.toolChoiceOverride,
                 // Stream so a slow reasoning model emits first bytes before the
                 // gateway's idle timeout fires (non-streaming waits for the full
@@ -1029,6 +1046,7 @@ ${question}`;
                 workdir,
                 tools: toolsConfig,
                 systemPrompt,
+                maxTokens: this.configurationService.resolveMaxOutputTokens(),
                 toolChoice: this.toolChoiceOverride,
                 // Stream so a slow reasoning model emits first bytes before the
                 // gateway's idle timeout fires (same rationale as runCompactFork).
@@ -1281,6 +1299,10 @@ ${question}`;
                             isMeta: true,
                         });
                     }
+                    // Pre-request auto-compaction: estimate the context about to be sent
+                    // and compact BEFORE issuing the request, so an over-limit request
+                    // never goes out. Skipped on fork paths (they use runForkLoop).
+                    await this.maybeAutoCompactBeforeRequest(abortController);
                     // Get recent message history
                     const rawMessages = this.messageManager.getMessages();
                     const currentModelConfig = this.getModelConfig();
@@ -1305,7 +1327,7 @@ ${question}`;
                         tools: toolsConfig, // Pass filtered tool configuration
                         model: model, // Use passed model
                         systemPrompt: mainSystemPrompt, // Pass custom system prompt
-                        maxTokens: maxTokens, // Pass max tokens override
+                        maxTokens: maxTokens ?? this.configurationService.resolveMaxOutputTokens(), // Pass max tokens override, falling back to the resolved global value
                         toolChoice: this.toolChoiceOverride, // Pass tool_choice override
                         // Fast-model subagents send disable-thinking params only when
                         // explicitly configured (never in the agent loop).
@@ -1489,8 +1511,9 @@ ${question}`;
                             }
                         }
                     }
-                    // Handle token statistics and message compaction
-                    await this.handleTokenUsageAndCompaction(result.usage, abortController);
+                    // Update token statistics for display (compaction decision is
+                    // pre-request, see maybeAutoCompactBeforeRequest)
+                    this.updateLatestTotalTokens(result.usage);
                     // Finalize text/reasoning blocks for the final response (no tools)
                     this.messageManager.finalizeStreamingBlocks();
                     // Check if there are tool operations or response was truncated, if so automatically initiate next AI service call

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/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/tools/bashTool.js

@@ -4,7 +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 { toPosixPath, toWindowsPath } from "../utils/path.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import { WindowsStreamDecoder } from "../utils/encoding.js";
 import { processToolResult } from "../utils/toolResultStorage.js";
@@ -498,12 +498,20 @@ The working directory persists between commands. Try to maintain your current wo
                 try {
                     if (fs.existsSync(tempCwdFile)) {
                         newCwd = fs.readFileSync(tempCwdFile, "utf8").trim();
+                        // Git Bash `pwd -P` writes MSYS-style POSIX paths (/c/Users/...);
+                        // convert back to a native Windows path before validating, otherwise
+                        // accessSync resolves /c/... to C:\c\... (ENOENT) on every command.
+                        if (process.platform === "win32") {
+                            newCwd = toWindowsPath(newCwd);
+                        }
                         // 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);
+                    // Best-effort CWD tracking: a stale/deleted target directory (e.g. a
+                    // removed worktree) shouldn't fail the command or spam WARN logs.
+                    logger.debug(`Could not read or validate new CWD from temp file ${tempCwdFile}:`, fileError);
                     newCwd = undefined;
                 }
                 finally {

package/dist/types/config.d.ts

@@ -24,7 +24,8 @@ export interface ModelConfig {
     fastModel?: string;
     /** Vision-capable model for image recognition subagents (resolved from WAVE_VISION_MODEL env var). */
     visionModel?: string;
-    maxTokens?: number;
+    /** Per-model input context window in tokens. Overrides the global `WAVE_MAX_INPUT_TOKENS` for this model. */
+    maxInputTokens?: number;
     permissionMode?: PermissionMode;
     capabilities?: ModelCapabilities;
     /** Generation params passed through to the API provider (temperature, thinking, etc.) */

package/dist/utils/markdownParser.js

@@ -5,6 +5,7 @@ import { join } from "path";
 import { tmpdir } from "os";
 import { SKILL_BASH_MAX_OUTPUT_CHARS, PREVIEW_SIZE_BYTES, } from "../constants/toolLimits.js";
 import { logger } from "./globalLogger.js";
+import { resolveShellPath } from "./shellResolver.js";
 const execAsync = promisify(exec);
 /**
  * Parse YAML frontmatter from markdown content
@@ -198,12 +199,29 @@ export function replaceBashCommandsWithOutput(content, results) {
  */
 export async function executeBashCommands(commands, workdir, timeout = 30000) {
     const results = [];
-    for (const command of commands) {
+    for (const originalCommand of commands) {
+        let command = originalCommand;
+        const execOptions = {
+            cwd: workdir,
+            timeout,
+        };
+        // Skill templates (e.g. !`gh pr view ... 2>/dev/null || echo '{}'`) use
+        // bash-only syntax. On Windows, child_process.exec defaults to cmd.exe,
+        // where `/dev/null` fails with a localized "path not found" error whose
+        // GBK bytes get mis-decoded as UTF-8 (mojibake). Run through Git Bash
+        // when available (same contract as the bash tool); otherwise force the
+        // UTF-8 codepage so cmd's own messages decode correctly.
+        if (process.platform === "win32") {
+            const bashPath = resolveShellPath();
+            if (bashPath) {
+                execOptions.shell = bashPath;
+            }
+            else {
+                command = `chcp 65001 >NUL && ${command}`;
+            }
+        }
         try {
-            const { stdout, stderr } = await execAsync(command, {
-                cwd: workdir,
-                timeout,
-            });
+            const { stdout, stderr } = await execAsync(command, execOptions);
             results.push({
                 command,
                 output: (stdout + (stderr || "")).trim(),

package/dist/utils/path.d.ts

@@ -25,3 +25,12 @@ export declare function getDisplayPath(filePath: string, workdir: string): strin
  * Returns the path as-is on non-Windows platforms.
  */
 export declare function toPosixPath(p: string): string;
+/**
+ * Convert a POSIX-style path to a native Windows path. Git Bash / MSYS shells
+ * print POSIX paths (e.g. `pwd -P` outputs `/c/Users/foo`), which Node.js on
+ * Windows would otherwise resolve against the current drive root (e.g. `/c/...`
+ * becomes `C:\c\...`) and fail with ENOENT. Handles `/c/...` (MSYS2/Git Bash),
+ * `/cygdrive/c/...` and `//server/share` (UNC) forms. Returns the path as-is on
+ * non-Windows platforms.
+ */
+export declare function toWindowsPath(p: string): string;

package/dist/utils/path.js

@@ -61,3 +61,35 @@ export function getDisplayPath(filePath, workdir) {
 export function toPosixPath(p) {
     return process.platform === "win32" ? p.replace(/\\/g, "/") : p;
 }
+/**
+ * Convert a POSIX-style path to a native Windows path. Git Bash / MSYS shells
+ * print POSIX paths (e.g. `pwd -P` outputs `/c/Users/foo`), which Node.js on
+ * Windows would otherwise resolve against the current drive root (e.g. `/c/...`
+ * becomes `C:\c\...`) and fail with ENOENT. Handles `/c/...` (MSYS2/Git Bash),
+ * `/cygdrive/c/...` and `//server/share` (UNC) forms. Returns the path as-is on
+ * non-Windows platforms.
+ */
+export function toWindowsPath(p) {
+    if (process.platform !== "win32")
+        return p;
+    // UNC paths: //server/share -> \\server\share
+    if (p.startsWith("//")) {
+        return p.replace(/\//g, "\\");
+    }
+    // /cygdrive/c/... -> C:\...
+    const cygdriveMatch = p.match(/^\/cygdrive\/([A-Za-z])(\/|$)/);
+    if (cygdriveMatch) {
+        const driveLetter = cygdriveMatch[1].toUpperCase();
+        const rest = p.slice(("/cygdrive/" + cygdriveMatch[1]).length);
+        return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    // /c/... (MSYS2/Git Bash) -> C:\...
+    const driveMatch = p.match(/^\/([A-Za-z])(\/|$)/);
+    if (driveMatch) {
+        const driveLetter = driveMatch[1].toUpperCase();
+        const rest = p.slice(2);
+        return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    // Already Windows or relative — just flip slashes
+    return p.replace(/\//g, "\\");
+}

package/dist/utils/tokenCalculation.d.ts

@@ -1,4 +1,4 @@
-import type { Usage } from "../types/index.js";
+import type { Message, Usage } from "../types/index.js";
 /**
  * Calculate comprehensive total tokens including cache-related tokens
  *
@@ -23,3 +23,21 @@ export declare function calculateComprehensiveTotalTokens(usage: Usage): number;
 export declare function extractLatestTotalTokens(messages: Array<{
     usage?: Usage;
 }>): number;
+/**
+ * Estimate the full context size of a message list for pre-request
+ * auto-compaction checks (aligned with Claude Code's tokenCountWithEstimation).
+ *
+ * Anchors on the most recent message carrying real usage (the last API
+ * response): that response's total_tokens (OpenAI-compatible semantics —
+ * already includes cache hits) plus a rough character-based estimate for
+ * every message added after it. Falls back to a pure character estimate
+ * when no usage anchor exists yet (e.g. the first request of a session).
+ */
+export declare function estimateContextTokens(messages: Message[]): number;
+/**
+ * Rough per-message token estimate over all message blocks.
+ * Used to estimate the messages added since the last usage-bearing response.
+ * Image blocks are ignored (images are stripped before compaction) and file
+ * history snapshots live on disk, so their content is not in the context.
+ */
+export declare function roughTokenCountForMessages(messages: Message[]): number;

package/dist/utils/tokenCalculation.js

@@ -1,3 +1,4 @@
+import { estimateTokens } from "./tokenEstimate.js";
 /**
  * Calculate comprehensive total tokens including cache-related tokens
  *
@@ -34,3 +35,66 @@ export function extractLatestTotalTokens(messages) {
     }
     return 0; // No usage data found
 }
+/**
+ * Estimate the full context size of a message list for pre-request
+ * auto-compaction checks (aligned with Claude Code's tokenCountWithEstimation).
+ *
+ * Anchors on the most recent message carrying real usage (the last API
+ * response): that response's total_tokens (OpenAI-compatible semantics —
+ * already includes cache hits) plus a rough character-based estimate for
+ * every message added after it. Falls back to a pure character estimate
+ * when no usage anchor exists yet (e.g. the first request of a session).
+ */
+export function estimateContextTokens(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const usage = messages[i].usage;
+        if (usage) {
+            return (usage.total_tokens + roughTokenCountForMessages(messages.slice(i + 1)));
+        }
+    }
+    return roughTokenCountForMessages(messages);
+}
+/**
+ * Rough per-message token estimate over all message blocks.
+ * Used to estimate the messages added since the last usage-bearing response.
+ * Image blocks are ignored (images are stripped before compaction) and file
+ * history snapshots live on disk, so their content is not in the context.
+ */
+export function roughTokenCountForMessages(messages) {
+    let total = 0;
+    for (const message of messages) {
+        for (const block of message.blocks) {
+            switch (block.type) {
+                case "text":
+                case "reasoning":
+                case "error":
+                case "compact":
+                    total += estimateTokens(block.content);
+                    break;
+                case "tool":
+                    if (block.parameters) {
+                        total += estimateTokens(block.parameters, "json");
+                    }
+                    if (block.result) {
+                        total += estimateTokens(block.result);
+                    }
+                    break;
+                case "bang":
+                    if (block.command) {
+                        total += estimateTokens(block.command);
+                    }
+                    if (block.output) {
+                        total += estimateTokens(block.output);
+                    }
+                    break;
+                case "task_notification":
+                    total += estimateTokens(block.summary);
+                    break;
+                case "image":
+                case "file_history":
+                    break;
+            }
+        }
+    }
+    return total;
+}

package/package.json

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