wave-agent-sdk 0.19.9 → 1.0.1

package/src/services/configurationService.ts

@@ -61,6 +61,10 @@ export class ConfigurationService {
   private currentConfiguration: WaveConfiguration | null = null;
   private options: AgentOptions = {};
   private _configuredEnvKeys = new Set<string>();
+  // 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`.
+  private envSnapshot: Record<string, string> = {};
 
   /**
    * Set agent options for configuration resolution
@@ -69,6 +73,28 @@ export class ConfigurationService {
     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(): Record<string, string> {
+    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(): Record<string, string> {
+    return Object.fromEntries(
+      Object.entries({ ...process.env, ...this.envSnapshot }).filter(
+        ([, v]) => v !== undefined,
+      ),
+    ) as Record<string, string>;
+  }
+
   // Core loading operations
 
   /**
@@ -384,16 +410,33 @@ 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: Record<string, string>): void {
     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;
+      }
     }
   }
 
@@ -437,8 +480,11 @@ export class ConfigurationService {
     fetchOptions?: ClientOptions["fetchOptions"],
     fetch?: ClientOptions["fetch"],
   ): GatewayConfig {
-    // 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 ||
@@ -469,7 +515,8 @@ export class ConfigurationService {
     } else if (this.options.apiKey !== undefined) {
       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
@@ -480,15 +527,18 @@ export class ConfigurationService {
     } else if (this.options.baseURL !== undefined) {
       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
@@ -497,7 +547,10 @@ export class ConfigurationService {
     }
 
     // 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
@@ -539,11 +592,13 @@ export class ConfigurationService {
       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;
+      fastModel ||
+      this.options.fastModel ||
+      (this.envSnapshot.WAVE_FAST_MODEL ?? process.env.WAVE_FAST_MODEL);
 
     // Resolve max output tokens
     const resolvedMaxTokens = this.resolveMaxOutputTokens(maxTokens);
@@ -564,16 +619,31 @@ export class ConfigurationService {
       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: ModelConfig = {
         ...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;
@@ -596,8 +666,10 @@ export class ConfigurationService {
       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)) {
@@ -645,9 +717,9 @@ export class ConfigurationService {
       return this.currentConfiguration.autoMemoryEnabled;
     }
 
-    // 2. WAVE_DISABLE_AUTO_MEMORY environment variable
+    // 2. WAVE_DISABLE_AUTO_MEMORY environment variable (settings snapshot > OS env)
     const disableAutoMemory =
-      process.env.WAVE_DISABLE_AUTO_MEMORY ||
+      this.envSnapshot.WAVE_DISABLE_AUTO_MEMORY ??
       process.env.WAVE_DISABLE_AUTO_MEMORY;
     if (disableAutoMemory === "1" || disableAutoMemory === "true") {
       return false;
@@ -681,9 +753,9 @@ export class ConfigurationService {
       return this.currentConfiguration.autoMemoryFrequency;
     }
 
-    // 2. WAVE_AUTO_MEMORY_FREQUENCY environment variable
+    // 2. WAVE_AUTO_MEMORY_FREQUENCY environment variable (settings snapshot > OS env)
     const envFrequency =
-      process.env.WAVE_AUTO_MEMORY_FREQUENCY ||
+      this.envSnapshot.WAVE_AUTO_MEMORY_FREQUENCY ??
       process.env.WAVE_AUTO_MEMORY_FREQUENCY;
     if (envFrequency) {
       const parsed = parseInt(envFrequency, 10);
@@ -713,8 +785,10 @@ export class ConfigurationService {
       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) {
@@ -761,8 +835,10 @@ export class ConfigurationService {
   getConfiguredModels(): string[] {
     const models = new Set<string>();
 
-    // 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/src/services/initializationService.ts

@@ -126,13 +126,17 @@ export class InitializationService {
       // 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`,
+        `Initialization Phase [Remote Settings Cache] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
       );
     } catch (error) {
       logger?.error("Failed to initialize remote settings:", error);
@@ -190,6 +194,13 @@ export class InitializationService {
       // 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();
@@ -237,7 +248,9 @@ export class InitializationService {
           cwd: workdir,
           worktreeName: agentOptions.worktreeName,
           env: Object.fromEntries(
-            Object.entries(process.env).filter((e) => e[1] !== undefined),
+            Object.entries(configurationService.getMergedEnv()).filter(
+              (e) => e[1] !== undefined,
+            ),
           ) as Record<string, string>,
         });
 

package/src/services/interactionService.ts

@@ -93,7 +93,9 @@ export class InteractionService {
               cwd: workdir,
               userPrompt: content,
               env: Object.fromEntries(
-                Object.entries(process.env).filter((e) => e[1] !== undefined),
+                Object.entries(
+                  context.configurationService.getMergedEnv(),
+                ).filter((e) => e[1] !== undefined),
               ) as Record<string, string>, // Include environment variables
             },
           );
@@ -137,6 +139,7 @@ export class InteractionService {
   ): Promise<void> {
     const {
       messageManager,
+      hookManager,
       logger,
       subagentManager,
       taskManager,
@@ -157,7 +160,24 @@ export class InteractionService {
       // 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 as Error).message}`,
+        );
+      }
+    }
+
+    // 4. Load target session
     const sessionData = await loadSessionFromJsonl(
       sessionId,
       messageManager.getWorkdir(),
@@ -166,20 +186,43 @@ export class InteractionService {
       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 as 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/src/services/remoteSettingsService.ts

@@ -198,8 +198,22 @@ function startPolling(): void {
 }
 
 export function initialize(): void {
+  // 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(): void {
   fetchRemoteSettings()
     .then(() => startPolling())
     .catch((err) => {
@@ -342,6 +356,7 @@ export function mergeRemoteSettings(
  */
 export const remoteSettingsService = {
   initialize,
+  startBackgroundFetch,
   getRemoteSettingsSync,
   refresh,
   clear,

package/src/services/session.ts

@@ -612,6 +612,74 @@ export async 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 async function cleanupMetaOnlySessions(): Promise<number> {
+  // 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/src/services/taskManager.ts

@@ -6,6 +6,7 @@ import { Task } from "../types/tasks.js";
 import { logger } from "../utils/globalLogger.js";
 import { Container } from "../utils/container.js";
 import type { MessageManager } from "../managers/messageManager.js";
+import type { ConfigurationService } from "./configurationService.js";
 
 function byIdAsc(a: Task, b: Task) {
   const aNum = parseInt(a.id, 10);
@@ -44,7 +45,15 @@ 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>("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/src/tools/bashTool.ts

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

package/src/tools/enterWorktreeTool.ts

@@ -9,6 +9,7 @@ import {
   createWorktree,
   validateWorktreeName,
   generateWorktreeName,
+  performPostCreationSetup,
 } from "../utils/worktreeUtils.js";
 import { getGitMainRepoRoot } from "../utils/gitUtils.js";
 import { ENTER_WORKTREE_TOOL_NAME } from "../constants/tools.js";
@@ -105,6 +106,20 @@ export const enterWorktreeTool: ToolPlugin = {
     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: WorktreeSession = {
       originalCwd: context.workdir,
@@ -134,11 +149,13 @@ export const enterWorktreeTool: ToolPlugin = {
             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),
+              Object.entries(context.sessionEnv ?? process.env).filter(
+                (e) => e[1] !== undefined,
+              ),
             ) as Record<string, string>,
           },
         );

package/src/tools/exitWorktreeTool.ts

@@ -162,16 +162,8 @@ export const exitWorktreeTool: ToolPlugin = {
       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 {
@@ -182,11 +174,13 @@ export const exitWorktreeTool: ToolPlugin = {
             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),
+              Object.entries(context.sessionEnv ?? process.env).filter(
+                (e) => e[1] !== undefined,
+              ),
             ) as Record<string, string>,
           },
         );
@@ -206,6 +200,15 @@ export const exitWorktreeTool: ToolPlugin = {
       }
     }
 
+    removeWorktree(worktreeInfo);
+
+    // Clear session state and restore CWD
+    const aiManager = context.aiManager;
+    if (aiManager) {
+      aiManager.setWorktreeSession(null);
+      aiManager.setWorkdir(originalCwd);
+    }
+
     const discardParts: string[] = [];
     if (summary.commits > 0) {
       discardParts.push(

package/src/tools/types.ts

@@ -127,4 +127,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/src/types/agent.ts

@@ -119,10 +119,4 @@ export interface AgentCallbacks
   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/src/types/config.ts

@@ -12,6 +12,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 {
@@ -31,4 +33,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/src/types/core.ts

@@ -25,7 +25,7 @@ export interface Usage {
   completion_tokens: number; // Tokens generated in completions
   total_tokens: number; // Sum of prompt + completion tokens
   model?: string; // Model used for the operation (e.g., "gpt-4", "gpt-3.5-turbo")
-  operation_type?: "agent" | "compact" | "goal_evaluation"; // Type of operation that generated usage
+  operation_type?: "agent" | "compact"; // Type of operation that generated usage
 
   // Cache-related tokens (Claude top-level + OpenAI prompt_tokens_details)
   cache_read_input_tokens?: number; // Tokens read from cache (Claude) or cached_tokens (OpenAI prompt_tokens_details)