wave-agent-sdk 0.19.8 → 1.0.0

package/dist/utils/bashParser.js

@@ -430,6 +430,76 @@ export const DANGEROUS_COMMANDS = [
     "nc",
     "netcat",
 ];
+/**
+ * Read-only command set: commands that only read/transform data and write to stdout.
+ * When a command in this set is used without write redirections, command substitution,
+ * or dangerous flags (e.g. sed -i), it is auto-allowed without a confirmation dialog.
+ * Aligned with Claude Code's SEMANTIC_READ_ONLY_COMMANDS, excluding interactive pagers
+ * (less, more, man, info), command executors (xargs), and infinite-output generators (yes).
+ * FR-019.2 through FR-019.7 in tool-permission-system.md.
+ */
+export const READ_ONLY_COMMANDS = [
+    "ls",
+    "cat",
+    "head",
+    "tail",
+    "wc",
+    "sort",
+    "uniq",
+    "grep",
+    "egrep",
+    "fgrep",
+    "rg",
+    "find",
+    "which",
+    "whereis",
+    "file",
+    "stat",
+    "du",
+    "df",
+    "free",
+    "uptime",
+    "uname",
+    "hostname",
+    "whoami",
+    "id",
+    "groups",
+    "env",
+    "printenv",
+    "echo",
+    "printf",
+    "date",
+    "true",
+    "false",
+    "pwd",
+    "tree",
+    "diff",
+    "cmp",
+    "md5sum",
+    "sha256sum",
+    "sha1sum",
+    "xxd",
+    "od",
+    "hexdump",
+    "strings",
+    "readlink",
+    "realpath",
+    "basename",
+    "dirname",
+    "seq",
+    "column",
+    "jq",
+    "yq",
+    "cut",
+    "paste",
+    "tr",
+    "awk",
+    "sed",
+    "test",
+    "expr",
+    "bc",
+    "sleep",
+];
 export const TOOL_RULES = {
     // Node/JS
     npm: { depth: 2, scopeFlags: ["--prefix", "-C", "--registry"] },
@@ -567,6 +637,39 @@ export function isDangerousFind(command) {
         return dangerousFlags.includes(unquoted);
     });
 }
