wave-agent-sdk 1.1.5 → 1.3.0

package/dist/utils/userSettings.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 用户偏好设置（三端设置页读写的子集）的读写工具。
+ *
+ * 落点唯一 = 用户级 `~/.wave/settings.json`（`getUserConfigPaths()[0]`）：
+ * 三端（VS Code 扩展 / JetBrains 插件 / 桌面端）设置页保存的 AI 回复语言、
+ * 上下文长度、自动记忆开关/轮次、服务端地址都写这个文件，由 SDK 的实时重载
+ * （LiveConfigManager）在各会话下一轮开始时生效——不经 `AgentOptions`
+ * 覆盖层下发（覆盖层优先级高于 settings.json，会永久遮蔽实时配置，
+ * 见 docs/specs/core/agent-config.md「设置实时重载」「分层职责」）。
+ *
+ * 上下文长度的键 = `env.WAVE_MAX_INPUT_TOKENS`（全局默认，K×1000 落盘、
+ * 回读按同一换算），UI 与线协议都传 K 值。
+ *
+ * 服务端地址的键 = `env.WAVE_SERVER_URL`（SDK 既有键，解析链
+ * `options.serverUrl > process.env.WAVE_SERVER_URL > DEFAULT_SERVER_URL`；
+ * settings `env` 的值经 `setEnvironmentVars` 特例镜像到 `process.env`，
+ * 见 docs/specs/core/agent-config.md 边界说明「服务端地址的落点」）。
+ *
+ * 写入是「读-改-写」：只覆盖这些键，其余顶层键与 `env` 下其它键原样保留。
+ *
+ * `readUserPreferenceView` 额外回答**当前生效值来自哪一层**：用户级文件是用户
+ * 偏好的**落点**，但企业下发的 remote-settings（或机器上的环境变量）可以盖过它，
+ * 此时只读用户文件会得到「显示值 ≠ 生效值」（spec core/agent-config.md
+ * 边界说明「用户偏好的层与来源」）。设置页据此对「由组织配置管理」的键置灰。
+ */
+import type { UserPreferenceKey, UserPreferenceSettings, UserPreferenceSource, WaveConfiguration } from "../types/configuration.js";
+export type { UserPreferenceSettings };
+/** 上下文长度在 settings.json 中的落点（全局默认，spec 边界说明「上下文长度的落点」）。 */
+export declare const MAX_INPUT_TOKENS_ENV_KEY = "WAVE_MAX_INPUT_TOKENS";
+/**
+ * 自动记忆的 env 键，与 `ConfigurationService.resolveAutoMemoryEnabledFrom` /
+ * `resolveAutoMemoryFrequency` 读取的键名一致（本视图只按同一优先级归因，
+ * 不改变解析行为）。
+ */
+export declare const DISABLE_AUTO_MEMORY_ENV_KEY = "WAVE_DISABLE_AUTO_MEMORY";
+export declare const AUTO_MEMORY_FREQUENCY_ENV_KEY = "WAVE_AUTO_MEMORY_FREQUENCY";
+/**
+ * 服务端地址的 env 键（SDK 既有键，见文件头与
+ * `ConfigurationService.setEnvironmentVars` 的镜像特例）。
+ */
+export declare const SERVER_URL_ENV_KEY = "WAVE_SERVER_URL";
+/** 用户偏好键（设置页控件）。 */
+export type { UserPreferenceKey, UserPreferenceSource };
+/** 生效偏好 + 每个键的来源。 */
+export interface UserPreferenceView {
+    /** 生效值；键缺失 = 该偏好没有任何提供者（落 SDK 默认/未设置态）。 */
+    values: UserPreferenceSettings;
+    /** 每个键恒有来源（缺省即 `default`）。 */
+    sources: Record<UserPreferenceKey, UserPreferenceSource>;
+}
+/** UI 的 K 值 → settings.json 的 token 数（K×1000）。 */
+export declare function contextLengthToMaxInputTokens(contextLengthK: number): number;
+/** settings.json 的 token 数 → UI 的 K 值（回读按同一换算）。 */
+export declare function maxInputTokensToContextLength(maxInputTokens: string | undefined): number | undefined;
+/** 用户级 settings.json 路径（`~/.wave/settings.json`）。 */
+export declare function userSettingsFilePath(): string;
+/**
+ * 读取当前用户偏好。文件缺失或损坏时返回空对象（与
+ * `loadWaveConfigFromFile` 的容错一致：损坏只影响展示，不阻塞设置页渲染）；
+ * 写入路径则会明确报错而不是覆盖用户文件。
+ */
+export declare function readUserPreferenceSettings(filePath?: string): UserPreferenceSettings;
+/**
+ * 读取**生效**用户偏好及其来源层。
+ *
+ * 优先级与各 resolve 链一致（只按**进程级可达**的层归因）：Remote 组织下发
+ * （顶层键，以及其 `env` 的 `WAVE_MAX_INPUT_TOKENS` / `WAVE_DISABLE_AUTO_MEMORY` /
+ * `WAVE_AUTO_MEMORY_FREQUENCY`）> 用户级文件（同样两种落点）> 机器环境变量
+ * （`process.env`）> 默认。Remote 胜出与 `mergeRemoteSettings` 的「标量远程赢、
+ * env 逐键远程赢」一致（remoteSettingsService.ts）。
+ *
+ * `values` 的语义**与只读用户文件时完全一致**：只有真的有提供者才会出现该键，
+ * 没有任何层提供时键缺失（设置页据此显示「未设置」态、按 SDK 默认值展示）。
+ * 新增信息只在 `sources`：每个键恒有来源（缺省 `default`）。
+ *
+ * 注意归因范围：`project`（`.wave/settings.json`）/ `local`（`.wave/settings.local.json`）
+ * 需要 workdir，而本 RPC 是刻意的无会话全局请求；`override` / `options` 是会话级
+ * 语义。三者都不在本视图的归因范围内——被它们覆盖时这里仍按进程级各层给出
+ * 「本层值」，见 spec core/agent-config.md 边界说明「用户偏好的层与来源」。
+ *
+ * @param remote - Remote 组织下发配置（默认取进程内缓存）
+ * @param filePath - 用户级 settings.json 路径
+ * @param env - 机器环境变量（默认 `process.env`，便于测试注入）
+ */
+export declare function readUserPreferenceView(remote?: WaveConfiguration | null, filePath?: string, env?: Record<string, string | undefined>): UserPreferenceView;
+/**
+ * 把 `patch` 里的键合并进用户级 settings.json，返回写入后的完整用户偏好。
+ * 未提供的键保持文件中现值；`patch` 为空时只回读、不落盘（无差异保存）。
+ */
+export declare function updateUserPreferenceSettings(patch: UserPreferenceSettings, filePath?: string): Promise<UserPreferenceSettings>;

