wave-agent-sdk 1.0.8 → 1.0.10

package/dist/services/artifactAvailability.js

@@ -9,13 +9,21 @@
  * "unset follows feature availability" semantics).
  */
 import { loadMergedWaveConfig } from "./configurationService.js";
+import { getRemoteSettingsSync } from "./remoteSettingsService.js";
 /** Code default for Artifact availability. Flip to true after the frame backend goes live. */
 export const ARTIFACT_DEFAULT_ENABLED = false;
 /**
  * Whether the Artifact tool should be registered / usable for the given workdir.
- * Explicit `enableArtifact` in merged settings wins over the code default.
+ * Resolution order: remote managed settings (`enableArtifact` from
+ * `GET /api/wave/settings`, admin override) → explicit `enableArtifact` in local
+ * merged settings → code default.
  */
 export function isArtifactEnabled(workdir) {
+    // Remote managed settings win (same last-write-wins semantics as `model`).
+    const remote = getRemoteSettingsSync();
+    if (remote?.enableArtifact !== undefined) {
+        return remote.enableArtifact;
+    }
     if (workdir) {
         const config = loadMergedWaveConfig(workdir);
         if (config?.enableArtifact !== undefined) {

package/dist/services/remoteSettingsService.js

@@ -307,6 +307,8 @@ export function mergeRemoteSettings(localMerged, remote) {
         result.marketplaces = remote.marketplaces;
     if (remote.enabledPlugins !== undefined)
         result.enabledPlugins = remote.enabledPlugins;
+    if (remote.enableArtifact !== undefined)
+        result.enableArtifact = remote.enableArtifact;
     return result;
 }
 /**

package/dist/tools/bashTool.js

@@ -6,6 +6,7 @@ import { logger } from "../utils/globalLogger.js";
 import { resolveShellPath } from "../utils/shellResolver.js";
 import { toPosixPath } from "../utils/path.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
+import { WindowsStreamDecoder } from "../utils/encoding.js";
 import { processToolResult } from "../utils/toolResultStorage.js";
 import { BASH_MAX_OUTPUT_CHARS } from "../constants/toolLimits.js";
 import { BASH_TOOL_NAME, GLOB_TOOL_NAME, GREP_TOOL_NAME, READ_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, } from "../constants/tools.js";
@@ -250,6 +251,10 @@ The working directory persists between commands. Try to maintain your current wo
             let isAborted = false;
             let isBackgrounded = false;
             let isFinished = false;
+            // On Windows, native tools (taskkill, powershell, ...) write GBK (cp936)
+            // instead of UTF-8; decode their byte streams accordingly (issue #1753).
+            const stdoutDecoder = process.platform === "win32" ? new WindowsStreamDecoder() : null;
+            const stderrDecoder = process.platform === "win32" ? new WindowsStreamDecoder() : null;
             // Best-effort cleanup of the temp CWD file — used by abort/error/exit paths
             const cleanupTempFile = () => {
                 try {
@@ -416,14 +421,14 @@ The working directory persists between commands. Try to maintain your current wo
             }
             child.stdout?.on("data", (data) => {
                 if (!isAborted && !isBackgrounded && !runInBackground) {
-                    const chunk = stripAnsiColors(data.toString());
+                    const chunk = stripAnsiColors(stdoutDecoder ? stdoutDecoder.push(data) : data.toString());
                     outputBuffer += chunk;
                     updateRealtimeResults();
                 }
             });
             child.stderr?.on("data", (data) => {
                 if (!isAborted && !isBackgrounded && !runInBackground) {
-                    const chunk = stripAnsiColors(data.toString());
+                    const chunk = stripAnsiColors(stderrDecoder ? stderrDecoder.push(data) : data.toString());
                     errorBuffer += chunk;
                     updateRealtimeResults();
                 }
@@ -467,6 +472,12 @@ The working directory persists between commands. Try to maintain your current wo
                         }
                     }
                     const exitCode = code ?? 0;
+                    // Decode any bytes still held at stream end (e.g. a trailing UTF-8
+                    // character split across the last chunk).
+                    if (stdoutDecoder)
+                        outputBuffer += stdoutDecoder.flush();
+                    if (stderrDecoder)
+                        errorBuffer += stderrDecoder.flush();
                     const combinedOutput = outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
                     // Prepend CWD change message to output if present
                     const finalOutput = recoveryNotice +

package/dist/tools/editTool.js

@@ -168,7 +168,11 @@ Usage:
             if (replaceAll) {
                 // Replace all matches
                 const regex = new RegExp(escapeRegExp(matchedOldString), "g");
-                newContent = normalizedContent.replace(regex, newString);
+                // Function replacer (claude-code's applyEditToFile approach): newString
+                // is inserted literally, never parsed as a $ replacement template. A
+                // string replacer would expand $& to the matched text, $$ to a single
+                // $, and `$` could even truncate and duplicate the file (issue #1752).
+                newContent = normalizedContent.replace(regex, () => newString);
                 replacementCount = (normalizedContent.match(regex) || []).length;
             }
             else {
@@ -181,7 +185,8 @@ Usage:
                         error: `old_string appears ${matches} times in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all=true to change every instance.`,
                     };
                 }
-                newContent = normalizedContent.replace(matchedOldString, newString);
+                // Function replacer: see note above — $ in newString stays literal
+                newContent = normalizedContent.replace(matchedOldString, () => newString);
                 replacementCount = 1;
             }
             // Permission check after validation but before real operation
@@ -238,6 +243,7 @@ Usage:
                 context.readFileState.set(resolvedPath, {
                     mtime: newStats.mtime.getTime(),
                     hash,
+                    source: "edit",
                     offset: undefined,
                     limit: undefined,
                 });

package/dist/tools/readTool.js

@@ -208,12 +208,14 @@ Usage:
                 : resolvePath(filePath, context.workdir);
             const stats = await stat(actualFilePath);
             // Deduplication: only dedup if the exact same range was read before
+            // (aligned with Claude Code — full reads dedup too). Entries written by
+            // Edit/Write have source "edit"/"write" and never dedup, so a file that
+            // was written before its first Read is still returned in full.
             if (context.readFileState) {
                 const state = context.readFileState.get(actualFilePath);
-                // Only dedup entries from a prior Read with explicit offset (not Edit/Write entries)
                 if (state &&
-                    state.mtime === stats.mtime.getTime() &&
-                    state.offset !== undefined) {
+                    state.source === "read" &&
+                    state.mtime === stats.mtime.getTime()) {
                     const rangeMatch = state.offset === offset && state.limit === limit;
                     if (rangeMatch) {
                         return {
@@ -249,6 +251,7 @@ Usage:
                 context.readFileState.set(actualFilePath, {
                     mtime: stats.mtime.getTime(),
                     hash,
+                    source: "read",
                     offset, // undefined for full reads
                     limit, // undefined for full reads
                 });

package/dist/tools/types.d.ts

@@ -95,6 +95,7 @@ export interface ToolContext {
     readFileState?: Map<string, {
         mtime: number;
         hash: string;
+        source: "read" | "edit" | "write";
         offset?: number;
         limit?: number;
     }>;

package/dist/tools/writeTool.js

@@ -179,6 +179,7 @@ Usage:
                 context.readFileState.set(resolvedPath, {
                     mtime: newStats.mtime.getTime(),
                     hash,
+                    source: "write",
                     offset: undefined,
                     limit: undefined,
                 });

package/dist/types/messaging.d.ts

@@ -37,6 +37,7 @@ export interface ToolBlock {
     images?: Array<{
         data: string;
         mediaType?: string;
+        path?: string;
     }>;
     id?: string;
     name?: string;

package/dist/utils/builtinEmbed.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Builtin content embedding.
+ *
+ * Builtin skills/subagents/plugins ship as TS source (src/builtin/*.ts) and are
+ * compiled into the bundle. At runtime they are lazily materialized to a
+ * content-hashed cache directory under the OS temp dir, so consumers that
+ * readdirSync real directories keep working unchanged — including inside
+ * esbuild bundles that never ship a `builtin/` dir on disk.
+ */
+/**
+ * Content-hash key: sha256 of the sorted `rel\0content` entries, truncated.
+ * Any change to builtin content yields a new key, auto-invalidating stale caches.
+ */
+export declare function getBuiltinCacheKey(): string;
+/**
+ * Materialize builtin content to `{tmpdir}/wave-builtin/{contentHash}/` and
+ * return the directory. Memoized per process; idempotent across processes via
+ * the `.wave-builtin-complete` marker written last (a torn write leaves no
+ * marker, so the next run rewrites).
+ */
+export declare function ensureBuiltinMaterialized(): string;

package/dist/utils/builtinEmbed.js

@@ -0,0 +1,53 @@
+/**
+ * Builtin content embedding.
+ *
+ * Builtin skills/subagents/plugins ship as TS source (src/builtin/*.ts) and are
+ * compiled into the bundle. At runtime they are lazily materialized to a
+ * content-hashed cache directory under the OS temp dir, so consumers that
+ * readdirSync real directories keep working unchanged — including inside
+ * esbuild bundles that never ship a `builtin/` dir on disk.
+ */
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+import { BUILTIN_CONTENT } from "../builtin/index.js";
+const BUILTIN_CACHE_ROOT = "wave-builtin";
+const BUILTIN_CACHE_COMPLETE = ".wave-builtin-complete";
+/**
+ * Content-hash key: sha256 of the sorted `rel\0content` entries, truncated.
+ * Any change to builtin content yields a new key, auto-invalidating stale caches.
+ */
+export function getBuiltinCacheKey() {
+    const entries = Object.keys(BUILTIN_CONTENT)
+        .sort()
+        .map((rel) => `${rel}\0${BUILTIN_CONTENT[rel]}`);
+    return createHash("sha256")
+        .update(entries.join("\0"))
+        .digest("hex")
+        .slice(0, 16);
+}
+let _builtinDir;
+/**
+ * Materialize builtin content to `{tmpdir}/wave-builtin/{contentHash}/` and
+ * return the directory. Memoized per process; idempotent across processes via
+ * the `.wave-builtin-complete` marker written last (a torn write leaves no
+ * marker, so the next run rewrites).
+ */
+export function ensureBuiltinMaterialized() {
+    if (_builtinDir)
+        return _builtinDir;
+    const dir = join(tmpdir(), BUILTIN_CACHE_ROOT, getBuiltinCacheKey());
+    const marker = join(dir, BUILTIN_CACHE_COMPLETE);
+    if (!existsSync(marker)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        for (const [rel, content] of Object.entries(BUILTIN_CONTENT)) {
+            const filePath = join(dir, rel);
+            mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
+            writeFileSync(filePath, content);
+        }
+        writeFileSync(marker, "");
+    }
+    _builtinDir = dir;
+    return dir;
+}

package/dist/utils/configPaths.d.ts

@@ -9,7 +9,6 @@
  * - Local configs: {workdir}/.wave/settings.local.json > {workdir}/.wave/settings.json
  * - Project configs override user configs (existing behavior)
  */
-export declare function getPackageRoot(): string;
 /**
  * Get the builtin skills directory path
  */

package/dist/utils/configPaths.js

@@ -9,48 +9,27 @@
  * - Local configs: {workdir}/.wave/settings.local.json > {workdir}/.wave/settings.json
  * - Project configs override user configs (existing behavior)
  */
-import { join, dirname } from "path";
+import { join } from "path";
 import { homedir } from "os";
 import { existsSync } from "fs";
-import { fileURLToPath } from "url";
-import { findUpSync } from "find-up";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-/**
- * Resolve the package root directory by finding the nearest package.json.
- * Works correctly even when bundled (e.g. esbuild into a VS Code extension),
- * as long as vendor/ and builtin/ remain alongside package.json on disk.
- */
-let _packageRoot;
-export function getPackageRoot() {
-    if (_packageRoot)
-        return _packageRoot;
-    const pkgPath = findUpSync("package.json", { cwd: __dirname });
-    if (pkgPath) {
-        _packageRoot = dirname(pkgPath);
-        return _packageRoot;
-    }
-    // Fallback: relative to this file (works during development)
-    _packageRoot = join(__dirname, "..", "..");
-    return _packageRoot;
-}
+import { ensureBuiltinMaterialized } from "./builtinEmbed.js";
 /**
  * Get the builtin skills directory path
  */
 export function getBuiltinSkillsDir() {
-    return join(getPackageRoot(), "builtin", "skills");
+    return join(ensureBuiltinMaterialized(), "skills");
 }
 /**
  * Get the builtin subagents directory path
  */
 export function getBuiltinSubagentsDir() {
-    return join(getPackageRoot(), "builtin", "subagents");
+    return join(ensureBuiltinMaterialized(), "subagents");
 }
 /**
  * Get the builtin plugins directory path
  */
 export function getBuiltinPluginsDir() {
-    return join(getPackageRoot(), "builtin", "plugins");
+    return join(ensureBuiltinMaterialized(), "plugins");
 }
 /**
  * Get the user-specific configuration file path (legacy function)

package/dist/utils/containerSetup.js

@@ -219,6 +219,14 @@ export function setupAgentContainer(setupOptions) {
         onReload: () => {
             const models = configurationService.getConfiguredModels();
             callbacks.onConfiguredModelsChange?.(models);
+            // Re-evaluate feature-gated tools (e.g. Artifact behind
+            // enableArtifact) so toggling the flag applies without a restart.
+            toolManager.reloadFeatureGatedTools();
+            // Same gate for the builtin /artifact skill: refresh emits "refreshed"
+            // so slash-command registration follows enableArtifact.
+            void skillManager.reloadFeatureGatedSkills().catch((error) => {
+                logger.error("Failed to reload feature-gated skills:", error);
+            });
         },
     });
     container.register("LiveConfigManager", liveConfigManager);

package/dist/utils/convertMessagesForAPI.js

@@ -102,10 +102,29 @@ export function convertMessagesForAPI(messages, options) {
                                 });
                             }
                             else {
-                                // Non-vision model: replace images with a text placeholder
+                                // Non-vision model: replace images with a text placeholder and
+                                // append [Image source: <path>] metadata for MCP images that
+                                // were persisted to temp files, so the main model can delegate
+                                // recognition to a vision subagent (which reads the path with
+                                // the Read tool). Images without a persisted path (e.g. legacy
+                                // history) fall back to the placeholder only.
+                                const contentParts = [
+                                    {
+                                        type: "text",
+                                        text: "[Tool returned an image, but the current model does not support image recognition]",
+                                    },
+                                ];
+                                toolBlock.images.forEach((image) => {
+                                    if (image.path) {
+                                        contentParts.push({
+                                            type: "text",
+                                            text: `[Image source: ${image.path}]`,
+                                        });
+                                    }
+                                });
                                 imageUserMessages.push({
                                     role: "user",
-                                    content: "[Tool returned an image, but the current model does not support image recognition]",
+                                    content: contentParts,
                                 });
                             }
                         }

package/dist/utils/encoding.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Streaming byte-to-text decoder for bash tool output on Windows.
+ *
+ * Git Bash (MSYS) tools emit UTF-8, but native Windows programs (taskkill,
+ * powershell, ping, ...) write the system OEM code page — GBK (cp936) on
+ * zh-CN systems. Node's default `data.toString()` decodes every stream as
+ * UTF-8, so GBK bytes turn into U+FFFD mojibake (issue #1753).
+ *
+ * Strategy (per-chunk buffering, decide-once):
+ * - Accumulate raw bytes; try strict UTF-8 (`fatal: true`) over everything
+ *   buffered so far. If it decodes cleanly, emit the text.
+ * - If strict UTF-8 fails, hold back up to 3 trailing bytes (a UTF-8
+ *   character split across chunk boundaries) and retry on the next chunk.
+ * - Once even the head is not valid UTF-8, the stream is GBK: re-decode all
+ *   buffered bytes with GBK and switch to GBK for every subsequent chunk.
+ * - `flush()` decodes any leftover buffered bytes (leniently) at stream end.
+ */
+export declare class WindowsStreamDecoder {
+    private pending;
+    private gbkDecoder;
+    /** Longest possible incomplete UTF-8 tail at a chunk boundary is 3 bytes. */
+    private static readonly MAX_UTF8_TRAIL_BYTES;
+    push(data: Buffer): string;
+    /** Decode any bytes still held at stream end (lenient UTF-8, else GBK). */
+    flush(): string;
+}
+/** Decode a single complete byte sequence (used for non-streaming reads). */
+export declare function decodeBytes(buf: Buffer): string;

package/dist/utils/encoding.js

@@ -0,0 +1,99 @@
+/**
+ * Streaming byte-to-text decoder for bash tool output on Windows.
+ *
+ * Git Bash (MSYS) tools emit UTF-8, but native Windows programs (taskkill,
+ * powershell, ping, ...) write the system OEM code page — GBK (cp936) on
+ * zh-CN systems. Node's default `data.toString()` decodes every stream as
+ * UTF-8, so GBK bytes turn into U+FFFD mojibake (issue #1753).
+ *
+ * Strategy (per-chunk buffering, decide-once):
+ * - Accumulate raw bytes; try strict UTF-8 (`fatal: true`) over everything
+ *   buffered so far. If it decodes cleanly, emit the text.
+ * - If strict UTF-8 fails, hold back up to 3 trailing bytes (a UTF-8
+ *   character split across chunk boundaries) and retry on the next chunk.
+ * - Once even the head is not valid UTF-8, the stream is GBK: re-decode all
+ *   buffered bytes with GBK and switch to GBK for every subsequent chunk.
+ * - `flush()` decodes any leftover buffered bytes (leniently) at stream end.
+ */
+export class WindowsStreamDecoder {
+    constructor() {
+        this.pending = Buffer.alloc(0);
+        this.gbkDecoder = null;
+    }
+    push(data) {
+        // Already determined GBK: decode each chunk as it arrives.
+        if (this.gbkDecoder) {
+            return this.gbkDecoder.decode(data);
+        }
+        this.pending = Buffer.concat([this.pending, data]);
+        try {
+            const text = new TextDecoder("utf-8", { fatal: true }).decode(this.pending);
+            this.pending = Buffer.alloc(0);
+            return text;
+        }
+        catch {
+            // Strict UTF-8 failed. The trailing bytes may be a UTF-8 sequence split
+            // across chunks: hold only the trailing run of non-ASCII bytes (max 3,
+            // the longest incomplete UTF-8 tail). Everything before it is already
+            // decodable and is emitted immediately.
+            const n = this.pending.length;
+            let keep = 0;
+            while (keep < WindowsStreamDecoder.MAX_UTF8_TRAIL_BYTES &&
+                keep < n &&
+                this.pending[n - 1 - keep] >= 0x80) {
+                keep++;
+            }
+            const head = this.pending.subarray(0, n - keep);
+            if (head.length > 0) {
+                try {
+                    const text = new TextDecoder("utf-8", { fatal: true }).decode(head);
+                    this.pending = Buffer.from(this.pending.subarray(n - keep));
+                    return text;
+                }
+                catch {
+                    // Head is not valid UTF-8 → the whole stream is GBK. Re-decode
+                    // everything accumulated so far and commit to GBK.
+                    this.gbkDecoder = new TextDecoder("gbk");
+                    const text = this.gbkDecoder.decode(this.pending);
+                    this.pending = Buffer.alloc(0);
+                    return text;
+                }
+            }
+            // Only the trailing bytes are suspect: hold them for the next chunk.
+            return "";
+        }
+    }
+    /** Decode any bytes still held at stream end (lenient UTF-8, else GBK). */
+    flush() {
+        if (this.pending.length === 0)
+            return "";
+        const rest = this.pending;
+        this.pending = Buffer.alloc(0);
+        if (this.gbkDecoder) {
+            return this.gbkDecoder.decode(rest);
+        }
+        const utf8 = rest.toString("utf-8");
+        if (!utf8.includes("\uFFFD"))
+            return utf8;
+        try {
+            return new TextDecoder("gbk").decode(rest);
+        }
+        catch {
+            return utf8;
+        }
+    }
+}
+/** Longest possible incomplete UTF-8 tail at a chunk boundary is 3 bytes. */
+WindowsStreamDecoder.MAX_UTF8_TRAIL_BYTES = 3;
+/** Decode a single complete byte sequence (used for non-streaming reads). */
+export function decodeBytes(buf) {
+    const utf8 = buf.toString("utf-8");
+    if (!utf8.includes("\uFFFD"))
+        return utf8;
+    try {
+        return new TextDecoder("gbk").decode(buf);
+    }
+    catch {
+        return utf8;
+    }
+}

package/dist/utils/messageOperations.d.ts

@@ -37,6 +37,7 @@ export interface UpdateToolBlockParams {
     images?: Array<{
         data: string;
         mediaType?: string;
+        path?: string;
     }>;
     compactParams?: string;
     parametersChunk?: string;

package/dist/utils/toolImagePersistence.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Persistence for MCP tool-returned images.
+ *
+ * MCP tools can return image content blocks as in-memory base64. When the
+ * agent's model does not support vision, the image is written to a temp file
+ * so convertMessagesForAPI can attach `[Image source: <path>]` metadata and
+ * the main model can delegate recognition to the vision subagent (which reads
+ * the path with the Read tool). Vision-capable models keep the inline base64
+ * and never write to disk.
+ */
+export interface PersistedToolImage {
+    data: string;
+    mediaType?: string;
+    path?: string;
+}
+/**
+ * Persist base64 images to temp files under /tmp/wave-mcp-images/.
+ * Uses the OS tmpdir for simplicity and automatic OS cleanup (same convention
+ * as /tmp/wave-tool-results/). Returns each image unchanged (no path) when the
+ * write fails, so the caller degrades to the placeholder-only behavior.
+ */
+export declare function persistToolImages(images: Array<{
+    data: string;
+    mediaType?: string;
+}>): PersistedToolImage[];

package/dist/utils/toolImagePersistence.js

@@ -0,0 +1,56 @@
+/**
+ * Persistence for MCP tool-returned images.
+ *
+ * MCP tools can return image content blocks as in-memory base64. When the
+ * agent's model does not support vision, the image is written to a temp file
+ * so convertMessagesForAPI can attach `[Image source: <path>]` metadata and
+ * the main model can delegate recognition to the vision subagent (which reads
+ * the path with the Read tool). Vision-capable models keep the inline base64
+ * and never write to disk.
+ */
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { logger } from "./globalLogger.js";
+const MCP_IMAGES_DIR = path.join(os.tmpdir(), "wave-mcp-images");
+/** Map MCP mimeType to a file extension. Unknown types fall back to .png. */
+const MIME_TO_EXT = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "image/bmp": ".bmp",
+    "image/svg+xml": ".svg",
+    "image/avif": ".avif",
+    "image/x-icon": ".ico",
+    "image/tiff": ".tiff",
+};
+/**
+ * Persist base64 images to temp files under /tmp/wave-mcp-images/.
+ * Uses the OS tmpdir for simplicity and automatic OS cleanup (same convention
+ * as /tmp/wave-tool-results/). Returns each image unchanged (no path) when the
+ * write fails, so the caller degrades to the placeholder-only behavior.
+ */
+export function persistToolImages(images) {
+    return images.map((image) => {
+        try {
+            fs.mkdirSync(MCP_IMAGES_DIR, { recursive: true });
+            // Strip a data: URL prefix if present (MCP spec carries raw base64, but
+            // be defensive about dataURL-formatted data).
+            let data = image.data;
+            if (data.startsWith("data:")) {
+                const commaIndex = data.indexOf(",");
+                data = commaIndex >= 0 ? data.slice(commaIndex + 1) : data;
+            }
+            const ext = MIME_TO_EXT[image.mediaType || ""] || ".png";
+            const id = `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+            const filePath = path.join(MCP_IMAGES_DIR, `mcp-image_${id}${ext}`);
+            fs.writeFileSync(filePath, Buffer.from(data, "base64"));
+            return { ...image, path: filePath };
+        }
+        catch (error) {
+            logger?.error("Failed to persist MCP tool image:", error);
+            return image;
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -36,7 +36,6 @@
   },
   "files": [
     "dist",
-    "builtin",
     "README.md"
   ],
   "dependencies": {
@@ -51,7 +50,6 @@
     "@vscode/ripgrep": "^1.18.0",
     "chokidar": "^4.0.3",
     "cron-parser": "^5.5.0",
-    "find-up": "^8.0.0",
     "fuzzysort": "^3.1.0",
     "glob": "^13.0.0",
     "lru-cache": "^11.3.5",

package/builtin/plugins/sdd/.wave-plugin/plugin.json

@@ -1,8 +0,0 @@
-{
-  "name": "sdd",
-  "description": "Spec-first workflow: specify skill, SessionStart guidance, and spec-count validation.",
-  "version": "1.0.0",
-  "author": {
-    "name": "Wave Team"
-  }
-}

package/builtin/plugins/sdd/hooks/hooks.json

@@ -1,14 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${WAVE_PLUGIN_ROOT}/scripts/session-start.js\""
-          }
-        ]
-      }
-    ]
-  }
-}

package/builtin/plugins/sdd/scripts/session-start.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-// SessionStart hook for the sdd built-in plugin.
-// Emits the spec-first workflow guidance as additionalContext (JSON form),
-// resolving the absolute path to the plugin's spec-count validator so the
-// agent can run it from its bash tool (which does not carry WAVE_PLUGIN_ROOT).
-import path from "node:path";
-
-const root =
-  process.env.WAVE_PLUGIN_ROOT ||
-  path.dirname(new URL("..", import.meta.url).pathname);
-const specCount = `node ${JSON.stringify(path.join(root, "scripts", "spec-count.js"))}`;
-
-const guidance = [
-  "Spec-First Workflow（规格优先工作流）：",
-  "- 需求增加或变更时，优先更新 spec：先更新对应规格说明（新增用户故事、验收场景），待用户确认 spec 后再实现代码。spec 是功能设计的权威来源，不是 changelog。",
-  "- 边界模糊时也先写 spec 草稿请用户确认，不要直接改代码。",
-  "- 规格编写技能（specify）由 AI 自动触发：对话中涉及新需求或需求变更时主动创建或更新规格文件，不需要用户手动调用（不出现在斜杠命令列表中）。",
-  `- 新增或修改 spec 后运行校验：${specCount}（自动检测 docs/specs/，否则 specs/，否则退出）。`,
-].join("\n");
-
-// JSON form → parsed as hookSpecificOutput.additionalContext by the hook manager.
-console.log(
-  JSON.stringify({ hookSpecificOutput: { additionalContext: guidance } }),
-);