wave-agent-sdk 0.19.9 → 1.0.1

package/dist/services/configurationService.js

@@ -28,6 +28,10 @@ export class ConfigurationService {
         this.currentConfiguration = null;
         this.options = {};
         this._configuredEnvKeys = new Set();
+        // Per-session environment snapshot: settings.json `env` is stored here (NOT
+        // written to process.env) so multiple sessions in one `wave --stdio` process
+        // don't cross-pollute. Resolve methods read `this.envSnapshot ?? process.env`.
+        this.envSnapshot = {};
     }
     /**
      * Set agent options for configuration resolution
@@ -35,6 +39,22 @@ export class ConfigurationService {
     setOptions(options) {
         this.options = options;
     }
+    /**
+     * Returns a copy of the per-session environment snapshot (settings.json `env`).
+     * Priority over OS env; does NOT include OS env. For subprocess spawning use
+     * {@link getMergedEnv} instead.
+     */
+    getEnvSnapshot() {
+        return { ...this.envSnapshot };
+    }
+    /**
+     * Returns OS env merged with the session snapshot (snapshot wins). Use this
+     * when spawning user-facing subprocesses (bash, hooks, bang, background, MCP)
+     * so they inherit both OS env and the session's settings env.
+     */
+    getMergedEnv() {
+        return Object.fromEntries(Object.entries({ ...process.env, ...this.envSnapshot }).filter(([, v]) => v !== undefined));
+    }
     // Core loading operations
     /**
      * Load and merge configuration with comprehensive validation
@@ -292,16 +312,31 @@ export class ConfigurationService {
     }
     // Utility operations
     /**
-     * Set environment variables from configuration
-     * This replaces direct process.env modification
+     * Store environment variables from configuration into the per-session
+     * snapshot (NOT process.env). Settings `env` shadows OS env for this session
+     * only — multiple sessions in one stdio process stay isolated.
+     *
+     * Exception: `WAVE_SERVER_URL` is also mirrored to `process.env` because the
+     * process-level singletons (AuthService, remoteSettingsService background
+     * fetch) need to read it and don't hold a per-session snapshot. Same value
+     * across sessions ⇒ no cross-pollution. See docs/specs/core/agent-config.md.
      */
     setEnvironmentVars(env) {
         for (const [key, value] of Object.entries(env)) {
-            if (process.env[key] !== undefined && !this._configuredEnvKeys.has(key)) {
+            if (process.env[key] !== undefined &&
+                !this._configuredEnvKeys.has(key) &&
+                process.env[key] !== value) {
                 logger.warn(`Overriding environment variable: ${key}`);
             }
-            process.env[key] = value;
+            this.envSnapshot[key] = value;
             this._configuredEnvKeys.add(key);
+            // WAVE_SERVER_URL is consumed by process-level singletons (AuthService,
+            // remoteSettingsService) that can't see the per-session snapshot — mirror
+            // it to process.env so they read the settings value. Same value across
+            // sessions ⇒ no last-session-wins cross-pollution.
+            if (key === "WAVE_SERVER_URL") {
+                process.env[key] = value;
+            }
         }
     }
     // =============================================================================
@@ -337,8 +372,11 @@ export class ConfigurationService {
      * @returns Resolved model configuration (model/fastModel may be undefined if not yet configured)
      */
     resolveGatewayConfig(apiKey, baseURL, defaultHeaders, fetchOptions, fetch) {
-        // Check for SSO token first - if present and server URL is available, use SSO mode
-        // Server URL resolution: options > process.env > default
+        // Check for SSO token first - if present and server URL is available, use SSO mode.
+        // Server URL resolution: options.serverUrl > process.env.WAVE_SERVER_URL > default.
+        // settings.json `env` WAVE_SERVER_URL is mirrored to process.env by
+        // setEnvironmentVars (so process-level singletons AuthService / remoteSettings
+        // can read it), then read here. See docs/specs/core/agent-config.md.
         const ssoToken = this.readSSOToken();
         const serverUrl = this.options.serverUrl ||
             process.env.WAVE_SERVER_URL ||
@@ -366,7 +404,8 @@ export class ConfigurationService {
             resolvedApiKey = this.options.apiKey;
         }
         else {
-            resolvedApiKey = process.env.WAVE_API_KEY;
+            resolvedApiKey =
+                this.envSnapshot.WAVE_API_KEY ?? process.env.WAVE_API_KEY;
         }
         // Resolve base URL: override > options > env (settings.json) > process.env
         // Note: Explicitly provided empty strings should be treated as invalid, not fall back to env
@@ -378,21 +417,26 @@ export class ConfigurationService {
             resolvedBaseURL = this.options.baseURL;
         }
         else {
-            resolvedBaseURL = process.env.WAVE_BASE_URL;
+            resolvedBaseURL =
+                this.envSnapshot.WAVE_BASE_URL ?? process.env.WAVE_BASE_URL;
         }
         // Fallback to process.env if still not resolved (for dynamic updates in tests)
         if (resolvedApiKey === undefined) {
-            resolvedApiKey = process.env.WAVE_API_KEY;
+            resolvedApiKey =
+                this.envSnapshot.WAVE_API_KEY ?? process.env.WAVE_API_KEY;
         }
         if (!resolvedBaseURL) {
-            resolvedBaseURL = process.env.WAVE_BASE_URL;
+            resolvedBaseURL =
+                this.envSnapshot.WAVE_BASE_URL ?? process.env.WAVE_BASE_URL;
         }
         // Treat empty string as not provided
         if (resolvedBaseURL?.trim() === "") {
             resolvedBaseURL = undefined;
         }
         // Resolve custom headers from environment: env (settings.json) > process.env
-        const envCustomHeaders = process.env.WAVE_CUSTOM_HEADERS || "";
+        const envCustomHeaders = this.envSnapshot.WAVE_CUSTOM_HEADERS ??
+            process.env.WAVE_CUSTOM_HEADERS ??
+            "";
         const parsedEnvHeaders = parseCustomHeaders(envCustomHeaders);
         // Merge headers: env headers < options < override
         const resolvedHeaders = {
@@ -424,9 +468,11 @@ export class ConfigurationService {
         const resolvedAgentModel = model ||
             this.options.model ||
             this.currentConfiguration?.model ||
-            process.env.WAVE_MODEL;
+            (this.envSnapshot.WAVE_MODEL ?? process.env.WAVE_MODEL);
         // Resolve fast model: override > options > process.env (includes settings.json env)
-        const resolvedFastModel = fastModel || this.options.fastModel || process.env.WAVE_FAST_MODEL;
+        const resolvedFastModel = fastModel ||
+            this.options.fastModel ||
+            (this.envSnapshot.WAVE_FAST_MODEL ?? process.env.WAVE_FAST_MODEL);
         // Resolve max output tokens
         const resolvedMaxTokens = this.resolveMaxOutputTokens(maxTokens);
         const baseConfig = {
@@ -442,14 +488,27 @@ export class ConfigurationService {
         if (fastModelSource && fastModelSource.options) {
             baseConfig.fastModelOptions = fastModelSource.options;
         }
+        // Resolve fast-model disable-thinking params from models[fastModel].disableThinkingOptions
+        const fastModelDisableThinking = fastModelSource && fastModelSource.disableThinkingOptions
+            ? fastModelSource.disableThinkingOptions
+            : undefined;
+        if (fastModelDisableThinking) {
+            baseConfig.disableThinkingOptions = fastModelDisableThinking;
+        }
         // Merge model-specific settings from configuration
         const modelSpecificConfig = resolvedAgentModel &&
             this.currentConfiguration?.models?.[resolvedAgentModel];
         if (modelSpecificConfig) {
-            return {
+            const resolved = {
                 ...baseConfig,
                 ...modelSpecificConfig,
             };
+            // Re-apply after the spread so the agent model's own
+            // disableThinkingOptions cannot clobber the fast-model value.
+            if (fastModelDisableThinking) {
+                resolved.disableThinkingOptions = fastModelDisableThinking;
+            }
+            return resolved;
         }
         return baseConfig;
     }
@@ -468,8 +527,9 @@ export class ConfigurationService {
         if (this.options.maxInputTokens !== undefined) {
             return this.options.maxInputTokens;
         }
-        // Try env (settings.json) first, then process.env
-        const envMaxInputTokens = process.env.WAVE_MAX_INPUT_TOKENS;
+        // Try env (settings.json snapshot) first, then process.env
+        const envMaxInputTokens = this.envSnapshot.WAVE_MAX_INPUT_TOKENS ??
+            process.env.WAVE_MAX_INPUT_TOKENS;
         if (envMaxInputTokens) {
             const parsed = parseInt(envMaxInputTokens, 10);
             if (!isNaN(parsed)) {
@@ -510,8 +570,8 @@ export class ConfigurationService {
         if (this.currentConfiguration?.autoMemoryEnabled !== undefined) {
             return this.currentConfiguration.autoMemoryEnabled;
         }
-        // 2. WAVE_DISABLE_AUTO_MEMORY environment variable
-        const disableAutoMemory = process.env.WAVE_DISABLE_AUTO_MEMORY ||
+        // 2. WAVE_DISABLE_AUTO_MEMORY environment variable (settings snapshot > OS env)
+        const disableAutoMemory = this.envSnapshot.WAVE_DISABLE_AUTO_MEMORY ??
             process.env.WAVE_DISABLE_AUTO_MEMORY;
         if (disableAutoMemory === "1" || disableAutoMemory === "true") {
             return false;
@@ -541,8 +601,8 @@ export class ConfigurationService {
         if (this.currentConfiguration?.autoMemoryFrequency !== undefined) {
             return this.currentConfiguration.autoMemoryFrequency;
         }
-        // 2. WAVE_AUTO_MEMORY_FREQUENCY environment variable
-        const envFrequency = process.env.WAVE_AUTO_MEMORY_FREQUENCY ||
+        // 2. WAVE_AUTO_MEMORY_FREQUENCY environment variable (settings snapshot > OS env)
+        const envFrequency = this.envSnapshot.WAVE_AUTO_MEMORY_FREQUENCY ??
             process.env.WAVE_AUTO_MEMORY_FREQUENCY;
         if (envFrequency) {
             const parsed = parseInt(envFrequency, 10);
@@ -568,8 +628,9 @@ export class ConfigurationService {
         if (this.options.maxTokens !== undefined) {
             return this.options.maxTokens;
         }
-        // Try env (settings.json) first, then process.env
-        const envMaxOutputTokens = process.env.WAVE_MAX_OUTPUT_TOKENS;
+        // Try env (settings.json snapshot) first, then process.env
+        const envMaxOutputTokens = this.envSnapshot.WAVE_MAX_OUTPUT_TOKENS ??
+            process.env.WAVE_MAX_OUTPUT_TOKENS;
         if (envMaxOutputTokens) {
             const parsed = parseInt(envMaxOutputTokens, 10);
             if (!isNaN(parsed) && parsed > 0) {
@@ -610,8 +671,9 @@ export class ConfigurationService {
      */
     getConfiguredModels() {
         const models = new Set();
-        // Add current model from options or environment
-        const currentModel = this.options.model || process.env.WAVE_MODEL;
+        // Add current model from options or environment (settings snapshot > OS env)
+        const currentModel = this.options.model ||
+            (this.envSnapshot.WAVE_MODEL ?? process.env.WAVE_MODEL);
         if (currentModel) {
             models.add(currentModel);
         }

package/dist/services/initializationService.js

@@ -44,12 +44,16 @@ export class InitializationService {
             logger?.error("Failed to initialize MCP servers:", error);
             // Don't throw error to prevent app startup failure
         }
-        // Initialize remote settings (load disk cache synchronously, then fetch in background)
-        // Must happen BEFORE loadMergedConfiguration so remote env vars are available
+        // Load remote settings disk cache synchronously.
+        // Must happen BEFORE loadMergedConfiguration so cached managed settings
+        // (env, model, disallowedTools) are merged into the config. Settings `env`
+        // is stored in the per-session env snapshot (NOT process.env), except
+        // WAVE_SERVER_URL which is mirrored to process.env so the network fetch
+        // (below) can read it via authService.getServerUrl(); no race.
         try {
             const phaseStart = performance.now();
             await remoteSettingsService.initialize();
-            logger?.debug(`Initialization Phase [Remote Settings] took ${(performance.now() - phaseStart).toFixed(2)}ms`);
+            logger?.debug(`Initialization Phase [Remote Settings Cache] took ${(performance.now() - phaseStart).toFixed(2)}ms`);
         }
         catch (error) {
             logger?.error("Failed to initialize remote settings:", error);
@@ -89,6 +93,12 @@ export class InitializationService {
             logger?.error("Failed to initialize hooks system:", error);
             // Don't throw error to prevent app startup failure
         }
+        // Start remote settings network fetch + polling now that the config is
+        // merged. Settings `env` WAVE_SERVER_URL was mirrored to process.env by
+        // loadMergedConfiguration → setEnvironmentVars, so the fetch reads it via
+        // authService.getServerUrl(); fire-and-forget, failures fall back to the
+        // cached/merged settings.
+        remoteSettingsService.startBackgroundFetch();
         // Execute SessionStart hooks
         try {
             const phaseStart = performance.now();
@@ -124,7 +134,7 @@ export class InitializationService {
                     transcriptPath: messageManager.getTranscriptPath(),
                     cwd: workdir,
                     worktreeName: agentOptions.worktreeName,
-                    env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)),
+                    env: Object.fromEntries(Object.entries(configurationService.getMergedEnv()).filter((e) => e[1] !== undefined)),
                 });
                 // Process hook results
                 hookManager.processHookResults("WorktreeCreate", hookResults, messageManager);

package/dist/services/interactionService.js

@@ -48,7 +48,7 @@ export class InteractionService {
                         transcriptPath: messageManager.getTranscriptPath(),
                         cwd: workdir,
                         userPrompt: content,
-                        env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)), // Include environment variables
+                        env: Object.fromEntries(Object.entries(context.configurationService.getMergedEnv()).filter((e) => e[1] !== undefined)), // Include environment variables
                     });
                     // Process hook results and determine if we should continue
                     const processResult = hookManager.processHookResults("UserPromptSubmit", hookResults, messageManager);
@@ -76,7 +76,7 @@ export class InteractionService {
         }
     }
     static async restoreSession(context, sessionId) {
-        const { messageManager, logger, subagentManager, taskManager, options, abortMessage, } = context;
+        const { messageManager, hookManager, logger, subagentManager, taskManager, options, abortMessage, } = context;
         // 1. Validation
         if (!sessionId || sessionId === messageManager.getSessionId()) {
             return; // No-op if session ID is invalid or already current
@@ -89,21 +89,49 @@ export class InteractionService {
             logger?.warn("Failed to save current session before restore:", error);
             // Continue with restoration even if save fails
         }
-        // 3. Load target session
+        // 3. Run SessionEnd hooks for the current session (cleanup before switching)
+        const currentSessionId = messageManager.getSessionId();
+        const currentTranscriptPath = messageManager.getTranscriptPath();
+        if (hookManager) {
+            try {
+                await hookManager.executeSessionEndHooks("resume", currentSessionId, currentTranscriptPath);
+            }
+            catch (error) {
+                logger?.warn(`SessionEnd hooks on restore failed: ${error.message}`);
+            }
+        }
+        // 4. Load target session
         const sessionData = await loadSessionFromJsonl(sessionId, messageManager.getWorkdir());
         if (!sessionData) {
             throw new Error(`Session not found: ${sessionId}`);
         }
-        // 4. Clean current state
+        // 5. Clean current state
         abortMessage(); // Abort any running operations
         subagentManager.cleanup(); // Clean up active subagents
-        // 5. Rebuild usage (in correct order)
+        // 6. Rebuild usage (in correct order)
         messageManager.rebuildUsageFromMessages(sessionData.messages);
-        // 6. Initialize session state last
+        // 7. Initialize session state last
         messageManager.initializeFromSession(sessionData);
+        // 8. Run SessionStart hooks for the restored session and inject additional
+        //    context as a meta user message (matches Claude Code's resume behavior:
+        //    SessionEnd then SessionStart, hook messages appended to the conversation)
+        if (hookManager) {
+            try {
+                const sessionStartResult = await hookManager.executeSessionStartHooks("resume", sessionData.id, messageManager.getTranscriptPath());
+                if (sessionStartResult.additionalContext) {
+                    messageManager.addUserMessage({
+                        content: `<system-reminder>\nSessionStart hook additional context: ${sessionStartResult.additionalContext}\n</system-reminder>`,
+                        isMeta: true,
+                    });
+                }
+            }
+            catch (error) {
+                logger?.warn(`SessionStart hooks on restore failed: ${error.message}`);
+            }
+        }
         // Update task manager with the root session ID to ensure continuity across compactions
         taskManager.setTaskListId(sessionData.id);
-        // 7. Load tasks for the restored session
+        // 9. Load tasks for the restored session
         const tasks = await taskManager.listTasks();
         options.callbacks?.onTasksChange?.(tasks);
     }

package/dist/services/remoteSettingsService.d.ts

@@ -6,6 +6,17 @@ import type { WaveConfiguration } from "../types/configuration.js";
  */
 export declare function onSettingsUpdate(callback: () => void | Promise<void>): () => void;
 export declare function initialize(): void;
+/**
+ * Start the fire-and-forget initial network fetch + background polling.
+ *
+ * Must be called AFTER loadMergedConfiguration() so disk-cached managed
+ * settings are merged before the fetch, and so settings `env` WAVE_SERVER_URL
+ * is mirrored to process.env (by setEnvironmentVars) before the fetch. The
+ * fetch uses authService.getServerUrl(), which reads process.env.WAVE_SERVER_URL
+ * — the settings value is visible there, so there is no init-ordering race
+ * that would fall back to DEFAULT_SERVER_URL (prod) and hit a test endpoint (401).
+ */
+export declare function startBackgroundFetch(): void;
 export declare function getRemoteSettingsSync(): WaveConfiguration | null;
 export declare function refresh(): Promise<RemoteSettingsFetchResult>;
 export declare function clear(): void;
@@ -17,6 +28,7 @@ export declare function mergeRemoteSettings(localMerged: WaveConfiguration, remo
  */
 export declare const remoteSettingsService: {
     readonly initialize: typeof initialize;
+    readonly startBackgroundFetch: typeof startBackgroundFetch;
     readonly getRemoteSettingsSync: typeof getRemoteSettingsSync;
     readonly refresh: typeof refresh;
     readonly clear: typeof clear;

package/dist/services/remoteSettingsService.js

@@ -174,8 +174,21 @@ function startPolling() {
     _pollingTimer.unref();
 }
 export function initialize() {
+    // Load disk cache synchronously so getRemoteSettingsSync() returns cached
+    // managed settings during loadMergedConfiguration() (must run BEFORE it).
     loadCacheFromDisk();
-    // Fire-and-forget the initial fetch, then start background polling
+}
+/**
+ * Start the fire-and-forget initial network fetch + background polling.
+ *
+ * Must be called AFTER loadMergedConfiguration() so disk-cached managed
+ * settings are merged before the fetch, and so settings `env` WAVE_SERVER_URL
+ * is mirrored to process.env (by setEnvironmentVars) before the fetch. The
+ * fetch uses authService.getServerUrl(), which reads process.env.WAVE_SERVER_URL
+ * — the settings value is visible there, so there is no init-ordering race
+ * that would fall back to DEFAULT_SERVER_URL (prod) and hit a test endpoint (401).
+ */
+export function startBackgroundFetch() {
     fetchRemoteSettings()
         .then(() => startPolling())
         .catch((err) => {
@@ -302,6 +315,7 @@ export function mergeRemoteSettings(localMerged, remote) {
  */
 export const remoteSettingsService = {
     initialize,
+    startBackgroundFetch,
     getRemoteSettingsSync,
     refresh,
     clear,

package/dist/services/session.d.ts

@@ -139,6 +139,19 @@ export declare function cleanupExpiredSessionsFromJsonl(workdir: string): Promis
  * Clean up empty project directories in the session directory
  */
 export declare function cleanupEmptyProjectDirectories(): Promise<void>;
+/**
+ * Clean up "ghost" session files that contain only meta messages
+ * (isMeta: true) — e.g. sessions where a SessionStart hook injected a
+ * system-reminder but no real user/assistant message was ever sent.
+ *
+ * Such sessions are no longer created thanks to lazy materialization in
+ * saveSession(); this one-time sweep removes files that predate that change
+ * so they stop showing up as "0 tokens / No content" entries in the resume
+ * list.
+ *
+ * @returns Promise that resolves to the number of files deleted
+ */
+export declare function cleanupMetaOnlySessions(): Promise<number>;
 /**
  * Check if a session exists in JSONL storage (new approach)
  *

package/dist/services/session.js

@@ -481,6 +481,70 @@ export async function cleanupEmptyProjectDirectories() {
         // Ignore errors if base directory doesn't exist or can't be accessed
     }
 }
+/**
+ * Clean up "ghost" session files that contain only meta messages
+ * (isMeta: true) — e.g. sessions where a SessionStart hook injected a
+ * system-reminder but no real user/assistant message was ever sent.
+ *
+ * Such sessions are no longer created thanks to lazy materialization in
+ * saveSession(); this one-time sweep removes files that predate that change
+ * so they stop showing up as "0 tokens / No content" entries in the resume
+ * list.
+ *
+ * @returns Promise that resolves to the number of files deleted
+ */
+export async function cleanupMetaOnlySessions() {
+    // Do not perform cleanup operations in test environment
+    if (process.env.NODE_ENV === "test") {
+        return 0;
+    }
+    let deletedCount = 0;
+    try {
+        const projectDirs = await fs.readdir(SESSION_DIR);
+        for (const projectDirName of projectDirs) {
+            const projectPath = join(SESSION_DIR, projectDirName);
+            try {
+                const stat = await fs.stat(projectPath);
+                if (!stat.isDirectory()) {
+                    continue;
+                }
+                const files = await fs.readdir(projectPath);
+                for (const file of files) {
+                    if (!file.endsWith(".jsonl")) {
+                        continue;
+                    }
+                    const filePath = join(projectPath, file);
+                    try {
+                        // Fast path: a file whose last message is not meta contains a
+                        // real message, so it can never be meta-only.
+                        const jsonlHandler = new JsonlHandler();
+                        const lastMessage = await jsonlHandler.getLastMessage(filePath);
+                        if (!lastMessage?.isMeta) {
+                            continue;
+                        }
+                        const messages = await jsonlHandler.read(filePath);
+                        if (messages.length > 0 && messages.every((m) => m.isMeta)) {
+                            await fs.unlink(filePath);
+                            deletedCount++;
+                        }
+                    }
+                    catch {
+                        // Skip corrupted or unreadable files
+                        continue;
+                    }
+                }
+            }
+            catch {
+                // Skip directories we can't access
+                continue;
+            }
+        }
+    }
+    catch {
+        // Ignore errors if base directory doesn't exist or can't be accessed
+    }
+    return deletedCount;
+}
 /**
  * Check if a session exists in JSONL storage (new approach)
  *

package/dist/services/taskManager.js

@@ -32,7 +32,13 @@ export class TaskManager extends EventEmitter {
         if (!messageManager)
             return;
         const rootSessionId = messageManager.getRootSessionId();
-        if (this.taskListId !== rootSessionId && !process.env.WAVE_TASK_LIST_ID) {
+        // Read the per-session snapshot (not process.env) so multiple sessions in
+        // one `wave --stdio` process don't cross-pollute this flag.
+        const envSnap = this.container
+            .get("ConfigurationService")
+            ?.getEnvSnapshot() ?? {};
+        const pinnedTaskListId = envSnap.WAVE_TASK_LIST_ID ?? process.env.WAVE_TASK_LIST_ID;
+        if (this.taskListId !== rootSessionId && !pinnedTaskListId) {
             this.setTaskListId(rootSessionId);
             await this.refreshTasks();
         }

package/dist/tools/bashTool.js

@@ -238,6 +238,7 @@ The working directory persists between commands. Try to maintain your current wo
                 cwd: context.workdir,
                 env: {
                     ...process.env,
+                    ...context.sessionEnv,
                 },
             });
             let outputBuffer = "";

package/dist/tools/enterWorktreeTool.js

@@ -2,7 +2,7 @@
  * EnterWorktree tool - creates an isolated git worktree and switches the session into it.
  * Mirrors Claude Code's EnterWorktree tool behavior and prompt.
  */
-import { createWorktree, validateWorktreeName, generateWorktreeName, } from "../utils/worktreeUtils.js";
+import { createWorktree, validateWorktreeName, generateWorktreeName, performPostCreationSetup, } from "../utils/worktreeUtils.js";
 import { getGitMainRepoRoot } from "../utils/gitUtils.js";
 import { ENTER_WORKTREE_TOOL_NAME } from "../constants/tools.js";
 import { logger } from "../utils/globalLogger.js";
@@ -85,6 +85,17 @@ export const enterWorktreeTool = {
         // Create the worktree (captures originalHeadCommit internally)
         const baseRef = context.aiManager?.getWorktreeBaseRef?.();
         const worktreeInfo = createWorktree(name, mainRepoRoot, { baseRef });
+        // Copy local settings (.wave/settings.local.json) and gitignored project
+        // files (.worktreeinclude, e.g. .env/.mcp.json) into a new worktree —
+        // mirrors the CLI createWorktree path. Best-effort, never fails the tool.
+        if (worktreeInfo.isNew) {
+            try {
+                await performPostCreationSetup(worktreeInfo.path, worktreeInfo.repoRoot);
+            }
+            catch (error) {
+                logger?.warn("Worktree post-creation setup failed:", error);
+            }
+        }
         // Build session state
         const session = {
             originalCwd: context.workdir,
@@ -110,10 +121,10 @@ export const enterWorktreeTool = {
                     projectDir: worktreeInfo.path,
                     timestamp: new Date(),
                     sessionId: context.sessionId ?? "",
-                    transcriptPath: context.messageManager?.getTranscriptPath() ?? "",
+                    transcriptPath: context.messageManager?.getTranscriptPath?.() ?? "",
                     cwd: worktreeInfo.path,
                     worktreeName: worktreeInfo.name,
-                    env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)),
+                    env: Object.fromEntries(Object.entries(context.sessionEnv ?? process.env).filter((e) => e[1] !== undefined)),
                 });
                 if (context.messageManager) {
                     context.hookManager.processHookResults("WorktreeCreate", hookResults, context.messageManager);

package/dist/tools/exitWorktreeTool.js

@@ -128,14 +128,8 @@ export const exitWorktreeTool = {
         };
         // Count changes BEFORE removing the worktree (directory will be gone after)
         const summary = countWorktreeChanges(worktreePath, session.originalHeadCommit) ?? { changedFiles: 0, commits: 0 };
-        removeWorktree(worktreeInfo);
-        // Clear session state and restore CWD
-        const aiManager = context.aiManager;
-        if (aiManager) {
-            aiManager.setWorktreeSession(null);
-            aiManager.setWorkdir(originalCwd);
-        }
-        // Trigger WorktreeRemove hook (non-blocking)
+        // Trigger WorktreeRemove hook (non-blocking) BEFORE git removal so hooks
+        // can still read files inside the worktree to clean up external resources.
         let hookTriggered = false;
         if (context.hookManager) {
             try {
@@ -144,10 +138,10 @@ export const exitWorktreeTool = {
                     projectDir: originalCwd,
                     timestamp: new Date(),
                     sessionId: context.sessionId ?? "",
-                    transcriptPath: context.messageManager?.getTranscriptPath() ?? "",
+                    transcriptPath: context.messageManager?.getTranscriptPath?.() ?? "",
                     cwd: originalCwd,
                     worktreePath,
-                    env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)),
+                    env: Object.fromEntries(Object.entries(context.sessionEnv ?? process.env).filter((e) => e[1] !== undefined)),
                 });
                 if (context.messageManager) {
                     context.hookManager.processHookResults("WorktreeRemove", hookResults, context.messageManager);
@@ -159,6 +153,13 @@ export const exitWorktreeTool = {
                 logger?.warn("WorktreeRemove hooks execution failed:", error);
             }
         }
+        removeWorktree(worktreeInfo);
+        // Clear session state and restore CWD
+        const aiManager = context.aiManager;
+        if (aiManager) {
+            aiManager.setWorktreeSession(null);
+            aiManager.setWorkdir(originalCwd);
+        }
         const discardParts = [];
         if (summary.commits > 0) {
             discardParts.push(`${summary.commits} ${summary.commits === 1 ? "commit" : "commits"}`);

package/dist/tools/types.d.ts

@@ -104,4 +104,11 @@ export interface ToolContext {
     originalWorkdir?: string;
     /** Workflow manager instance for workflow orchestration */
     workflowManager?: import("../managers/workflowManager.js").WorkflowManager;
+    /**
+     * Per-session merged environment (OS env overlaid with the settings env
+     * snapshot) for this session. Tools that spawn subprocesses (Bash, hooks)
+     * should merge this on top of `process.env` so settings `env` vars reach
+     * the subprocess without polluting other sessions in one stdio process.
+     */
+    sessionEnv?: Record<string, string>;
 }

package/dist/types/agent.d.ts

@@ -98,6 +98,4 @@ export interface AgentCallbacks extends MessageManagerCallbacks, BackgroundTaskM
     onCommandRunningChange?: (running: boolean) => void;
     onWorkdirChange?: (newCwd: string) => void;
     onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
-    onGoalStateChange?: (active: boolean, condition?: string, elapsed?: string) => void;
-    onGoalEvaluating?: (evaluating: boolean) => void;
 }

package/dist/types/config.d.ts

@@ -10,6 +10,8 @@ export interface GatewayConfig {
     defaultHeaders?: Record<string, string>;
     fetchOptions?: OpenAI["fetchOptions"];
     fetch?: OpenAI["fetch"];
+    /** Session identifier, sent as the `x-session-id` request header for backend correlation. */
+    sessionId?: string;
 }
 export interface ModelCapabilities {
     /** Whether the model supports image/vision input. Default: true. */
@@ -27,4 +29,11 @@ export interface ModelConfig {
     options?: Record<string, unknown>;
     /** Fast model generation params (resolved from models[fastModel].options) */
     fastModelOptions?: Record<string, unknown>;
+    /**
+     * Fast-model-only disable-thinking params passed through verbatim
+     * (e.g. `{ thinking: { type: "disabled" } }`). Applied only in fast-model
+     * scenarios (webFetch content processing, `model: fastModel` subagents),
+     * never in the agent loop. `{}` clears the default.
+     */
+    disableThinkingOptions?: Record<string, unknown>;
 }

package/dist/types/core.d.ts

@@ -22,7 +22,7 @@ export interface Usage {
     completion_tokens: number;
     total_tokens: number;
     model?: string;
-    operation_type?: "agent" | "compact" | "goal_evaluation";
+    operation_type?: "agent" | "compact";
     cache_read_input_tokens?: number;
     cache_creation_input_tokens?: number;
     cache_creation?: {