package/dist/utils/userSettings.js

@@ -0,0 +1,291 @@
+/**
+ * 用户偏好设置（三端设置页读写的子集）的读写工具。
+ *
+ * 落点唯一 = 用户级 `~/.wave/settings.json`（`getUserConfigPaths()[0]`）：
+ * 三端（VS Code 扩展 / JetBrains 插件 / 桌面端）设置页保存的 AI 回复语言、
+ * 上下文长度、自动记忆开关/轮次、服务端地址都写这个文件，由 SDK 的实时重载
+ * （LiveConfigManager）在各会话下一轮开始时生效——不经 `AgentOptions`
+ * 覆盖层下发（覆盖层优先级高于 settings.json，会永久遮蔽实时配置，
+ * 见 docs/specs/core/agent-config.md「设置实时重载」「分层职责」）。
+ *
+ * 上下文长度的键 = `env.WAVE_MAX_INPUT_TOKENS`（全局默认，K×1000 落盘、
+ * 回读按同一换算），UI 与线协议都传 K 值。
+ *
+ * 服务端地址的键 = `env.WAVE_SERVER_URL`（SDK 既有键，解析链
+ * `options.serverUrl > process.env.WAVE_SERVER_URL > DEFAULT_SERVER_URL`；
+ * settings `env` 的值经 `setEnvironmentVars` 特例镜像到 `process.env`，
+ * 见 docs/specs/core/agent-config.md 边界说明「服务端地址的落点」）。
+ *
+ * 写入是「读-改-写」：只覆盖这些键，其余顶层键与 `env` 下其它键原样保留。
+ *
+ * `readUserPreferenceView` 额外回答**当前生效值来自哪一层**：用户级文件是用户
+ * 偏好的**落点**，但企业下发的 remote-settings（或机器上的环境变量）可以盖过它，
+ * 此时只读用户文件会得到「显示值 ≠ 生效值」（spec core/agent-config.md
+ * 边界说明「用户偏好的层与来源」）。设置页据此对「由组织配置管理」的键置灰。
+ */
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname } from "path";
+import { atomicWriteFile } from "./atomicWrite.js";
+import { getUserConfigPaths } from "./configPaths.js";
+import { getRemoteSettingsSync } from "../services/remoteSettingsService.js";
+/** 上下文长度在 settings.json 中的落点（全局默认，spec 边界说明「上下文长度的落点」）。 */
+export const MAX_INPUT_TOKENS_ENV_KEY = "WAVE_MAX_INPUT_TOKENS";
+/**
+ * 自动记忆的 env 键，与 `ConfigurationService.resolveAutoMemoryEnabledFrom` /
+ * `resolveAutoMemoryFrequency` 读取的键名一致（本视图只按同一优先级归因，
+ * 不改变解析行为）。
+ */
+export const DISABLE_AUTO_MEMORY_ENV_KEY = "WAVE_DISABLE_AUTO_MEMORY";
+export const AUTO_MEMORY_FREQUENCY_ENV_KEY = "WAVE_AUTO_MEMORY_FREQUENCY";
+/**
+ * 服务端地址的 env 键（SDK 既有键，见文件头与
+ * `ConfigurationService.setEnvironmentVars` 的镜像特例）。
+ */
+export const SERVER_URL_ENV_KEY = "WAVE_SERVER_URL";
+/**
+ * 上下文长度的 env 值（token 字符串）→ UI 的 K 值；非数字/非正数视作未提供。
+ */
+function envContextLength(raw) {
+    return typeof raw === "string"
+        ? maxInputTokensToContextLength(raw)
+        : undefined;
+}
+/** `WAVE_DISABLE_AUTO_MEMORY` → 关闭(false) / 未提供(undefined)。 */
+function envDisableAutoMemory(raw) {
+    return raw === "1" || raw === "true" ? false : undefined;
+}
+/** `WAVE_AUTO_MEMORY_FREQUENCY` → 正数轮次 / 未提供。 */
+function envAutoMemoryFrequency(raw) {
+    const parsed = Number.parseInt(typeof raw === "string" ? raw : "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+/** 服务端地址：非空字符串 / 未提供（空串视作未提供，不编造默认值）。 */
+function envNonEmptyString(raw) {
+    return typeof raw === "string" && raw.trim() !== "" ? raw : undefined;
+}
+/** 按优先级取第一个提供了值的层。 */
+function selectPreference(candidates) {
+    for (const [source, value] of candidates) {
+        if (value !== undefined)
+            return { value, source };
+    }
+    return undefined;
+}
+/** UI 的 K 值 → settings.json 的 token 数（K×1000）。 */
+export function contextLengthToMaxInputTokens(contextLengthK) {
+    return Math.round(contextLengthK * 1000);
+}
+/** settings.json 的 token 数 → UI 的 K 值（回读按同一换算）。 */
+export function maxInputTokensToContextLength(maxInputTokens) {
+    if (maxInputTokens === undefined)
+        return undefined;
+    const parsed = Number.parseInt(maxInputTokens, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return undefined;
+    return Math.round(parsed / 1000);
+}
+/** 用户级 settings.json 路径（`~/.wave/settings.json`）。 */
+export function userSettingsFilePath() {
+    return getUserConfigPaths()[0];
+}
+function parseSettingsFile(filePath) {
+    if (!existsSync(filePath))
+        return {};
+    const raw = readFileSync(filePath, "utf-8");
+    if (raw.trim() === "")
+        return {};
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${filePath} 的顶层必须是 JSON 对象`);
+    }
+    return parsed;
+}
+/** settings.json 的 `env`（用户手写文件，须容忍非对象值）。 */
+function asEnvBlock(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function toSettings(data) {
+    const env = asEnvBlock(data.env);
+    const rawMax = env[MAX_INPUT_TOKENS_ENV_KEY];
+    const settings = {};
+    if (typeof data.language === "string")
+        settings.language = data.language;
+    const contextLength = maxInputTokensToContextLength(typeof rawMax === "string" ? rawMax : undefined);
+    if (contextLength !== undefined)
+        settings.contextLength = contextLength;
+    if (typeof data.autoMemoryEnabled === "boolean") {
+        settings.autoMemoryEnabled = data.autoMemoryEnabled;
+    }
+    if (typeof data.autoMemoryFrequency === "number") {
+        settings.autoMemoryFrequency = data.autoMemoryFrequency;
+    }
+    const serverUrl = envNonEmptyString(env[SERVER_URL_ENV_KEY]);
+    if (serverUrl !== undefined)
+        settings.serverUrl = serverUrl;
+    return settings;
+}
+/** 容忍损坏的读取：文件缺失或损坏时视作没有设置（只影响展示，不阻塞设置页）。 */
+function readSettingsFileTolerant(filePath) {
+    try {
+        return parseSettingsFile(filePath);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * 读取当前用户偏好。文件缺失或损坏时返回空对象（与
+ * `loadWaveConfigFromFile` 的容错一致：损坏只影响展示，不阻塞设置页渲染）；
+ * 写入路径则会明确报错而不是覆盖用户文件。
+ */
+export function readUserPreferenceSettings(filePath = userSettingsFilePath()) {
+    return toSettings(readSettingsFileTolerant(filePath));
+}
+/**
+ * 读取**生效**用户偏好及其来源层。
+ *
+ * 优先级与各 resolve 链一致（只按**进程级可达**的层归因）：Remote 组织下发
+ * （顶层键，以及其 `env` 的 `WAVE_MAX_INPUT_TOKENS` / `WAVE_DISABLE_AUTO_MEMORY` /
+ * `WAVE_AUTO_MEMORY_FREQUENCY`）> 用户级文件（同样两种落点）> 机器环境变量
+ * （`process.env`）> 默认。Remote 胜出与 `mergeRemoteSettings` 的「标量远程赢、
+ * env 逐键远程赢」一致（remoteSettingsService.ts）。
+ *
+ * `values` 的语义**与只读用户文件时完全一致**：只有真的有提供者才会出现该键，
+ * 没有任何层提供时键缺失（设置页据此显示「未设置」态、按 SDK 默认值展示）。
+ * 新增信息只在 `sources`：每个键恒有来源（缺省 `default`）。
+ *
+ * 注意归因范围：`project`（`.wave/settings.json`）/ `local`（`.wave/settings.local.json`）
+ * 需要 workdir，而本 RPC 是刻意的无会话全局请求；`override` / `options` 是会话级
+ * 语义。三者都不在本视图的归因范围内——被它们覆盖时这里仍按进程级各层给出
+ * 「本层值」，见 spec core/agent-config.md 边界说明「用户偏好的层与来源」。
+ *
+ * @param remote - Remote 组织下发配置（默认取进程内缓存）
+ * @param filePath - 用户级 settings.json 路径
+ * @param env - 机器环境变量（默认 `process.env`，便于测试注入）
+ */
+export function readUserPreferenceView(remote = getRemoteSettingsSync(), filePath = userSettingsFilePath(), env = process.env) {
+    const fileData = readSettingsFileTolerant(filePath);
+    const user = toSettings(fileData);
+    const userEnv = asEnvBlock(fileData.env);
+    const remoteEnv = asEnvBlock(remote?.env);
+    const values = {};
+    const sources = {
+        language: "default",
+        contextLength: "default",
+        autoMemoryEnabled: "default",
+        autoMemoryFrequency: "default",
+        serverUrl: "default",
+    };
+    // language 没有 env 落点（`resolveLanguage` 只读合并后的顶层键）。
+    const language = selectPreference([
+        ["remote", remote?.language],
+        ["user", user.language],
+    ]);
+    if (language) {
+        values.language = language.value;
+        sources.language = language.source;
+    }
+    // 上下文长度的归因层 = `env.WAVE_MAX_INPUT_TOKENS` 这个 env key 所在的层
+    // （不是「模型配置」那层：模型自带上限时以模型配置为准是 SDK 既有行为，
+    // 设置页那一行可见说明已交代）。
+    const contextLength = selectPreference([
+        ["remote", envContextLength(remoteEnv[MAX_INPUT_TOKENS_ENV_KEY])],
+        ["user", user.contextLength],
+        ["env", envContextLength(env[MAX_INPUT_TOKENS_ENV_KEY])],
+    ]);
+    if (contextLength) {
+        values.contextLength = contextLength.value;
+        sources.contextLength = contextLength.source;
+    }
+    // 自动记忆开关每层有两条路径：顶层标量，以及 `env.WAVE_DISABLE_AUTO_MEMORY`。
+    // 顶层标量整层优先于 env（`resolveAutoMemoryEnabledFrom` 先看 config 再看 env）。
+    // 没有任何层提供时**不编造**值（与其余三个键一致：键缺失 = 无提供者），
+    // 设置页按 SDK 默认显示为「开」，与生效值一致。
+    const autoMemoryEnabled = selectPreference([
+        ["remote", remote?.autoMemoryEnabled],
+        ["user", user.autoMemoryEnabled],
+        ["remote", envDisableAutoMemory(remoteEnv[DISABLE_AUTO_MEMORY_ENV_KEY])],
+        ["user", envDisableAutoMemory(userEnv[DISABLE_AUTO_MEMORY_ENV_KEY])],
+        ["env", envDisableAutoMemory(env[DISABLE_AUTO_MEMORY_ENV_KEY])],
+    ]);
+    if (autoMemoryEnabled) {
+        values.autoMemoryEnabled = autoMemoryEnabled.value;
+        sources.autoMemoryEnabled = autoMemoryEnabled.source;
+    }
+    const autoMemoryFrequency = selectPreference([
+        ["remote", remote?.autoMemoryFrequency],
+        ["user", user.autoMemoryFrequency],
+        [
+            "remote",
+            envAutoMemoryFrequency(remoteEnv[AUTO_MEMORY_FREQUENCY_ENV_KEY]),
+        ],
+        ["user", envAutoMemoryFrequency(userEnv[AUTO_MEMORY_FREQUENCY_ENV_KEY])],
+        ["env", envAutoMemoryFrequency(env[AUTO_MEMORY_FREQUENCY_ENV_KEY])],
+    ]);
+    if (autoMemoryFrequency) {
+        values.autoMemoryFrequency = autoMemoryFrequency.value;
+        sources.autoMemoryFrequency = autoMemoryFrequency.source;
+    }
+    // 服务端地址的落点 = `env.WAVE_SERVER_URL`，来源只可能是 user / env / default——
+    // 不归因 remote（远端托管配置本身取自该地址，不存在「组织下发服务端地址」的闭环，
+    // 见 spec core/agent-config.md 边界说明「服务端地址的落点」）。
+    const serverUrl = selectPreference([
+        ["user", user.serverUrl],
+        ["env", envNonEmptyString(env[SERVER_URL_ENV_KEY])],
+    ]);
+    if (serverUrl) {
+        values.serverUrl = serverUrl.value;
+        sources.serverUrl = serverUrl.source;
+    }
+    return { values, sources };
+}
+/**
+ * 把 `patch` 里的键合并进用户级 settings.json，返回写入后的完整用户偏好。
+ * 未提供的键保持文件中现值；`patch` 为空时只回读、不落盘（无差异保存）。
+ */
+export async function updateUserPreferenceSettings(patch, filePath = userSettingsFilePath()) {
+    const data = parseSettingsFile(filePath);
+    const hasLanguage = patch.language !== undefined;
+    const hasContextLength = patch.contextLength !== undefined;
+    const hasEnabled = patch.autoMemoryEnabled !== undefined;
+    const hasFrequency = patch.autoMemoryFrequency !== undefined;
+    // 空串视作未提供（与回读侧 `envNonEmptyString` 同一判据）：写进去会在
+    // `process.env` 镜像里遮蔽 OS 环境变量（解析链用 `||` 回落到默认值），而回读侧
+    // 又按「未设置」展示 ⇒ 显示值与生效值分叉。省略键 = 不改该键。
+    const serverUrl = envNonEmptyString(patch.serverUrl);
+    if (!hasLanguage &&
+        !hasContextLength &&
+        !hasEnabled &&
+        !hasFrequency &&
+        serverUrl === undefined) {
+        return toSettings(data);
+    }
+    if (hasLanguage)
+        data.language = patch.language;
+    if (typeof patch.contextLength === "number" &&
+        Number.isFinite(patch.contextLength)) {
+        const env = asEnvBlock(data.env);
+        env[MAX_INPUT_TOKENS_ENV_KEY] = String(contextLengthToMaxInputTokens(patch.contextLength));
+        data.env = env;
+    }
+    if (hasEnabled)
+        data.autoMemoryEnabled = patch.autoMemoryEnabled;
+    if (typeof patch.autoMemoryFrequency === "number" &&
+        Number.isFinite(patch.autoMemoryFrequency)) {
+        data.autoMemoryFrequency = patch.autoMemoryFrequency;
+    }
+    // 服务端地址落 `env.WAVE_SERVER_URL`（既有键）：原样写入，不做归一/清理
+    // （格式校验在设置页，见 spec 边界说明「服务端地址的落点」）。
+    if (serverUrl !== undefined) {
+        const env = asEnvBlock(data.env);
+        env[SERVER_URL_ENV_KEY] = serverUrl;
+        data.env = env;
+    }
+    // 首次保存时 `~/.wave` 可能尚不存在（会话启动时文件不存在，场景 7），
+    // 原子写需要同目录可写，先确保目录存在。
+    mkdirSync(dirname(filePath), { recursive: true });
+    await atomicWriteFile(filePath, `${JSON.stringify(data, null, 2)}\n`);
+    return toSettings(data);
+}

package/dist/utils/worktreeUtils.d.ts

@@ -47,7 +47,8 @@ export declare function performPostCreationSetup(worktreePath: string, repoRoot:
  * is MAX_PATH-limited — deep paths (e.g. node_modules) can fail with "Filename
  * too long", leaving an orphan directory. When git fails we fall back to
  * fs.rmSync with an extended-length path (bypasses MAX_PATH) and prune stale
- * metadata. Failures are logged but never block branch deletion.
+ * metadata. Failures are logged; when the directory survives, its branch is
+ * deliberately kept so the leftover checkout stays reachable through git.
  */
 export declare function removeWorktree(info: WorktreeInfo): void;
 /**

package/dist/utils/worktreeUtils.js

@@ -517,6 +517,36 @@ function toExtendedLengthPath(worktreePath) {
     }
     return `\\\\?\\${absolute}`;
 }
+/**
+ * Describe what is still on disk after a failed removal. Without this a log
+ * line cannot distinguish "directory already gone" from "the whole checkout is
+ * still sitting there".
+ */
+function probeResidue(worktreePath) {
+    try {
+        if (!fs.existsSync(worktreePath))
+            return "none";
+        const entries = fs.readdirSync(worktreePath);
+        const head = entries.slice(0, 5).join(",");
+        return `${entries.length}[${head}${entries.length > 5 ? ",…" : ""}]`;
+    }
+    catch (error) {
+        return `unknown(${error.code ?? "error"})`;
+    }
+}
+/** Delete the worktree directory with fs.rmSync; returns the error, if any. */
+function rmWorktreeDirWithFs(worktreePath) {
+    try {
+        fs.rmSync(toExtendedLengthPath(worktreePath), {
+            recursive: true,
+            force: true,
+        });
+        return null;
+    }
+    catch (error) {
+        return error;
+    }
+}
 /**
  * Remove a git worktree and its branch.
  *
@@ -525,28 +555,36 @@ function toExtendedLengthPath(worktreePath) {
  * is MAX_PATH-limited — deep paths (e.g. node_modules) can fail with "Filename
  * too long", leaving an orphan directory. When git fails we fall back to
  * fs.rmSync with an extended-length path (bypasses MAX_PATH) and prune stale
- * metadata. Failures are logged but never block branch deletion.
+ * metadata. Failures are logged; when the directory survives, its branch is
+ * deliberately kept so the leftover checkout stays reachable through git.
  */
 export function removeWorktree(info) {
     const repoRoot = info.repoRoot;
-    // Get current branch in worktree before removing
-    let currentBranch;
-    try {
-        currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-            cwd: info.path,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-    }
-    catch {
-        // Ignore errors
-    }
     // Remove worktree
     try {
         execFileSync("git", ["worktree", "remove", "--force", info.path], {
             cwd: repoRoot,
             stdio: ["ignore", "pipe", "pipe"],
         });
+        // git exits 0 even when it did not delete the directory: on Windows it
+        // cannot remove the directory symlinks/junctions that pnpm's node_modules
+        // is made of, so it deletes the files, leaves the skeleton behind and still
+        // reports success. Verify on disk instead of trusting the exit status.
+        if (fs.existsSync(info.path)) {
+            logger.warn("git worktree remove reported success but the directory survived, falling back to fs.rmSync:", {
+                worktreePath: info.path,
+                residue: probeResidue(info.path),
+            });
+            const rmError = rmWorktreeDirWithFs(info.path);
+            if (rmError !== null) {
+                logger.error("Failed to remove worktree or branch:", {
+                    worktreePath: info.path,
+                    stage: "fs(after git success)",
+                    error: rmError instanceof Error ? rmError.message : String(rmError),
+                    residue: probeResidue(info.path),
+                });
+            }
+        }
     }
     catch (error) {
         logger.warn("git worktree remove failed, falling back to fs.rmSync:", {
@@ -577,7 +615,19 @@ export function removeWorktree(info) {
             // Ignore errors
         }
     }
-    // Delete worktree branch
+    // The directory, not any exit code, decides whether the removal happened. A
+    // surviving directory means its checkout (and any uncommitted work in it) is
+    // still on disk, and the branch is the only ref still leading back to it.
+    if (fs.existsSync(info.path)) {
+        logger.warn(`Worktree directory survived removal — keeping ${info.branch} so the leftover checkout stays reachable:`, {
+            worktreePath: info.path,
+            residue: probeResidue(info.path),
+        });
+        return;
+    }
+    // Delete the worktree's own branch. Branches the user checked out inside the
+    // worktree are never touched — they may hold commits that are not reachable
+    // from anywhere else (aligned with Claude Code).
     try {
         execFileSync("git", ["branch", "-D", info.branch], {
             cwd: repoRoot,
@@ -587,26 +637,6 @@ export function removeWorktree(info) {
     catch {
         // Ignore errors
     }
-    // Delete current branch if different and not protected
-    if (currentBranch &&
-        currentBranch !== info.branch &&
-        currentBranch !== "HEAD") {
-        const defaultRemoteBranch = getDefaultRemoteBranch(repoRoot);
-        const defaultBranchName = defaultRemoteBranch.split("/").pop();
-        if (currentBranch !== defaultBranchName &&
-            currentBranch !== "main" &&
-            currentBranch !== "master") {
-            try {
-                execFileSync("git", ["branch", "-D", currentBranch], {
-                    cwd: repoRoot,
-                    stdio: ["ignore", "pipe", "pipe"],
-                });
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-    }
 }
 /**
  * Validate that a worktree path is safe to remove before running git removal.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "1.1.5",
+  "version": "1.3.0",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -13,6 +13,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -23,8 +24,12 @@
       "default": "./dist/types/index.js"
     },
     "./constants": {
-      "types": "./dist/constants/tools.d.ts",
-      "default": "./dist/constants/tools.js"
+      "types": "./dist/constants/index.d.ts",
+      "default": "./dist/constants/index.js"
+    },
+    "./host": {
+      "types": "./dist/host/index.d.ts",
+      "default": "./dist/host/index.js"
     },
     "./package.json": "./package.json",
     "./*": "./*"
@@ -50,15 +55,19 @@
     "@vscode/ripgrep": "^1.18.0",
     "chokidar": "^4.0.3",
     "cron-parser": "^5.5.0",
+    "fflate": "^0.8.3",
     "fuzzysort": "^3.1.0",
     "glob": "^13.0.0",
     "lru-cache": "^11.3.5",
     "marked": "^17.0.2",
     "minimatch": "^10.0.3",
     "openai": "^5.12.2",
+    "semver": "^7.7.4",
+    "sharp": "^0.35.4",
     "turndown": "^7.2.2"
   },
   "devDependencies": {
+    "@types/semver": "^7.7.1",
     "@types/turndown": "^5.0.6",
     "@vitest/coverage-v8": "^4.1.7",
     "rimraf": "^6.1.2",
@@ -71,7 +80,6 @@
   "scripts": {
     "build": "rimraf dist && tsc -p tsconfig.build.json",
     "type-check": "tsc --noEmit --incremental",
-    "watch": "tsc -p tsconfig.build.json --watch",
     "test": "vitest run --reporter=dot",
     "test:coverage": "vitest run --coverage --reporter=dot",
     "test:unit": "vitest run --reporter=dot --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",

package/dist/managers/bangManager.d.ts

@@ -1,26 +0,0 @@
-import { Container } from "../utils/container.js";
-export interface BangManagerOptions {
-    workdir: string;
-}
-export interface CommandExecutionResult {
-    exitCode: number;
-    output: string;
-}
-export declare class BangManager {
-    private container;
-    private workdir;
-    isCommandRunning: boolean;
-    private currentProcess;
-    onCommandRunningChange?: (running: boolean) => void;
-    constructor(container: Container, options: BangManagerOptions);
-    private get messageManager();
-    /**
-     * Merged env (OS env overlaid with this session's settings snapshot) for
-     * bang-command subprocesses, so settings `env` vars reach them without
-     * polluting other sessions in one `wave --stdio` process.
-     */
-    private get sessionEnv();
-    private setCommandRunning;
-    executeCommand(command: string): Promise<number>;
-    abortCommand(): void;
-}