+/**
+ * Detects command substitution $(...) or backticks `...` in a command string.
+ * Commands with substitution are never auto-allowed because the substituted
+ * command may be dangerous (e.g. cat $(rm x)). FR-019.6.
+ */
+export function hasCommandSubstitution(command) {
+    // Remove quoted strings first so $() or backticks inside quotes don't trigger
+    const stripped = command
+        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+        .replace(/'(?:[^'\\]|\\.)*'/g, "''");
+    return /\$\([^)]*\)/.test(stripped) || /`[^`]*`/.test(stripped);
+}
+/**
+ * Detects process substitution <(...) or >(...) in a command string.
+ * These can execute side effects and are never auto-allowed. FR-019.6.
+ */
+export function hasProcessSubstitution(command) {
+    const stripped = command
+        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+        .replace(/'(?:[^'\\]|\\.)*'/g, "''");
+    return /[<>]\([^)]*\)/.test(stripped);
+}
+/**
+ * Detects sed in-place edit flag (-i, with optional backup suffix like -i.bak).
+ * sed -i modifies files in place and must NOT be auto-allowed. FR-019.5.
+ */
+export function hasSedInPlace(command) {
+    const stripped = stripRedirections(stripEnvVars(command));
+    const tokens = stripped.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    if (tokens.length === 0 || tokens[0] !== "sed")
+        return false;
+    return tokens.some((token) => /^-i(\..*)?$/.test(token));
+}
 /**
  * Extracts a "smart prefix" from a bash command based on common developer tools.
  * Returns null if the command is blacklisted or cannot be safely prefix-matched.

package/dist/utils/configPaths.d.ts

@@ -18,6 +18,10 @@ export declare function getBuiltinSkillsDir(): string;
  * Get the builtin subagents directory path
  */
 export declare function getBuiltinSubagentsDir(): string;
+/**
+ * Get the builtin plugins directory path
+ */
+export declare function getBuiltinPluginsDir(): string;
 /**
  * Get the user-specific configuration file path (legacy function)
  * @deprecated Use getUserConfigPaths() for better priority support

package/dist/utils/configPaths.js

@@ -46,6 +46,12 @@ export function getBuiltinSkillsDir() {
 export function getBuiltinSubagentsDir() {
     return join(getPackageRoot(), "builtin", "subagents");
 }
+/**
+ * Get the builtin plugins directory path
+ */
+export function getBuiltinPluginsDir() {
+    return join(getPackageRoot(), "builtin", "plugins");
+}
 /**
  * Get the user-specific configuration file path (legacy function)
  * @deprecated Use getUserConfigPaths() for better priority support

package/dist/utils/containerSetup.js

@@ -159,7 +159,7 @@ export function setupAgentContainer(setupOptions) {
                     toolName: context.toolName,
                     toolInput: context.toolInput,
                     planFilePath: permissionManager.getPlanFilePath(),
-                    env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)),
+                    env: Object.fromEntries(Object.entries(configurationService.getMergedEnv()).filter((e) => e[1] !== undefined)),
                 });
                 if (results.length > 0) {
                     const processResult = hookManager.processHookResults("PermissionRequest", results, messageManager);

package/dist/utils/fileSearch.js

@@ -25,9 +25,11 @@ async function getAllFiles(workingDirectory) {
             stderr += data.toString();
         });
         child.on("close", (code) => {
+            // Exit 2 = some files were unreadable (e.g. device-name files like
+            // "nul" on Windows); stdout still holds usable partial results.
+            // Spawn failures surface via the 'error' listener instead.
             if (code !== 0 && code !== 1) {
-                reject(new Error(`ripgrep failed: ${stderr}`));
-                return;
+                logger.warn(`ripgrep exited with code ${code}, keeping partial results: ${stderr.trim()}`);
             }
             const files = stdout
                 .trim()

package/dist/utils/openaiClient.js

@@ -36,11 +36,12 @@ export class OpenAIClient {
         };
     }
     async _create(params, options) {
-        const { baseURL, apiKey, defaultHeaders, fetchOptions, fetch: customFetch, } = this.config;
+        const { baseURL, apiKey, sessionId, defaultHeaders, fetchOptions, fetch: customFetch, } = this.config;
         const url = `${baseURL}/chat/completions`;
         const headers = {
             "Content-Type": "application/json",
             ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+            ...(sessionId ? { "x-session-id": sessionId } : {}),
             ...defaultHeaders,
         };
         const fetchFn = customFetch || fetch;

package/dist/utils/pathEncoder.js

@@ -127,8 +127,13 @@ export class PathEncoder {
             // If realpath fails, use the absolute path
             resolvedPath = absolutePath;
         }
-        // Encode the resolved path
-        const encodedName = await this.encode(resolvedPath);
+        // Encode the resolved path. Use encodeSync (pure string transform) rather
+        // than encode(): realpath was already attempted above with its own fallback,
+        // so re-resolving via encode()->resolvePath() would throw ENOENT again when
+        // the workdir no longer exists (e.g. a deleted worktree during agent
+        // shutdown). Session files live under <baseSessionDir>/<encoded>/ regardless
+        // of the workdir's existence, so encoding must not require it to exist.
+        const encodedName = this.encodeSync(resolvedPath);
         const encodedPath = join(baseSessionDir, encodedName);
         // Generate hash if encoding resulted in truncation
         let pathHash;

package/dist/utils/worktreeUtils.d.ts

@@ -33,10 +33,27 @@ export declare function getHeadCommit(cwd: string): string;
 export declare function createWorktree(name: string, cwd: string, options?: {
     baseRef?: "fresh" | "head";
 }): WorktreeInfo;
+/**
+ * Set up a freshly created worktree: copy local settings and gitignored
+ * project files (via .worktreeinclude) from the main repo. Best-effort — any
+ * failure only logs a warning and never fails worktree creation.
+ */
+export declare function performPostCreationSetup(worktreePath: string, repoRoot: string): Promise<void>;
 /**
  * Remove a git worktree and its branch.
  */
 export declare function removeWorktree(info: WorktreeInfo): void;
+/**
+ * Validate that a worktree path is safe to remove before running git removal.
+ * Aligns with Claude Code v2.1.216+ background-session checks:
+ * - rejects a path whose final component is a symlink;
+ * - rejects a path that resolves outside the repo root.
+ *
+ * A path that no longer exists (worktree already removed) is allowed so that
+ * removal stays best-effort/idempotent; its nearest existing ancestor is used
+ * for the containment check. Throws an Error on invalid paths.
+ */
+export declare function validateWorktreeRemovalPath(worktreePath: string, repoRoot: string): void;
 /**
  * Count uncommitted files and new commits in a worktree.
  * Returns null if git commands fail (fail-closed).

package/dist/utils/worktreeUtils.js

@@ -2,11 +2,16 @@
  * Git worktree creation and removal utilities for the SDK.
  * Used by EnterWorktree and ExitWorktree tools.
  */
-import { execFileSync } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { getGitMainRepoRoot, getDefaultRemoteBranch, ensureWaveRuntimeFilesExcluded, } from "./gitUtils.js";
 import { logger } from "./globalLogger.js";
+// Post-creation setup runs inside the shared `wave --stdio` process too
+// (desktop sessions), so use the async execFile: a synchronous git call
+// (e.g. `git ls-files` over a large working tree) would freeze every session.
+const execFileAsync = promisify(execFile);
 /**
  * Validate a worktree name to prevent path traversal and invalid characters.
  */
@@ -211,6 +216,288 @@ export function createWorktree(name, cwd, options) {
         throw new Error(`Failed to create worktree: ${error.message}\n${stderr}`);
     }
 }
+/** Translate a single gitignore glob into a RegExp (gitignore semantics). */
+function globToRegExp(glob) {
+    let source = "^";
+    for (let i = 0; i < glob.length; i++) {
+        const ch = glob[i];
+        if (ch === "*") {
+            if (glob[i + 1] === "*") {
+                if (glob[i + 2] === "/") {
+                    // "**/" matches zero or more leading directories
+                    source += "(?:.*/)?";
+                    i += 2;
+                }
+                else {
+                    source += ".*";
+                    i += 1;
+                }
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (ch === "?") {
+            source += "[^/]";
+        }
+        else if (ch === "[") {
+            const end = glob.indexOf("]", i + 1);
+            if (end === -1) {
+                source += "\\[";
+            }
+            else {
+                let charClass = glob.slice(i, end + 1);
+                if (charClass.startsWith("[!")) {
+                    // gitignore uses "[!...]" for a negated character class
+                    charClass = "[^" + charClass.slice(2);
+                }
+                source += charClass;
+                i = end;
+            }
+        }
+        else {
+            source += ch.replace(/[.+^${}()|\\]/g, "\\$&");
+        }
+    }
+    source += "$";
+    return new RegExp(source);
+}
+/**
+ * Parse .worktreeinclude content into patterns. Blank lines and "#" comments
+ * are skipped, matching gitignore conventions.
+ */
+function parseWorktreeIncludePatterns(content) {
+    const patterns = [];
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        let raw = line;
+        const negated = raw.startsWith("!");
+        if (negated)
+            raw = raw.slice(1);
+        const dirOnly = raw.endsWith("/");
+        if (dirOnly)
+            raw = raw.slice(0, -1);
+        const anchored = raw.startsWith("/");
+        if (anchored)
+            raw = raw.slice(1);
+        if (!raw)
+            continue;
+        patterns.push({
+            raw,
+            negated,
+            dirOnly,
+            anchored,
+            anyLevel: !anchored && !raw.includes("/"),
+            regex: globToRegExp(raw),
+        });
+    }
+    return patterns;
+}
+/** Test a single pattern against one candidate path. */
+function testPatternAgainst(pattern, candidate) {
+    if (pattern.anyLevel) {
+        // Match the full path or any "/"-suffix (basename at any level)
+        if (pattern.regex.test(candidate))
+            return true;
+        for (let i = 0; i < candidate.length; i++) {
+            if (candidate[i] === "/" && pattern.regex.test(candidate.slice(i + 1))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return pattern.regex.test(candidate);
+}
+/**
+ * Test a pattern against a path and every ancestor prefix. Excluding a
+ * directory excludes everything beneath it (gitignore semantics), so ancestor
+ * prefixes are always treated as directories.
+ */
+function patternMatchesPath(pattern, relPath, isDir) {
+    let candidate = relPath;
+    for (;;) {
+        const candidateIsDir = candidate === relPath ? isDir : true;
+        if (!(pattern.dirOnly && !candidateIsDir) &&
+            testPatternAgainst(pattern, candidate)) {
+            return true;
+        }
+        const idx = candidate.lastIndexOf("/");
+        if (idx === -1)
+            break;
+        candidate = candidate.slice(0, idx);
+    }
+    return false;
+}
+/** Last-match-wins resolution with "!" negation. */
+function worktreeIncludeMatches(patterns, relPath, isDir) {
+    let matched = false;
+    for (const pattern of patterns) {
+        if (patternMatchesPath(pattern, relPath, isDir)) {
+            matched = !pattern.negated;
+        }
+    }
+    return matched;
+}
+/**
+ * A positive pattern targets something inside a collapsed directory: either it
+ * literally starts with the directory path, or the directory path starts with
+ * the pattern's literal (pre-glob) prefix.
+ */
+function needsExpansion(patterns, dir) {
+    return patterns.some((p) => {
+        if (p.negated)
+            return false;
+        if (p.raw.startsWith(dir + "/"))
+            return true;
+        const globIdx = p.raw.search(/[*?[]/);
+        if (globIdx > 0 && dir.startsWith(p.raw.slice(0, globIdx)))
+            return true;
+        return false;
+    });
+}
+// --- Post-creation setup -----------------------------------------------------
+/**
+ * Copy <repoRoot>/.wave/settings.local.json into the worktree so local
+ * configuration (permissions, env, ...) carries over. Missing files are
+ * skipped silently; other failures only log a warning.
+ */
+async function copyLocalSettingsToWorktree(repoRoot, worktreePath) {
+    const relativePath = path.join(".wave", "settings.local.json");
+    const sourcePath = path.join(repoRoot, relativePath);
+    const destPath = path.join(worktreePath, relativePath);
+    let content;
+    try {
+        content = await fs.promises.readFile(sourcePath, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            logger.warn(`Failed to read ${sourcePath}: ${error.message}`);
+        }
+        return;
+    }
+    try {
+        await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+        await fs.promises.writeFile(destPath, content);
+    }
+    catch (error) {
+        logger.warn(`Failed to copy ${relativePath} into worktree: ${error.message}`);
+    }
+}
+/**
+ * Copy files listed in <repoRoot>/.worktreeinclude into the worktree. Each
+ * non-comment line is a gitignore pattern; matching gitignored files are
+ * copied at their relative paths.
+ */
+async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
+    const includePath = path.join(repoRoot, ".worktreeinclude");
+    let content;
+    try {
+        content = await fs.promises.readFile(includePath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const patterns = parseWorktreeIncludePatterns(content);
+    if (patterns.length === 0)
+        return [];
+    const worktreeRelPath = path
+        .relative(repoRoot, worktreePath)
+        .split(path.sep)
+        .join("/");
+    // The worktree lives under .wave/worktrees/, which is gitignored — never
+    // copy the worktree (or anything inside it) into itself.
+    const isSelf = (entry) => entry === worktreeRelPath || entry.startsWith(worktreeRelPath + "/");
+    // "--directory" collapses fully-ignored directories into single entries,
+    // which keeps the listing fast on large repos.
+    let entries;
+    try {
+        const { stdout } = await execFileAsync("git", [
+            "ls-files",
+            "--others",
+            "--ignored",
+            "--exclude-standard",
+            "--directory",
+        ], { cwd: repoRoot, encoding: "utf8" });
+        entries = stdout.trim().split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+    const copied = [];
+    const dirsToExpand = [];
+    const copyToWorktree = async (relativePath) => {
+        const srcPath = path.join(repoRoot, relativePath);
+        const destPath = path.join(worktreePath, relativePath);
+        try {
+            await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.promises.copyFile(srcPath, destPath);
+            copied.push(relativePath);
+        }
+        catch (error) {
+            logger.warn(`Failed to copy ${relativePath} into worktree: ${error.message}`);
+        }
+    };
+    for (const entry of entries) {
+        if (isSelf(entry))
+            continue;
+        if (entry.endsWith("/")) {
+            const dir = entry.slice(0, -1);
+            if (worktreeIncludeMatches(patterns, dir, true)) {
+                // The directory itself matches — copy it wholesale
+                try {
+                    await fs.promises.cp(path.join(repoRoot, dir), path.join(worktreePath, dir), {
+                        recursive: true,
+                    });
+                    copied.push(entry);
+                }
+                catch (error) {
+                    logger.warn(`Failed to copy ${entry} into worktree: ${error.message}`);
+                }
+            }
+            else if (needsExpansion(patterns, dir)) {
+                dirsToExpand.push(dir);
+            }
+        }
+        else if (worktreeIncludeMatches(patterns, entry, false)) {
+            await copyToWorktree(entry);
+        }
+    }
+    if (dirsToExpand.length > 0) {
+        // List the files inside collapsed dirs whose contents are targeted
+        try {
+            const { stdout } = await execFileAsync("git", [
+                "ls-files",
+                "--others",
+                "--ignored",
+                "--exclude-standard",
+                "--",
+                ...dirsToExpand,
+            ], { cwd: repoRoot, encoding: "utf8" });
+            for (const file of stdout.trim().split("\n").filter(Boolean)) {
+                if (isSelf(file))
+                    continue;
+                if (worktreeIncludeMatches(patterns, file, false)) {
+                    await copyToWorktree(file);
+                }
+            }
+        }
+        catch {
+            // Expansion is best-effort; the worktree is already usable without it
+        }
+    }
+    return copied;
+}
+/**
+ * Set up a freshly created worktree: copy local settings and gitignored
+ * project files (via .worktreeinclude) from the main repo. Best-effort — any
+ * failure only logs a warning and never fails worktree creation.
+ */
+export async function performPostCreationSetup(worktreePath, repoRoot) {
+    await copyLocalSettingsToWorktree(repoRoot, worktreePath);
+    await copyWorktreeIncludeFiles(repoRoot, worktreePath);
+}
 /**
  * Remove a git worktree and its branch.
  */
@@ -273,6 +560,57 @@ export function removeWorktree(info) {
         throw error;
     }
 }
+/**
+ * Validate that a worktree path is safe to remove before running git removal.
+ * Aligns with Claude Code v2.1.216+ background-session checks:
+ * - rejects a path whose final component is a symlink;
+ * - rejects a path that resolves outside the repo root.
+ *
+ * A path that no longer exists (worktree already removed) is allowed so that
+ * removal stays best-effort/idempotent; its nearest existing ancestor is used
+ * for the containment check. Throws an Error on invalid paths.
+ */
+export function validateWorktreeRemovalPath(worktreePath, repoRoot) {
+    const SYMLINK_PREFIX = "Refusing to remove worktree at symlink path:";
+    // Reject a symlink as the final path component.
+    try {
+        if (fs.lstatSync(worktreePath).isSymbolicLink()) {
+            throw new Error(`${SYMLINK_PREFIX} ${worktreePath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith(SYMLINK_PREFIX)) {
+            throw error;
+        }
+        // lstat failed (path missing) — the containment check below still applies.
+    }
+    const resolvedRepoRoot = fs.realpathSync(repoRoot);
+    // Resolve the path, following symlinks in existing components. If the path
+    // (or a parent) no longer exists, fall back to the deepest existing ancestor
+    // so the containment check still guards against traversal outside the repo.
+    let resolvedPath;
+    let existingAncestor = worktreePath;
+    for (;;) {
+        try {
+            resolvedPath = fs.realpathSync(existingAncestor);
+            break;
+        }
+        catch {
+            const parent = path.dirname(existingAncestor);
+            if (parent === existingAncestor) {
+                throw new Error(`Invalid worktree path for removal: ${worktreePath}`);
+            }
+            existingAncestor = parent;
+        }
+    }
+    if (existingAncestor !== worktreePath) {
+        resolvedPath = path.join(resolvedPath, path.relative(existingAncestor, worktreePath));
+    }
+    const relative = path.relative(resolvedRepoRoot, resolvedPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Refusing to remove worktree outside repo root: ${worktreePath}`);
+    }
+}
 /**
  * Count uncommitted files and new commits in a worktree.
  * Returns null if git commands fail (fail-closed).

package/package.json

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

package/src/agent.ts

@@ -78,6 +78,7 @@ export class Agent {
   private reversionManager: ReversionManager;
   private messageQueue: MessageQueue; // Unified queue for messages, bang commands, and notifications
   private dispatchPromise: Promise<void> | null = null; // Track current dispatch for teardown
+  private isAborting = false; // Guard: prevents tryDispatch from firing during abortMessage
   private memoryRuleManager: MemoryRuleManager; // Add memory rule manager instance
   private liveConfigManager: LiveConfigManager; // Add live configuration manager
   private taskManager: TaskManager;
@@ -94,7 +95,10 @@ export class Agent {
 
   // Dynamic configuration getter methods
   public getGatewayConfig(): GatewayConfig {
-    return this.configurationService.resolveGatewayConfig();
+    return {
+      ...this.configurationService.resolveGatewayConfig(),
+      sessionId: this.messageManager.getSessionId(),
+    };
   }
 
   public getModelConfig(): ModelConfig {
@@ -412,6 +416,7 @@ export class Agent {
    * onLoadingChange(false), and onCommandRunningChange(false).
    */
   private tryDispatch(): void {
+    if (this.isAborting) return; // Suppress dispatch during abort to prevent queued notifications from being dispatched as a side-effect
     if (this.messageQueue.state !== "idle") return;
     if (!this.messageQueue.hasPending()) return;
     if (this.aiManager.isLoading || this.isCommandRunning) return;
@@ -847,17 +852,24 @@ export class Agent {
 
   /** Unified interrupt method, interrupts both AI messages and command execution */
   public abortMessage(): void {
-    if (this.aiManager.isLoading || this.isCommandRunning) {
-      // Clear user-facing queue items first to prevent processQueuedMessage
-      // from dequeuing when abortAIMessage triggers onLoadingChange(false).
-      // Notifications are preserved so background task results aren't lost.
-      this.messageQueue.clear();
-      this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
+    // Guard: prevent tryDispatch (triggered by abortAIMessage → setIsLoading(false))
+    // from dispatching preserved notifications as a new AI turn during the abort.
+    this.isAborting = true;
+    try {
+      if (this.aiManager.isLoading || this.isCommandRunning) {
+        // Clear user-facing queue items first to prevent processQueuedMessage
+        // from dequeuing when abortAIMessage triggers onLoadingChange(false).
+        // Notifications are preserved so background task results aren't lost.
+        this.messageQueue.clear();
+        this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
+      }
+      this.messageQueue.transitionTo("idle"); // Reset state on abort
+      this.abortAIMessage(); // This will abort tools including Agent tool (subagents)
+      this.abortBashCommand();
+      this.abortSlashCommand();
+    } finally {
+      this.isAborting = false;
     }
-    this.messageQueue.transitionTo("idle"); // Reset state on abort
-    this.abortAIMessage(); // This will abort tools including Agent tool (subagents)
-    this.abortBashCommand();
-    this.abortSlashCommand();
   }
 
   /** Interrupt bash command execution */
@@ -915,7 +927,9 @@ export class Agent {
           cwd: this.workdir,
           worktreePath,
           env: Object.fromEntries(
-            Object.entries(process.env).filter((e) => e[1] !== undefined),
+            Object.entries(this.configurationService.getMergedEnv()).filter(
+              (e) => e[1] !== undefined,
+            ),
           ) as Record<string, string>,
         },
       );

package/src/index.ts

@@ -29,6 +29,7 @@ export * from "./utils/tokenCalculation.js";
 export * from "./utils/gitUtils.js";
 export * from "./utils/nameGenerator.js";
 export * from "./utils/worktreeSession.js";
+export * from "./utils/worktreeUtils.js";
 export { loadMergedWaveConfig } from "./services/configurationService.js";
 export * from "./types/index.js";